34c - AI辅助游戏逻辑

简单 FSM（Finite State Machine）
  ├── 枚举 + switch 实现
  ├── 适合：简单角色（3-5 个状态）
  └── 缺点：状态多时代码膨胀

状态模式（State Pattern）
  ├── 每个状态一个类/脚本
  ├── 适合：中等复杂度（5-15 个状态）
  └── 优点：开闭原则，易扩展

层级状态机（Hierarchical State Machine / HFSM）
  ├── 状态可嵌套子状态机
  ├── 适合：复杂角色（15+ 个状态）
  └── 优点：减少转换爆炸，逻辑分层

推栈状态机（Pushdown Automaton）
  ├── 状态栈，支持暂停/恢复
  ├── 适合：需要"返回上一状态"的场景
  └── 例如：暂停菜单、对话中断

// Unity C# - 角色状态机（枚举 + switch 模式）
// AI 提示词生成的典型输出
 
public enum PlayerState
{
    Idle,
    Running,
    Jumping,
    Falling,
    Attacking,
    Dashing,
    Hurt,
    Dead
}
 
public class PlayerStateMachine : MonoBehaviour
{
    [Header("状态机")]
    public PlayerState currentState = PlayerState.Idle;
    private PlayerState previousState;
 
    [Header("移动参数")]
    public float moveSpeed = 8f;
    public float jumpForce = 12f;
    public float dashSpeed = 20f;
    public float dashDuration = 0.2f;
 
    private Rigidbody2D rb;
    private Animator animator;
    private float dashTimer;
    private bool isGrounded;
 
    void Start()
    {
        rb = GetComponent<Rigidbody2D>();
        animator = GetComponent<Animator>();
        EnterState(PlayerState.Idle);
    }
 
    void Update()
    {
        UpdateState();
        CheckTransitions();
    }
 
    // --- 状态进入 ---
    void EnterState(PlayerState newState)
    {
        previousState = currentState;
        currentState = newState;
 
        switch (newState)
        {
            case PlayerState.Idle:
                rb.linearVelocity = new Vector2(0, rb.linearVelocity.y);
                animator.Play("Idle");
                break;
            case PlayerState.Running:
                animator.Play("Run");
                break;
            case PlayerState.Jumping:
                rb.linearVelocity = new Vector2(rb.linearVelocity.x, jumpForce);
                animator.Play("Jump");
                break;
            case PlayerState.Dashing:
                dashTimer = dashDuration;
                float dir = transform.localScale.x > 0 ? 1 : -1;
                rb.linearVelocity = new Vector2(dir * dashSpeed, 0);
                rb.gravityScale = 0;
                animator.Play("Dash");
                break;
            case PlayerState.Hurt:
                rb.linearVelocity = new Vector2(-transform.localScale.x * 5f, 3f);
                animator.Play("Hurt");
                break;
            case PlayerState.Dead:
                rb.linearVelocity = Vector2.zero;
                rb.simulated = false;
                animator.Play("Death");
                break;
        }
    }
 
    // --- 状态更新 ---
    void UpdateState()
    {
        switch (currentState)
        {
            case PlayerState.Running:
                float h = Input.GetAxisRaw("Horizontal");
                rb.linearVelocity = new Vector2(h * moveSpeed, rb.linearVelocity.y);
                if (h != 0) transform.localScale = new Vector3(
                    Mathf.Sign(h), 1, 1);
                break;
            case PlayerState.Dashing:
                dashTimer -= Time.deltaTime;
                if (dashTimer <= 0)
                {
                    rb.gravityScale = 1;
                    TransitionTo(PlayerState.Idle);
                }
                break;
        }
    }
 
    // --- 状态转换检查 ---
    void CheckTransitions()
    {
        if (currentState == PlayerState.Dead) return;
 
        float h = Input.GetAxisRaw("Horizontal");
 
        switch (currentState)
        {
            case PlayerState.Idle:
                if (Mathf.Abs(h) > 0.1f) TransitionTo(PlayerState.Running);
                if (Input.GetButtonDown("Jump") && isGrounded)
                    TransitionTo(PlayerState.Jumping);
                if (Input.GetButtonDown("Fire1"))
                    TransitionTo(PlayerState.Attacking);
                if (Input.GetKeyDown(KeyCode.LeftShift))
                    TransitionTo(PlayerState.Dashing);
                break;
            case PlayerState.Running:
                if (Mathf.Abs(h) < 0.1f) TransitionTo(PlayerState.Idle);
                if (Input.GetButtonDown("Jump") && isGrounded)
                    TransitionTo(PlayerState.Jumping);
                if (Input.GetKeyDown(KeyCode.LeftShift))
                    TransitionTo(PlayerState.Dashing);
                break;
            case PlayerState.Jumping:
                if (rb.linearVelocity.y < 0) TransitionTo(PlayerState.Falling);
                break;
            case PlayerState.Falling:
                if (isGrounded) TransitionTo(PlayerState.Idle);
                break;
        }
    }
 
    void TransitionTo(PlayerState newState)
    {
        ExitState(currentState);
        EnterState(newState);
    }
 
    void ExitState(PlayerState state)
    {
        switch (state)
        {
            case PlayerState.Dashing:
                rb.gravityScale = 1;
                break;
        }
    }
 
    // 外部调用：受伤
    public void TakeDamage(int damage)
    {
        if (currentState == PlayerState.Dashing) return; // 冲刺无敌
        TransitionTo(PlayerState.Hurt);
        Invoke(nameof(RecoverFromHurt), 0.5f);
    }
 
    void RecoverFromHurt() => TransitionTo(PlayerState.Idle);
}

# Godot GDScript - 状态模式（每个状态一个脚本）
# 基类：State.gd
 
class_name State
extends Node
 
# 状态机引用，由 StateMachine 自动注入
var state_machine: StateMachine
var player: CharacterBody2D
 
# 虚方法：子类重写
func enter() -> void:
    pass
 
func exit() -> void:
    pass
 
func update(delta: float) -> void:
    pass
 
func physics_update(delta: float) -> void:
    pass
 
func handle_input(event: InputEvent) -> void:
    pass

# StateMachine.gd - 状态机管理器
 
class_name StateMachine
extends Node
 
@export var initial_state: State
@export var player: CharacterBody2D
 
var current_state: State
var states: Dictionary = {}
 
func _ready() -> void:
    # 注册所有子节点状态
    for child in get_children():
        if child is State:
            states[child.name.to_lower()] = child
            child.state_machine = self
            child.player = player
 
    # 进入初始状态
    if initial_state:
        current_state = initial_state
        current_state.enter()
 
func _process(delta: float) -> void:
    if current_state:
        current_state.update(delta)
 
func _physics_process(delta: float) -> void:
    if current_state:
        current_state.physics_update(delta)
 
func _unhandled_input(event: InputEvent) -> void:
    if current_state:
        current_state.handle_input(event)
 
func transition_to(state_name: String) -> void:
    var new_state = states.get(state_name.to_lower())
    if new_state == null:
        push_warning("状态不存在: " + state_name)
        return
    if new_state == current_state:
        return
 
    current_state.exit()
    current_state = new_state
    current_state.enter()
    print("状态转换: -> ", state_name)

# IdleState.gd - 空闲状态
 
extends State
 
func enter() -> void:
    player.get_node("AnimationPlayer").play("idle")
 
func physics_update(delta: float) -> void:
    # 应用重力
    if not player.is_on_floor():
        player.velocity.y += player.gravity * delta
 
    player.velocity.x = move_toward(player.velocity.x, 0, player.friction)
    player.move_and_slide()
 
func handle_input(event: InputEvent) -> void:
    if event.is_action_pressed("move_left") or event.is_action_pressed("move_right"):
        state_machine.transition_to("run")
    elif event.is_action_pressed("jump") and player.is_on_floor():
        state_machine.transition_to("jump")
    elif event.is_action_pressed("attack"):
        state_machine.transition_to("attack")
    elif event.is_action_pressed("dash"):
        state_machine.transition_to("dash")

# RunState.gd - 奔跑状态
 
extends State
 
func enter() -> void:
    player.get_node("AnimationPlayer").play("run")
 
func physics_update(delta: float) -> void:
    var direction = Input.get_axis("move_left", "move_right")
 
    if direction != 0:
        player.velocity.x = direction * player.move_speed
        player.get_node("Sprite2D").flip_h = direction < 0
    else:
        state_machine.transition_to("idle")
        return
 
    if not player.is_on_floor():
        player.velocity.y += player.gravity * delta
        state_machine.transition_to("fall")
        return
 
    player.move_and_slide()
 
func handle_input(event: InputEvent) -> void:
    if event.is_action_pressed("jump") and player.is_on_floor():
        state_machine.transition_to("jump")
    elif event.is_action_pressed("attack"):
        state_machine.transition_to("attack")
    elif event.is_action_pressed("dash"):
        state_machine.transition_to("dash")

// Unreal Engine C++ - 层级状态机框架
// GameplayState.h
 
#pragma once
#include "CoreMinimal.h"
#include "GameplayState.generated.h"
 
UCLASS(Abstract, Blueprintable)
class MYGAME_API UGameplayState : public UObject
{
    GENERATED_BODY()
 
public:
    // 状态生命周期
    UFUNCTION(BlueprintNativeEvent)
    void OnEnter();
 
    UFUNCTION(BlueprintNativeEvent)
    void OnExit();
 
    UFUNCTION(BlueprintNativeEvent)
    void OnUpdate(float DeltaTime);
 
    // 子状态机支持（HFSM 核心）
    UPROPERTY()
    class UHierarchicalStateMachine* SubStateMachine;
 
    UPROPERTY()
    class ACharacter* OwnerCharacter;
 
    // 状态名称
    UPROPERTY(EditAnywhere, BlueprintReadOnly)
    FName StateName;
};
 
// HierarchicalStateMachine.h
 
UCLASS(BlueprintType)
class MYGAME_API UHierarchicalStateMachine : public UObject
{
    GENERATED_BODY()
 
public:
    void Initialize(ACharacter* Owner);
    void Update(float DeltaTime);
 
    UFUNCTION(BlueprintCallable)
    void TransitionTo(FName StateName);
 
    UFUNCTION(BlueprintCallable)
    void AddState(FName Name, TSubclassOf<UGameplayState> StateClass);
 
    UFUNCTION(BlueprintCallable)
    FName GetCurrentStateName() const;
 
private:
    UPROPERTY()
    TMap<FName, UGameplayState*> States;
 
    UPROPERTY()
    UGameplayState* CurrentState;
 
    UPROPERTY()
    ACharacter* OwnerCharacter;
};
 
// HierarchicalStateMachine.cpp
 
void UHierarchicalStateMachine::Initialize(ACharacter* Owner)
{
    OwnerCharacter = Owner;
}
 
void UHierarchicalStateMachine::Update(float DeltaTime)
{
    if (CurrentState)
    {
        CurrentState->OnUpdate(DeltaTime);
 
        // 递归更新子状态机
        if (CurrentState->SubStateMachine)
        {
            CurrentState->SubStateMachine->Update(DeltaTime);
        }
    }
}
 
void UHierarchicalStateMachine::TransitionTo(FName StateName)
{
    UGameplayState** FoundState = States.Find(StateName);
    if (!FoundState) return;
 
    if (CurrentState)
    {
        // 退出子状态机
        if (CurrentState->SubStateMachine)
        {
            CurrentState->SubStateMachine->TransitionTo(NAME_None);
        }
        CurrentState->OnExit();
    }
 
    CurrentState = *FoundState;
    CurrentState->OnEnter();
 
    UE_LOG(LogTemp, Log, TEXT("HFSM 转换: -> %s"), *StateName.ToString());
}
 
void UHierarchicalStateMachine::AddState(
    FName Name, TSubclassOf<UGameplayState> StateClass)
{
    UGameplayState* NewState = NewObject<UGameplayState>(
        this, StateClass);
    NewState->StateName = Name;
    NewState->OwnerCharacter = OwnerCharacter;
    States.Add(Name, NewState);
}

你是一个 [Unity C# / Godot GDScript / Unreal C++] 游戏开发专家。

请为 [角色类型，如：2D 平台跳跃角色] 生成一个完整的有限状态机（FSM）。

角色状态需求：
- [列出所有状态，如：Idle, Run, Jump, Fall, Attack, Dash, Hurt, Dead]

每个状态需要：
1. 进入动作（播放动画、设置参数）
2. 更新逻辑（每帧执行的行为）
3. 退出动作（清理资源）
4. 转换条件（什么条件下转到哪个状态）

物理参数：
- 移动速度：[X] 单位/秒
- 跳跃力：[Y]
- 重力：[Z]

要求：
- 使用 [枚举+switch / 状态模式 / 层级状态机] 架构
- 包含完整的输入处理
- 包含动画播放调用
- 代码注释使用中文

请为 [RPG 角色 / 动作游戏 Boss] 设计一个层级状态机（HFSM）。

顶层状态：
- Exploration（探索）
  - 子状态：Idle, Walk, Run, Interact
- Combat（战斗）
  - 子状态：Engage, Attack, Defend, Dodge, Skill
- Cutscene（过场）
  - 子状态：Dialogue, Animation

转换规则：
- Exploration -> Combat：检测到敌人进入 [范围]
- Combat -> Exploration：所有敌人被消灭或脱离战斗 [时间] 秒
- 任意 -> Cutscene：触发剧情事件

要求：
- 顶层状态机管理大状态切换
- 每个大状态内部有独立的子状态机
- 子状态机在父状态退出时自动重置
- 提供状态转换的 Mermaid 图

请审查以下状态机代码，检查：

1. 是否存在"状态转换爆炸"（N 个状态需要 N² 个转换）
2. 是否有遗漏的状态转换（死锁风险）
3. 是否正确处理了边界情况（如：空中受伤、攻击中被打断）
4. 性能问题（每帧不必要的检查）
5. 是否适合重构为层级状态机

代码：
[粘贴现有状态机代码]

请给出具体的改进建议和重构后的代码。

// Unity C# - 完整碰撞检测与响应系统
 
public class CollisionManager : MonoBehaviour
{
    [Header("碰撞层配置")]
    public LayerMask groundLayer;
    public LayerMask enemyLayer;
    public LayerMask collectibleLayer;
 
    [Header("地面检测")]
    public Transform groundCheck;
    public float groundCheckRadius = 0.2f;
 
    [Header("墙壁检测")]
    public Transform wallCheck;
    public float wallCheckDistance = 0.5f;
 
    // 地面检测（OverlapCircle）
    public bool IsGrounded()
    {
        return Physics2D.OverlapCircle(
            groundCheck.position,
            groundCheckRadius,
            groundLayer
        );
    }
 
    // 墙壁检测（Raycast）
    public bool IsTouchingWall()
    {
        float direction = transform.localScale.x;
        RaycastHit2D hit = Physics2D.Raycast(
            wallCheck.position,
            Vector2.right * direction,
            wallCheckDistance,
            groundLayer
        );
        return hit.collider != null;
    }
 
    // 扇形范围检测（攻击判定）
    public Collider2D[] DetectEnemiesInArc(
        float radius, float angle, Vector2 direction)
    {
        Collider2D[] allEnemies = Physics2D.OverlapCircleAll(
            transform.position, radius, enemyLayer);
 
        return System.Array.FindAll(allEnemies, enemy =>
        {
            Vector2 toEnemy =
                (enemy.transform.position - transform.position).normalized;
            float angleBetween = Vector2.Angle(direction, toEnemy);
            return angleBetween <= angle / 2f;
        });
    }
 
    // 触发器碰撞回调
    void OnTriggerEnter2D(Collider2D other)
    {
        // 收集物品
        if (((1 << other.gameObject.layer) & collectibleLayer) != 0)
        {
            ICollectible collectible =
                other.GetComponent<ICollectible>();
            collectible?.Collect(gameObject);
        }
 
        // 伤害区域
        if (other.CompareTag("DamageZone"))
        {
            DamageZone zone = other.GetComponent<DamageZone>();
            GetComponent<HealthSystem>()?.TakeDamage(zone.damage);
        }
    }
 
    // 碰撞体碰撞回调（物理碰撞）
    void OnCollisionEnter2D(Collision2D collision)
    {
        // 获取碰撞信息
        ContactPoint2D contact = collision.GetContact(0);
        Vector2 normal = contact.normal;
        float impactForce = collision.relativeVelocity.magnitude;
 
        // 高速碰撞伤害
        if (impactForce > 15f)
        {
            float damage = (impactForce - 15f) * 2f;
            GetComponent<HealthSystem>()?.TakeDamage(damage);
        }
 
        // 碰撞粒子效果
        if (impactForce > 5f)
        {
            ParticleSystem particles =
                Instantiate(impactParticles, contact.point,
                    Quaternion.LookRotation(normal));
            Destroy(particles.gameObject, 2f);
        }
    }
 
    // 可视化调试
    void OnDrawGizmosSelected()
    {
        if (groundCheck != null)
        {
            Gizmos.color = Color.green;
            Gizmos.DrawWireSphere(groundCheck.position, groundCheckRadius);
        }
        if (wallCheck != null)
        {
            Gizmos.color = Color.red;
            float dir = transform.localScale.x;
            Gizmos.DrawRay(wallCheck.position,
                Vector2.right * dir * wallCheckDistance);
        }
    }
 
    [SerializeField] private ParticleSystem impactParticles;
}
 
// 可收集物品接口
public interface ICollectible
{
    void Collect(GameObject collector);
}

# Godot GDScript - 角色物理控制器
# CharacterController.gd
 
extends CharacterBody2D
 
# 移动参数
@export var move_speed: float = 300.0
@export var jump_force: float = -500.0
@export var gravity: float = 1200.0
@export var max_fall_speed: float = 800.0
 
# 高级物理参数
@export var acceleration: float = 2000.0
@export var friction: float = 1500.0
@export var air_friction: float = 200.0
@export var coyote_time: float = 0.1  # 土狼时间（离开平台后仍可跳跃）
@export var jump_buffer_time: float = 0.15  # 跳跃缓冲
 
# 内部状态
var coyote_timer: float = 0.0
var jump_buffer_timer: float = 0.0
var was_on_floor: bool = false
 
# 射线检测节点
@onready var ground_ray_left: RayCast2D = $GroundRayLeft
@onready var ground_ray_right: RayCast2D = $GroundRayRight
@onready var wall_ray: RayCast2D = $WallRay
 
func _physics_process(delta: float) -> void:
    _apply_gravity(delta)
    _handle_movement(delta)
    _handle_jump()
    _update_timers(delta)
    move_and_slide()
    _check_landing()
 
func _apply_gravity(delta: float) -> void:
    if not is_on_floor():
        velocity.y += gravity * delta
        velocity.y = min(velocity.y, max_fall_speed)
 
func _handle_movement(delta: float) -> void:
    var direction = Input.get_axis("move_left", "move_right")
 
    if direction != 0:
        # 加速
        velocity.x = move_toward(
            velocity.x, direction * move_speed, acceleration * delta)
        # 翻转精灵
        $Sprite2D.flip_h = direction < 0
    else:
        # 减速（地面摩擦 vs 空气阻力）
        var current_friction = friction if is_on_floor() else air_friction
        velocity.x = move_toward(velocity.x, 0, current_friction * delta)
 
func _handle_jump() -> void:
    # 跳跃缓冲：提前按跳跃键
    if Input.is_action_just_pressed("jump"):
        jump_buffer_timer = jump_buffer_time
 
    # 可以跳跃的条件：在地面 或 土狼时间内
    var can_jump = is_on_floor() or coyote_timer > 0
 
    if jump_buffer_timer > 0 and can_jump:
        velocity.y = jump_force
        jump_buffer_timer = 0
        coyote_timer = 0
 
    # 短按跳跃（松开按键时减速）
    if Input.is_action_just_released("jump") and velocity.y < 0:
        velocity.y *= 0.5
 
func _update_timers(delta: float) -> void:
    # 土狼时间计时器
    if is_on_floor():
        coyote_timer = coyote_time
    else:
        coyote_timer -= delta
 
    # 跳跃缓冲计时器
    if jump_buffer_timer > 0:
        jump_buffer_timer -= delta
 
func _check_landing() -> void:
    # 检测着陆（用于播放着陆效果）
    if is_on_floor() and not was_on_floor:
        _on_landed()
    was_on_floor = is_on_floor()
 
func _on_landed() -> void:
    # 着陆粒子效果
    $LandingParticles.emitting = true
    # 着陆音效
    $LandingSFX.play()
 
# --- 射线检测工具方法 ---
 
func is_near_wall() -> bool:
    """检测是否靠近墙壁"""
    wall_ray.target_position.x = 20 if not $Sprite2D.flip_h else -20
    wall_ray.force_raycast_update()
    return wall_ray.is_colliding()
 
func get_ground_normal() -> Vector2:
    """获取地面法线（用于斜坡处理）"""
    if ground_ray_left.is_colliding():
        return ground_ray_left.get_collision_normal()
    elif ground_ray_right.is_colliding():
        return ground_ray_right.get_collision_normal()
    return Vector2.UP
 
func detect_enemies_in_range(radius: float) -> Array[Node2D]:
    """检测范围内的敌人"""
    var space = get_world_2d().direct_space_state
    var query = PhysicsShapeQueryParameters2D.new()
    var circle = CircleShape2D.new()
    circle.radius = radius
    query.shape = circle
    query.transform = global_transform
    query.collision_mask = 0b0100  # 敌人层
 
    var results = space.intersect_shape(query)
    var enemies: Array[Node2D] = []
    for result in results:
        enemies.append(result.collider)
    return enemies

// Unity C# - 刚体物理交互系统
 
public class PhysicsInteraction : MonoBehaviour
{
    [Header("推动物体")]
    public float pushForce = 5f;
    public float maxPushSpeed = 3f;
 
    [Header("爆炸力")]
    public float explosionForce = 500f;
    public float explosionRadius = 5f;
    public float explosionUpward = 1f;
 
    [Header("吸引力")]
    public float attractForce = 10f;
    public float attractRadius = 8f;
 
    // 推动可移动物体
    void OnControllerColliderHit(ControllerColliderHit hit)
    {
        Rigidbody rb = hit.collider.attachedRigidbody;
        if (rb == null || rb.isKinematic) return;
 
        // 不推动脚下的物体
        if (hit.moveDirection.y < -0.3f) return;
 
        Vector3 pushDir = new Vector3(hit.moveDirection.x, 0, hit.moveDirection.z);
        rb.AddForce(pushDir * pushForce, ForceMode.Impulse);
 
        // 限制最大速度
        if (rb.linearVelocity.magnitude > maxPushSpeed)
            rb.linearVelocity = rb.linearVelocity.normalized * maxPushSpeed;
    }
 
    // 爆炸效果
    public void CreateExplosion(Vector3 position)
    {
        Collider[] colliders = Physics.OverlapSphere(
            position, explosionRadius);
 
        foreach (Collider col in colliders)
        {
            Rigidbody rb = col.GetComponent<Rigidbody>();
            if (rb != null)
            {
                rb.AddExplosionForce(
                    explosionForce, position,
                    explosionRadius, explosionUpward,
                    ForceMode.Impulse);
            }
 
            // 对可破坏物体造成伤害
            IDestructible destructible =
                col.GetComponent<IDestructible>();
            if (destructible != null)
            {
                float distance = Vector3.Distance(
                    position, col.transform.position);
                float damagePercent = 1f - (distance / explosionRadius);
                destructible.TakeDamage(
                    explosionForce * damagePercent * 0.1f);
            }
        }
    }
 
    // 磁力吸引（每帧调用）
    public void ApplyAttraction(Vector3 center)
    {
        Collider[] colliders = Physics.OverlapSphere(
            center, attractRadius);
 
        foreach (Collider col in colliders)
        {
            Rigidbody rb = col.GetComponent<Rigidbody>();
            if (rb == null || rb.isKinematic) return;
 
            Vector3 direction =
                (center - col.transform.position).normalized;
            float distance = Vector3.Distance(
                center, col.transform.position);
            // 距离越近，力越大（反平方律）
            float forceMagnitude =
                attractForce / (distance * distance + 0.1f);
            rb.AddForce(direction * forceMagnitude);
        }
    }
}
 
public interface IDestructible
{
    void TakeDamage(float damage);
}

# Godot GDScript - 射线检测工具集
# RaycastUtils.gd
 
extends Node
 
# --- 单射线检测 ---
static func raycast_2d(
    space_state: PhysicsDirectSpaceState2D,
    from: Vector2,
    to: Vector2,
    collision_mask: int = 0xFFFFFFFF,
    exclude: Array[RID] = []
) -> Dictionary:
    """执行 2D 射线检测，返回碰撞信息"""
    var query = PhysicsRayQueryParameters2D.create(from, to)
    query.collision_mask = collision_mask
    query.exclude = exclude
    return space_state.intersect_ray(query)
 
# --- 扇形射线检测（视野锥） ---
static func cone_cast_2d(
    space_state: PhysicsDirectSpaceState2D,
    origin: Vector2,
    direction: Vector2,
    distance: float,
    half_angle_deg: float,
    ray_count: int = 12,
    collision_mask: int = 0xFFFFFFFF
) -> Array[Dictionary]:
    """扇形射线检测，用于 NPC 视野检测"""
    var results: Array[Dictionary] = []
    var half_angle = deg_to_rad(half_angle_deg)
    var base_angle = direction.angle()
 
    for i in range(ray_count):
        var t = float(i) / float(ray_count - 1) if ray_count > 1 else 0.5
        var angle = base_angle - half_angle + t * 2.0 * half_angle
        var end = origin + Vector2.from_angle(angle) * distance
 
        var result = raycast_2d(space_state, origin, end, collision_mask)
        if result:
            results.append(result)
 
    return results
 
# --- 地面法线检测（斜坡适配） ---
static func get_ground_info(
    space_state: PhysicsDirectSpaceState2D,
    position: Vector2,
    ground_mask: int
) -> Dictionary:
    """获取脚下地面信息：法线、角度、材质"""
    var result = raycast_2d(
        space_state, position, position + Vector2.DOWN * 50, ground_mask)
 
    if result:
        var normal: Vector2 = result.normal
        var angle = rad_to_deg(normal.angle_to(Vector2.UP))
        return {
            "hit": true,
            "point": result.position,
            "normal": normal,
            "angle": angle,
            "collider": result.collider,
            "is_slope": abs(angle) > 5.0,
            "is_steep": abs(angle) > 45.0
        }
    return {"hit": false}

请为 [2D 平台游戏 / 3D 动作游戏] 生成完整的碰撞检测系统。

引擎：[Unity / Godot / Unreal]

需要的碰撞检测功能：
1. 地面检测（支持斜坡，角度阈值 [X] 度）
2. 墙壁检测（左右两侧）
3. 天花板检测
4. 敌人范围检测（圆形/扇形，半径 [R]）
5. 射线检测（武器瞄准线、视线检查）

碰撞层设置：
- Layer 0: Default
- Layer 1: Player
- Layer 2: Enemy
- Layer 3: Ground/Wall
- Layer 4: Collectible
- Layer 5: Projectile

要求：
- 使用引擎原生物理 API
- 包含 Gizmo/Debug 可视化
- 性能优化（避免每帧 OverlapAll）
- 包含碰撞回调处理

我的 [2D 平台跳跃 / 3D 第三人称] 游戏角色物理手感不好。

当前参数：
- 移动速度：[X]
- 跳跃力：[Y]
- 重力：[Z]
- 加速度：[A]
- 摩擦力：[F]

问题描述：
[描述具体问题，如：跳跃感觉太飘、移动太滑、落地太硬]

参考游戏手感：[如：Celeste 的精确操控 / Hollow Knight 的沉重感]

请：
1. 分析当前参数的问题
2. 推荐调整后的参数值
3. 解释每个参数变化的原因
4. 提供额外的物理技巧（如：土狼时间、跳跃缓冲、可变跳跃高度）

行为树节点
├── 组合节点（Composite）
│   ├── Selector（选择器）：依次尝试子节点，第一个成功即返回成功
│   ├── Sequence（序列）：依次执行子节点，全部成功才返回成功
│   ├── Parallel（并行）：同时执行所有子节点
│   └── RandomSelector（随机选择器）：随机选择一个子节点执行
│
├── 装饰器节点（Decorator）
│   ├── Inverter（取反）：反转子节点结果
│   ├── Repeater（重复器）：重复执行子节点 N 次
│   ├── Limiter（限制器）：限制执行频率
│   ├── Cooldown（冷却）：执行后等待一段时间
│   ├── TimeLimit（时间限制）：超时返回失败
│   └── Condition（条件守卫）：条件满足才执行子节点
│
└── 叶节点（Leaf）
    ├── Action（动作）：执行具体行为（移动、攻击、播放动画）
    └── Condition（条件）：检查条件（血量、距离、视线）

// Unity C# - 轻量行为树框架
 
// 节点状态枚举
public enum NodeStatus
{
    Success,
    Failure,
    Running
}
 
// 行为树节点基类
public abstract class BTNode
{
    public string Name { get; set; }
    protected Blackboard blackboard;
 
    public BTNode(string name, Blackboard blackboard)
    {
        Name = name;
        this.blackboard = blackboard;
    }
 
    public abstract NodeStatus Tick(float deltaTime);
    public virtual void Reset() { }
}
 
// 黑板（共享数据）
public class Blackboard
{
    private Dictionary<string, object> data = new();
 
    public void Set<T>(string key, T value) => data[key] = value;
 
    public T Get<T>(string key, T defaultValue = default)
    {
        if (data.TryGetValue(key, out object value))
            return (T)value;
        return defaultValue;
    }
 
    public bool Has(string key) => data.ContainsKey(key);
}
 
// --- 组合节点 ---
 
// 选择器：依次尝试，第一个成功即返回
public class Selector : BTNode
{
    private List<BTNode> children;
    private int currentChild = 0;
 
    public Selector(string name, Blackboard bb,
        params BTNode[] children) : base(name, bb)
    {
        this.children = new List<BTNode>(children);
    }
 
    public override NodeStatus Tick(float deltaTime)
    {
        while (currentChild < children.Count)
        {
            var status = children[currentChild].Tick(deltaTime);
 
            switch (status)
            {
                case NodeStatus.Success:
                    currentChild = 0;
                    return NodeStatus.Success;
                case NodeStatus.Running:
                    return NodeStatus.Running;
                case NodeStatus.Failure:
                    currentChild++;
                    break;
            }
        }
 
        currentChild = 0;
        return NodeStatus.Failure;
    }
 
    public override void Reset()
    {
        currentChild = 0;
        foreach (var child in children) child.Reset();
    }
}
 
// 序列：依次执行，全部成功才返回成功
public class Sequence : BTNode
{
    private List<BTNode> children;
    private int currentChild = 0;
 
    public Sequence(string name, Blackboard bb,
        params BTNode[] children) : base(name, bb)
    {
        this.children = new List<BTNode>(children);
    }
 
    public override NodeStatus Tick(float deltaTime)
    {
        while (currentChild < children.Count)
        {
            var status = children[currentChild].Tick(deltaTime);
 
            switch (status)
            {
                case NodeStatus.Success:
                    currentChild++;
                    break;
                case NodeStatus.Running:
                    return NodeStatus.Running;
                case NodeStatus.Failure:
                    currentChild = 0;
                    return NodeStatus.Failure;
            }
        }
 
        currentChild = 0;
        return NodeStatus.Success;
    }
 
    public override void Reset()
    {
        currentChild = 0;
        foreach (var child in children) child.Reset();
    }
}
 
// --- 装饰器节点 ---
 
// 取反器
public class Inverter : BTNode
{
    private BTNode child;
 
    public Inverter(string name, Blackboard bb,
        BTNode child) : base(name, bb)
    {
        this.child = child;
    }
 
    public override NodeStatus Tick(float deltaTime)
    {
        var status = child.Tick(deltaTime);
        return status switch
        {
            NodeStatus.Success => NodeStatus.Failure,
            NodeStatus.Failure => NodeStatus.Success,
            _ => NodeStatus.Running
        };
    }
}
 
// 冷却装饰器
public class Cooldown : BTNode
{
    private BTNode child;
    private float cooldownTime;
    private float timer;
 
    public Cooldown(string name, Blackboard bb,
        BTNode child, float cooldownTime) : base(name, bb)
    {
        this.child = child;
        this.cooldownTime = cooldownTime;
    }
 
    public override NodeStatus Tick(float deltaTime)
    {
        timer -= deltaTime;
        if (timer > 0) return NodeStatus.Failure;
 
        var status = child.Tick(deltaTime);
        if (status == NodeStatus.Success)
            timer = cooldownTime;
        return status;
    }
}
 
// --- 叶节点示例 ---
 
// 条件：检查目标是否在范围内
public class IsTargetInRange : BTNode
{
    private float range;
 
    public IsTargetInRange(Blackboard bb, float range)
        : base("IsTargetInRange", bb)
    {
        this.range = range;
    }
 
    public override NodeStatus Tick(float deltaTime)
    {
        var self = blackboard.Get<Transform>("self");
        var target = blackboard.Get<Transform>("target");
        if (self == null || target == null)
            return NodeStatus.Failure;
 
        float distance = Vector3.Distance(
            self.position, target.position);
        return distance <= range
            ? NodeStatus.Success
            : NodeStatus.Failure;
    }
}
 
// 动作：移动到目标
public class MoveToTarget : BTNode
{
    private float speed;
    private float stoppingDistance;
 
    public MoveToTarget(Blackboard bb,
        float speed, float stoppingDistance)
        : base("MoveToTarget", bb)
    {
        this.speed = speed;
        this.stoppingDistance = stoppingDistance;
    }
 
    public override NodeStatus Tick(float deltaTime)
    {
        var self = blackboard.Get<Transform>("self");
        var target = blackboard.Get<Transform>("target");
        if (self == null || target == null)
            return NodeStatus.Failure;
 
        float distance = Vector3.Distance(
            self.position, target.position);
 
        if (distance <= stoppingDistance)
            return NodeStatus.Success;
 
        Vector3 direction =
            (target.position - self.position).normalized;
        self.position += direction * speed * deltaTime;
 
        // 面向目标
        self.rotation = Quaternion.LookRotation(direction);
 
        return NodeStatus.Running;
    }
}
 
// 动作：攻击
public class AttackTarget : BTNode
{
    private float attackDuration;
    private float damage;
    private float timer;
 
    public AttackTarget(Blackboard bb,
        float damage, float duration)
        : base("AttackTarget", bb)
    {
        this.damage = damage;
        this.attackDuration = duration;
    }
 
    public override NodeStatus Tick(float deltaTime)
    {
        timer += deltaTime;
 
        if (timer >= attackDuration)
        {
            // 造成伤害
            var target = blackboard.Get<Transform>("target");
            var health = target?.GetComponent<HealthSystem>();
            health?.TakeDamage(damage);
            timer = 0;
            return NodeStatus.Success;
        }
 
        return NodeStatus.Running;
    }
 
    public override void Reset() => timer = 0;
}

// Unity C# - 使用行为树框架构建 NPC AI
 
public class EnemyAI : MonoBehaviour
{
    [Header("AI 参数")]
    public float detectionRange = 15f;
    public float attackRange = 2f;
    public float moveSpeed = 5f;
    public float attackDamage = 10f;
    public float attackCooldown = 1.5f;
    public float patrolSpeed = 2f;
    public Transform[] patrolPoints;
 
    private BTNode behaviorTree;
    private Blackboard blackboard;
 
    void Start()
    {
        blackboard = new Blackboard();
        blackboard.Set("self", transform);
        blackboard.Set("patrolPoints", patrolPoints);
        blackboard.Set("patrolIndex", 0);
 
        behaviorTree = BuildBehaviorTree();
    }
 
    void Update()
    {
        // 更新黑板数据
        UpdateBlackboard();
        // 执行行为树
        behaviorTree.Tick(Time.deltaTime);
    }
 
    void UpdateBlackboard()
    {
        // 寻找最近的玩家
        GameObject player = GameObject.FindGameObjectWithTag("Player");
        if (player != null)
        {
            blackboard.Set("target", player.transform);
            blackboard.Set("distanceToTarget",
                Vector3.Distance(transform.position,
                    player.transform.position));
        }
    }
 
    BTNode BuildBehaviorTree()
    {
        // 行为树结构：
        // Root (Selector)
        // ├── Combat (Sequence)
        // │   ├── IsTargetInRange(detectionRange)
        // │   └── Selector
        // │       ├── Attack (Sequence)
        // │       │   ├── IsTargetInRange(attackRange)
        // │       │   └── Cooldown(AttackTarget)
        // │       └── MoveToTarget
        // └── Patrol (Sequence)
        //     └── PatrolBetweenPoints
 
        var bb = blackboard;
 
        return new Selector("Root", bb,
            // 战斗分支
            new Sequence("Combat", bb,
                new IsTargetInRange(bb, detectionRange),
                new Selector("CombatAction", bb,
                    // 攻击
                    new Sequence("Attack", bb,
                        new IsTargetInRange(bb, attackRange),
                        new Cooldown("AttackCooldown", bb,
                            new AttackTarget(bb, attackDamage, 0.5f),
                            attackCooldown)
                    ),
                    // 追击
                    new MoveToTarget(bb, moveSpeed, attackRange * 0.8f)
                )
            ),
            // 巡逻分支
            new PatrolAction(bb, patrolSpeed)
        );
    }
}

# Godot GDScript - 使用 Beehave 插件构建 NPC AI
# 安装：在 AssetLib 搜索 "Beehave" 或通过 Git 子模块
 
# --- 自定义条件节点 ---
# IsPlayerInRange.gd
 
class_name IsPlayerInRange
extends ConditionLeaf
 
@export var detection_range: float = 200.0
 
func tick(actor: Node, blackboard: Blackboard) -> int:
    var player = blackboard.get_value("player")
    if player == null:
        return FAILURE
 
    var distance = actor.global_position.distance_to(
        player.global_position)
    blackboard.set_value("distance_to_player", distance)
 
    if distance <= detection_range:
        return SUCCESS
    return FAILURE

# IsPlayerInAttackRange.gd
 
class_name IsPlayerInAttackRange
extends ConditionLeaf
 
@export var attack_range: float = 50.0
 
func tick(actor: Node, blackboard: Blackboard) -> int:
    var distance = blackboard.get_value("distance_to_player", INF)
    if distance <= attack_range:
        return SUCCESS
    return FAILURE

# --- 自定义动作节点 ---
# ChasePlayer.gd
 
class_name ChasePlayer
extends ActionLeaf
 
@export var chase_speed: float = 150.0
 
func tick(actor: Node, blackboard: Blackboard) -> int:
    var player = blackboard.get_value("player")
    if player == null:
        return FAILURE
 
    var direction = (player.global_position - actor.global_position).normalized
    actor.velocity = direction * chase_speed
 
    # 翻转精灵
    if direction.x != 0:
        actor.get_node("Sprite2D").flip_h = direction.x < 0
 
    actor.get_node("AnimationPlayer").play("run")
    actor.move_and_slide()
 
    return RUNNING

# AttackPlayer.gd
 
class_name AttackPlayer
extends ActionLeaf
 
@export var damage: float = 10.0
@export var attack_duration: float = 0.5
var timer: float = 0.0
 
func tick(actor: Node, blackboard: Blackboard) -> int:
    timer += actor.get_process_delta_time()
 
    if timer <= 0.01:  # 攻击开始
        actor.get_node("AnimationPlayer").play("attack")
        actor.velocity = Vector2.ZERO
 
    if timer >= attack_duration:
        # 造成伤害
        var player = blackboard.get_value("player")
        if player and player.has_method("take_damage"):
            player.take_damage(damage)
        timer = 0.0
        return SUCCESS
 
    return RUNNING
 
func _on_reset() -> void:
    timer = 0.0

# PatrolAction.gd
 
class_name PatrolAction
extends ActionLeaf
 
@export var patrol_speed: float = 80.0
@export var wait_time: float = 2.0
 
var current_point_index: int = 0
var waiting: bool = false
var wait_timer: float = 0.0
 
func tick(actor: Node, blackboard: Blackboard) -> int:
    var patrol_points = blackboard.get_value("patrol_points", [])
    if patrol_points.is_empty():
        return FAILURE
 
    if waiting:
        wait_timer += actor.get_process_delta_time()
        if wait_timer >= wait_time:
            waiting = false
            wait_timer = 0.0
            current_point_index = (current_point_index + 1) % patrol_points.size()
        return RUNNING
 
    var target_pos: Vector2 = patrol_points[current_point_index].global_position
    var direction = (target_pos - actor.global_position).normalized
    var distance = actor.global_position.distance_to(target_pos)
 
    if distance < 10.0:
        waiting = true
        actor.velocity = Vector2.ZERO
        actor.get_node("AnimationPlayer").play("idle")
        return RUNNING
 
    actor.velocity = direction * patrol_speed
    actor.get_node("Sprite2D").flip_h = direction.x < 0
    actor.get_node("AnimationPlayer").play("walk")
    actor.move_and_slide()
 
    return RUNNING

# EnemyAI.gd - 敌人主脚本（场景树中配置 Beehave 节点）
 
extends CharacterBody2D
 
@export var gravity: float = 980.0
 
@onready var behavior_tree: BeehaveTree = $BeehaveTree
 
func _ready() -> void:
    # 初始化黑板数据
    var blackboard = behavior_tree.blackboard
    blackboard.set_value("patrol_points", $PatrolPoints.get_children())
 
    # 查找玩家
    var player = get_tree().get_first_node_in_group("player")
    blackboard.set_value("player", player)
 
func _physics_process(delta: float) -> void:
    # 应用重力
    if not is_on_floor():
        velocity.y += gravity * delta
    move_and_slide()
 
func take_damage(amount: float) -> void:
    $HealthComponent.take_damage(amount)

EnemyAI (CharacterBody2D)
├── Sprite2D
├── CollisionShape2D
├── AnimationPlayer
├── PatrolPoints
│   ├── Point1 (Marker2D)
│   └── Point2 (Marker2D)
└── BeehaveTree
    └── SelectorComposite (Root)
        ├── SequenceComposite (Combat)
        │   ├── IsPlayerInRange (detection_range=200)
        │   └── SelectorComposite (CombatAction)
        │       ├── SequenceComposite (Attack)
        │       │   ├── IsPlayerInAttackRange (attack_range=50)
        │       │   └── AttackPlayer (damage=10)
        │       └── ChasePlayer (chase_speed=150)
        └── PatrolAction (patrol_speed=80)

// Unreal Engine C++ - 自定义行为树任务（BTTask）
// BTTask_FindPatrolPoint.h
 
#pragma once
#include "BehaviorTree/BTTaskNode.h"
#include "BTTask_FindPatrolPoint.generated.h"
 
UCLASS()
class MYGAME_API UBTTask_FindPatrolPoint : public UBTTaskNode
{
    GENERATED_BODY()
 
public:
    UBTTask_FindPatrolPoint();
 
    virtual EBTNodeResult::Type ExecuteTask(
        UBehaviorTreeComponent& OwnerComp,
        uint8* NodeMemory) override;
 
    // 黑板键：巡逻点位置
    UPROPERTY(EditAnywhere, Category = "Blackboard")
    FBlackboardKeySelector PatrolLocationKey;
 
    // 巡逻半径
    UPROPERTY(EditAnywhere, Category = "Patrol")
    float PatrolRadius = 500.0f;
};
 
// BTTask_FindPatrolPoint.cpp
 
UBTTask_FindPatrolPoint::UBTTask_FindPatrolPoint()
{
    NodeName = TEXT("Find Patrol Point");
}
 
EBTNodeResult::Type UBTTask_FindPatrolPoint::ExecuteTask(
    UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory)
{
    AAIController* AIController = OwnerComp.GetAIOwner();
    if (!AIController) return EBTNodeResult::Failed;
 
    APawn* AIPawn = AIController->GetPawn();
    if (!AIPawn) return EBTNodeResult::Failed;
 
    // 在巡逻半径内随机选择一个可导航点
    UNavigationSystemV1* NavSys =
        UNavigationSystemV1::GetCurrent(GetWorld());
    if (!NavSys) return EBTNodeResult::Failed;
 
    FNavLocation RandomLocation;
    bool bFound = NavSys->GetRandomReachablePointInRadius(
        AIPawn->GetActorLocation(),
        PatrolRadius,
        RandomLocation);
 
    if (bFound)
    {
        OwnerComp.GetBlackboardComponent()->SetValueAsVector(
            PatrolLocationKey.SelectedKeyName,
            RandomLocation.Location);
        return EBTNodeResult::Succeeded;
    }
 
    return EBTNodeResult::Failed;
}

// BTTask_AttackTarget.h - 攻击任务
 
#pragma once
#include "BehaviorTree/BTTaskNode.h"
#include "BTTask_AttackTarget.generated.h"
 
UCLASS()
class MYGAME_API UBTTask_AttackTarget : public UBTTaskNode
{
    GENERATED_BODY()
 
public:
    virtual EBTNodeResult::Type ExecuteTask(
        UBehaviorTreeComponent& OwnerComp,
        uint8* NodeMemory) override;
 
    virtual void TickTask(
        UBehaviorTreeComponent& OwnerComp,
        uint8* NodeMemory, float DeltaSeconds) override;
 
    UPROPERTY(EditAnywhere, Category = "Attack")
    float AttackDamage = 20.0f;
 
    UPROPERTY(EditAnywhere, Category = "Attack")
    float AttackDuration = 1.0f;
 
    UPROPERTY(EditAnywhere, Category = "Attack")
    UAnimMontage* AttackMontage;
 
private:
    float AttackTimer = 0.0f;
    bool bDamageApplied = false;
};
 
// BTTask_AttackTarget.cpp
 
EBTNodeResult::Type UBTTask_AttackTarget::ExecuteTask(
    UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory)
{
    AAIController* AIController = OwnerComp.GetAIOwner();
    APawn* AIPawn = AIController ? AIController->GetPawn() : nullptr;
    if (!AIPawn) return EBTNodeResult::Failed;
 
    // 播放攻击动画
    if (AttackMontage)
    {
        UAnimInstance* AnimInstance =
            Cast<ACharacter>(AIPawn)->GetMesh()->GetAnimInstance();
        if (AnimInstance)
        {
            AnimInstance->Montage_Play(AttackMontage);
        }
    }
 
    AttackTimer = 0.0f;
    bDamageApplied = false;
    bNotifyTick = true;
 
    return EBTNodeResult::InProgress;
}
 
void UBTTask_AttackTarget::TickTask(
    UBehaviorTreeComponent& OwnerComp,
    uint8* NodeMemory, float DeltaSeconds)
{
    AttackTimer += DeltaSeconds;
 
    // 在攻击动画中间点造成伤害
    if (!bDamageApplied && AttackTimer >= AttackDuration * 0.4f)
    {
        AActor* Target = Cast<AActor>(
            OwnerComp.GetBlackboardComponent()->GetValueAsObject(
                TEXT("TargetActor")));
 
        if (Target)
        {
            UGameplayStatics::ApplyDamage(
                Target, AttackDamage,
                OwnerComp.GetAIOwner(),
                OwnerComp.GetAIOwner()->GetPawn(),
                nullptr);
        }
        bDamageApplied = true;
    }
 
    if (AttackTimer >= AttackDuration)
    {
        FinishLatentTask(OwnerComp, EBTNodeResult::Succeeded);
    }
}

行为树结构：
Root (Selector)
├── 战斗 (Sequence)
│   ├── [条件] 检测到玩家？
│   └── (Selector)
│       ├── 攻击 (Sequence)
│       │   ├── [条件] 在攻击范围内？
│       │   └── [动作] 执行攻击（带冷却）
│       └── [动作] 追击玩家
├── 调查 (Sequence)
│   ├── [条件] 听到声音？
│   └── [动作] 移动到声音位置
└── 巡逻 (Sequence)
    └── [动作] 在巡逻点间移动

行为树结构：
Root (Selector)
├── 阶段3：狂暴 (Sequence)
│   ├── [条件] 血量 < 30%？
│   └── (Selector)
│       ├── [动作] 全屏 AOE 攻击（冷却 8s）
│       ├── [动作] 连续冲刺攻击 x3
│       └── [动作] 召唤小怪
├── 阶段2：强化 (Sequence)
│   ├── [条件] 血量 < 60%？
│   └── (Selector)
│       ├── [动作] 远程弹幕攻击（冷却 5s）
│       ├── [动作] 跳跃砸地攻击
│       └── [动作] 追击玩家
└── 阶段1：普通 (Selector)
    ├── 攻击 (Sequence)
    │   ├── [条件] 在攻击范围内？
    │   └── (Selector)
    │       ├── [动作] 重击（冷却 3s）
    │       └── [动作] 普通攻击
    └── [动作] 缓慢接近玩家

请为 [敌人类型，如：巡逻守卫 / 远程弓箭手 / Boss] 生成完整的行为树 AI。

引擎：[Unity C# / Godot GDScript + Beehave / Unreal C++ BT]

NPC 行为需求：
1. 巡逻：在 [N] 个巡逻点间移动，每个点停留 [X] 秒
2. 检测：视野范围 [R] 单位，视野角度 [A] 度
3. 追击：检测到玩家后追击，速度 [S]，追击超过 [T] 秒或距离超过 [D] 放弃
4. 攻击：
   - 近战攻击：范围 [R1]，伤害 [D1]，冷却 [C1] 秒
   - [可选] 远程攻击：范围 [R2]，弹速 [V]，冷却 [C2] 秒
5. 受伤反应：受伤后 [闪避 / 后退 / 格挡] [X] 秒
6. 死亡：播放死亡动画，掉落物品

黑板变量：
- target: 当前目标 Transform
- last_known_position: 最后已知目标位置
- health: 当前血量
- is_alerted: 是否处于警戒状态

要求：
- 提供完整的行为树结构图（文本格式）
- 提供所有自定义节点的代码实现
- 包含黑板数据管理
- 包含动画播放调用

我的 NPC 行为树有以下问题：
[描述问题，如：NPC 在追击和巡逻之间频繁切换 / 攻击动画被打断 / 多个 NPC 同时攻击导致卡顿]

当前行为树结构：
[粘贴行为树结构或代码]

请：
1. 分析问题根因
2. 提供修复方案
3. 建议性能优化（如：条件检查频率、黑板更新策略）
4. 如果适用，建议添加以下高级特性：
   - 冷却机制防止行为抖动
   - 组 AI 协调（避免所有敌人同时攻击）
   - 感知系统（视觉 + 听觉 + 记忆衰减）

// Unity C# - A* 寻路系统（2D 网格）
 
using System.Collections.Generic;
using UnityEngine;
 
public class AStarPathfinding : MonoBehaviour
{
    [Header("网格设置")]
    public int gridWidth = 50;
    public int gridHeight = 50;
    public float cellSize = 1f;
    public LayerMask obstacleLayer;
 
    private PathNode[,] grid;
 
    // 路径节点
    public class PathNode
    {
        public int X, Y;
        public bool Walkable;
        public int GCost;       // 起点到当前的代价
        public int HCost;       // 当前到终点的启发值
        public int FCost => GCost + HCost;  // 总代价
        public PathNode Parent;
        public int MovementPenalty;  // 地形惩罚
 
        public PathNode(int x, int y, bool walkable, int penalty = 0)
        {
            X = x; Y = y;
            Walkable = walkable;
            MovementPenalty = penalty;
        }
    }
 
    void Start()
    {
        GenerateGrid();
    }
 
    // 生成网格
    void GenerateGrid()
    {
        grid = new PathNode[gridWidth, gridHeight];
 
        for (int x = 0; x < gridWidth; x++)
        {
            for (int y = 0; y < gridHeight; y++)
            {
                Vector2 worldPos = GridToWorld(x, y);
                bool walkable = !Physics2D.OverlapCircle(
                    worldPos, cellSize * 0.4f, obstacleLayer);
 
                // 地形惩罚（可选：不同地形不同代价）
                int penalty = 0;
                // 例如：沼泽地形惩罚 +5
                if (Physics2D.OverlapCircle(worldPos, cellSize * 0.4f,
                    LayerMask.GetMask("Swamp")))
                    penalty = 5;
 
                grid[x, y] = new PathNode(x, y, walkable, penalty);
            }
        }
    }
 
    // A* 寻路核心算法
    public List<Vector2> FindPath(Vector2 startWorld, Vector2 endWorld)
    {
        PathNode startNode = WorldToNode(startWorld);
        PathNode endNode = WorldToNode(endWorld);
 
        if (startNode == null || endNode == null || !endNode.Walkable)
            return null;
 
        // 开放列表和关闭列表
        List<PathNode> openList = new List<PathNode> { startNode };
        HashSet<PathNode> closedSet = new HashSet<PathNode>();
 
        // 初始化所有节点
        for (int x = 0; x < gridWidth; x++)
            for (int y = 0; y < gridHeight; y++)
            {
                grid[x, y].GCost = int.MaxValue;
                grid[x, y].Parent = null;
            }
 
        startNode.GCost = 0;
        startNode.HCost = CalculateHeuristic(startNode, endNode);
 
        while (openList.Count > 0)
        {
            // 找 F 值最小的节点
            PathNode current = GetLowestFCost(openList);
 
            if (current == endNode)
                return RetracePath(startNode, endNode);
 
            openList.Remove(current);
            closedSet.Add(current);
 
            // 遍历邻居
            foreach (PathNode neighbor in GetNeighbors(current))
            {
                if (!neighbor.Walkable || closedSet.Contains(neighbor))
                    continue;
 
                // 对角线移动代价 14，直线 10
                int moveCost = current.GCost +
                    CalculateDistance(current, neighbor) +
                    neighbor.MovementPenalty;
 
                if (moveCost < neighbor.GCost)
                {
                    neighbor.GCost = moveCost;
                    neighbor.HCost = CalculateHeuristic(
                        neighbor, endNode);
                    neighbor.Parent = current;
 
                    if (!openList.Contains(neighbor))
                        openList.Add(neighbor);
                }
            }
        }
 
        return null; // 无路径
    }
 
    // 启发函数（曼哈顿距离 + 对角线优化）
    int CalculateHeuristic(PathNode a, PathNode b)
    {
        int dx = Mathf.Abs(a.X - b.X);
        int dy = Mathf.Abs(a.Y - b.Y);
        // 对角线距离：min * 14 + (max - min) * 10
        return Mathf.Min(dx, dy) * 14 +
               Mathf.Abs(dx - dy) * 10;
    }
 
    int CalculateDistance(PathNode a, PathNode b)
    {
        int dx = Mathf.Abs(a.X - b.X);
        int dy = Mathf.Abs(a.Y - b.Y);
        return (dx + dy == 2) ? 14 : 10;
    }
 
    // 获取邻居节点（8 方向）
    List<PathNode> GetNeighbors(PathNode node)
    {
        List<PathNode> neighbors = new List<PathNode>();
        for (int dx = -1; dx <= 1; dx++)
        {
            for (int dy = -1; dy <= 1; dy++)
            {
                if (dx == 0 && dy == 0) continue;
                int nx = node.X + dx;
                int ny = node.Y + dy;
                if (nx >= 0 && nx < gridWidth &&
                    ny >= 0 && ny < gridHeight)
                {
                    // 对角线移动检查：防止穿墙角
                    if (dx != 0 && dy != 0)
                    {
                        if (!grid[node.X + dx, node.Y].Walkable ||
                            !grid[node.X, node.Y + dy].Walkable)
                            continue;
                    }
                    neighbors.Add(grid[nx, ny]);
                }
            }
        }
        return neighbors;
    }
 
    // 回溯路径
    List<Vector2> RetracePath(PathNode start, PathNode end)
    {
        List<Vector2> path = new List<Vector2>();
        PathNode current = end;
        while (current != start)
        {
            path.Add(GridToWorld(current.X, current.Y));
            current = current.Parent;
        }
        path.Reverse();
        return path;
    }
 
    PathNode GetLowestFCost(List<PathNode> list)
    {
        PathNode lowest = list[0];
        foreach (var node in list)
            if (node.FCost < lowest.FCost ||
                (node.FCost == lowest.FCost &&
                 node.HCost < lowest.HCost))
                lowest = node;
        return lowest;
    }
 
    // 坐标转换
    Vector2 GridToWorld(int x, int y) =>
        new Vector2(x * cellSize + cellSize / 2f,
                    y * cellSize + cellSize / 2f);
 
    PathNode WorldToNode(Vector2 worldPos)
    {
        int x = Mathf.FloorToInt(worldPos.x / cellSize);
        int y = Mathf.FloorToInt(worldPos.y / cellSize);
        if (x >= 0 && x < gridWidth && y >= 0 && y < gridHeight)
            return grid[x, y];
        return null;
    }
}