1
// ===== 碰撞查询 vs 物理模拟：核心区别 =====
2
//
3
// 碰撞查询（Collision Query）：
4
//   - 不依赖物理引擎的动力学模拟
5
//   - 实时执行：问"这个位置有什么？" → 立即返回结果
6
//   - 典型应用：子弹射线检测、近战攻击判定、脚部IK地面检测
7
//   - API：LineTrace / SphereTrace / OverlapMulti / SweepMulti
8
//   - 开销：单次检测 ~0.01ms（取决于碰撞体复杂度）
9
//
10
// 物理模拟（Physics Simulation）：
11
//   - 依赖 Chaos 引擎的帧间动力学积分
12
//   - 持续运行：每帧推进物体运动 → 检测碰撞 → 求解响应
13
//   - 典型应用：掉落的武器、破碎的墙壁、布料飘动
14
//   - API：UPrimitiveComponent::SetSimulatePhysics(true)
15
//   - 开销：每个模拟物体 ~0.1~1ms/帧

1
// ===== 碰撞通道体系 =====
2
//
3
// UE 的碰撞检测基于"通道对通道"的响应矩阵：
4
//
5
// 每个物体有一个 ObjectType（"我是什么类型"）
6
// 物体的碰撞预设定义了"我对每种 Trace Channel 的响应"
7
//
8
// ┌────────────────┬──────────────────────────────────┐
9
// │ Object Channel  │ 物体自身所属的碰撞通道（你是谁）    │
10
// │ Trace Channel   │ 查询时使用的通道（你想检测什么）    │
11
// └────────────────┴──────────────────────────────────┘
12
//
13
// 内置 Object Channel（可在 Project Settings → Collision 中扩展）：
14
//   ECC_WorldStatic    —— 静态世界几何体（墙壁、地面）
15
//   ECC_WorldDynamic   —— 动态世界几何体（可移动平台）
16
//   ECC_Pawn           —— Pawn 角色
17
//   ECC_PhysicsBody    —— 物理模拟中的物体
18
//   ECC_Vehicle        —— 载具
19
//   ECC_Destructible   —— 可破坏物体
20
//
21
// 内置 Trace Channel（射线检测时指定"我想检测什么通道"）：
22
//   ECC_Visibility     —— 视线检测（子弹、AI视野、Mouse Picking）
23
//   ECC_Camera         —— 相机穿透检测
24

25
// ---------- C++ 中设置碰撞属性 ----------
26
void ConfigureCollision()
27
{
28
    // ① 设置碰撞启用状态
29
    UPrimitiveComponent* Comp = GetComponentByClass<UPrimitiveComponent>();
30
    if (!Comp) return;
31

32
    // 完全禁用碰撞（不参与任何碰撞检测）
33
    Comp->SetCollisionEnabled(ECollisionEnabled::NoCollision);
34

35
    // 仅查询（不产生物理碰撞响应——但可以被 Trace 检测到）
36
    Comp->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
37

38
    // 仅物理（参与物理模拟——但不能被 Trace 检测到）
39
    Comp->SetCollisionEnabled(ECollisionEnabled::PhysicsOnly);
40

41
    // 查询 + 物理（同时参与两者）
42
    Comp->SetCollisionEnabled(ECollisionEnabled::QueryAndPhysics);
43

44
    // ② 设置 Object Type（"我是什么"）
45
    Comp->SetCollisionObjectType(ECC_Pawn);
46

47
    // ③ 设置对特定通道的响应
48
    Comp->SetCollisionResponseToChannel(ECC_Visibility, ECR_Block);   // 阻挡视线
49
    Comp->SetCollisionResponseToChannel(ECC_Camera, ECR_Ignore);      // 不阻挡相机
50
    Comp->SetCollisionResponseToChannel(ECC_Pawn, ECR_Overlap);       // 与角色重叠
51

52
    // ④ 批量设置——对所有通道的默认响应
53
    Comp->SetCollisionResponseToAllChannels(ECR_Block);  // 挡住一切
54
    // 然后单独放行某些通道
55
    Comp->SetCollisionResponseToChannel(ECC_Visibility, ECR_Ignore);
56
}
57

58
// ===== ECR 响应类型 =====
59
// ECR_Ignore    → 完全无视——不阻挡、不重叠、不产生事件
60
// ECR_Overlap   → 重叠——产生 Overlap 事件，但不阻挡移动
61
// ECR_Block     → 阻挡——物理/移动被拦截 + 产生 Hit 事件

1
// ===== Collision Preset：碰撞预设 =====
2
//
3
// 在编辑器中（或 C++）为每个 Component 选择预设：
4
//
5
// NoCollision        → 完全无碰撞
6
// BlockAll           → 阻挡一切
7
// BlockAllDynamic    → 阻挡所有动态物体
8
// OverlapAll         → 与一切重叠（不阻挡）
9
// OverlapAllDynamic  → 与动态物体重叠
10
// Custom             → 自定义（手动配置每个通道的响应）
11
//
12
// 预设本质上是一组"对所有通道的默认响应 + 特定通道的覆盖"的快捷方式
13
// 编译后存在 CDO 中，运行时可通过 C++ 修改
14

15
// C++ 中设置预设：
16
void SetCollisionPreset(UPrimitiveComponent* Comp)
17
{
18
    // 方法 1：直接设置预设名（引擎内置或项目自定义）
19
    Comp->SetCollisionProfileName(TEXT("BlockAll"));
20

21
    // 方法 2：运行时覆盖特定通道
22
    Comp->SetCollisionEnabled(ECollisionEnabled::QueryAndPhysics);
23
    Comp->SetCollisionObjectType(ECC_Pawn);
24
    Comp->SetCollisionResponseToAllChannels(ECR_Ignore);   // 默认忽略一切
25
    Comp->SetCollisionResponseToChannel(ECC_WorldStatic, ECR_Block);  // 只挡墙壁
26
    Comp->SetCollisionResponseToChannel(ECC_Pawn, ECR_Overlap);       // 与角色重叠
27
}

1
// ===== Trace 四种形状与使用场景 =====
2
//
3
// LineTrace（射线）：沿一条直线检测
4
//   → 子弹、AI 视野、鼠标拾取（Mouse Picking）
5
//   → 最轻量——只有起点和终点
6
//
7
// SphereTrace（球形）：沿路径移动一个球体
8
//   → 近战"爆炸式"攻击判定、手部抓取检测
9
//   → 在半径方向上更宽容——不要求精确命中
10
//
11
// BoxTrace（盒形）：沿路径移动一个长方体
12
//   → 近战"扇形"攻击判定——覆盖一个矩形区域
13
//   → 例如："前方 200×100×50 的盒子"模拟剑的挥砍范围
14
//
15
// CapsuleTrace（胶囊形）：沿路径移动一个胶囊体
16
//   → 角色移动的"推开"检测、蹲下检测
17
//   → 没有棱角——不会卡在楼梯或门槛上
18

19
// ---------- ① LineTrace：最基础的射线检测 ----------
20
void LineTraceExample()
21
{
22
    FVector Start = GetActorLocation();
23
    FVector End = Start + GetActorForwardVector() * 5000.0f;  // 前方 50 米
24

25
    FHitResult Hit;
26
    FCollisionQueryParams Params;
27
    Params.AddIgnoredActor(this);     // 忽略自己
28
    Params.bTraceComplex = false;     // 使用简化碰撞体（性能更好）
29
    Params.bReturnPhysicalMaterial = true;  // 返回物理材质
30

31
    bool bHit = GetWorld()->LineTraceSingleByChannel(
32
        Hit,
33
        Start,
34
        End,
35
        ECC_Visibility,   // 使用 Visibility 通道
36
        Params
37
    );
38

39
    if (bHit)
40
    {
41
        AActor* HitActor = Hit.GetActor();
42
        FVector HitPoint = Hit.Location;
43
        FVector HitNormal = Hit.ImpactNormal;
44
        UPhysicalMaterial* PhysMat = Hit.PhysMaterial.Get();  // 物理材质
45

46
        // 画调试线
47
        DrawDebugLine(GetWorld(), Start, HitPoint, FColor::Red,
48
            false, 2.0f, 0, 2.0f);
49

50
        UE_LOG(LogPhysics, Log, TEXT("命中: %s at %s"),
51
            *HitActor->GetName(), *HitPoint.ToString());
52
    }
53
}
54

55
// ---------- ② SphereTrace：球形扫描 ----------
56
void SphereTraceExample()
57
{
58
    FVector Start = GetActorLocation();
59
    FVector End = Start + GetActorForwardVector() * 300.0f;
60
    float Radius = 50.0f;
61

62
    TArray<FHitResult> Hits;
63
    FCollisionQueryParams Params;
64
    Params.AddIgnoredActor(this);
65

66
    // SphereMulti：返回所有被扫到的物体（不是第一个）
67
    bool bHit = GetWorld()->SweepMultiByChannel(
68
        Hits,
69
        Start,
70
        End,
71
        FQuat::Identity,
72
        ECC_GameTraceChannel1,  // 自定义通道（项目设置中定义）
73
        FCollisionShape::MakeSphere(Radius),
74
        Params
75
    );
76

77
    for (const FHitResult& Hit : Hits)
78
    {
79
        if (AActor* HitActor = Hit.GetActor())
80
        {
81
            // 近战攻击判定——对每个被扫到的敌人造成伤害
82
            UGameplayStatics::ApplyDamage(HitActor, 25.0f,
83
                GetInstigatorController(), this, UDamageType::StaticClass());
84
        }
85
    }
86
}
87

88
// ---------- ③ BoxTrace：盒形扫描（扇形攻击） ----------
89
void BoxTraceExample()
90
{
91
    FVector Start = GetActorLocation();
92
    FVector End = Start + GetActorForwardVector() * 200.0f;
93
    FVector3f HalfSize = FVector3f(100.f, 50.f, 50.f);  // 宽 200 × 深 100 × 高 100（LWC 后必须使用 FVector3f）
94

95
    // 因为盒子有朝向，需要传入旋转
96
    FQuat Rotation = GetActorQuat();
97

98
    TArray<FHitResult> Hits;
99
    FCollisionQueryParams Params;
100
    Params.AddIgnoredActor(this);
101

102
    bool bHit = GetWorld()->SweepMultiByChannel(
103
        Hits,
104
        Start,
105
        End,
106
        Rotation,
107
        ECC_GameTraceChannel1,
108
        FCollisionShape::MakeBox(HalfSize),
109
        Params
110
    );
111

112
    // 可视化调试
113
    DrawDebugBox(GetWorld(), (Start + End) * 0.5f, HalfSize,
114
        Rotation, bHit ? FColor::Red : FColor::Green, false, 1.0f);
115
}
116

117
// ---------- ④ CapsuleTrace：胶囊扫描 ----------
118
void CapsuleTraceExample()
119
{
120
    FVector Start = GetActorLocation();
121
    FVector End = Start + FVector(0, 0, -200.0f);  // 向下检测
122
    float Radius = 34.0f;  // 角色胶囊体半径
123
    float HalfHeight = 88.0f;
124

125
    FHitResult Hit;
126
    FCollisionQueryParams Params;
127
    Params.AddIgnoredActor(this);
128

129
    GetWorld()->SweepSingleByChannel(
130
        Hit,
131
        Start,
132
        End,
133
        FQuat::Identity,
134
        ECC_Visibility,
135
        FCollisionShape::MakeCapsule(Radius, HalfHeight),
136
        Params
137
    );
138
}

1
// ===== Overlap：检测"当前这个区域内有什么" =====
2
//
3
// Overlap 不沿路径移动——它在固定位置检测重叠
4

5
void OverlapExample()
6
{
7
    // 检测角色周围 500 半径内所有 Pawn
8
    TArray<FOverlapResult> Overlaps;
9
    FCollisionQueryParams Params;
10
    Params.AddIgnoredActor(this);
11

12
    bool bHasOverlaps = GetWorld()->OverlapMultiByObjectType(
13
        Overlaps,
14
        GetActorLocation(),
15
        FQuat::Identity,
16
        FCollisionObjectQueryParams(ECC_Pawn),  // 只关心 Pawn 类型
17
        FCollisionShape::MakeSphere(500.0f),
18
        Params
19
    );
20

21
    for (const FOverlapResult& Result : Overlaps)
22
    {
23
        if (APawn* NearbyPawn = Cast<APawn>(Result.GetActor()))
24
        {
25
            UE_LOG(LogPhysics, Log, TEXT("附近角色: %s"),
26
                *NearbyPawn->GetName());
27
        }
28
    }
29
}
30

31
// ===== Single vs Multi 的选择 =====
32
//
33
// Single：只返回第一个碰撞结果（最近的那个）
34
//   → 性能更好——引擎在找到第一个碰撞后立即返回，不继续检测
35
//   适用：子弹射线（打到第一个目标就停）、地面检测
36
//
37
// Multi：返回所有碰撞结果
38
//   → 引擎检测完整路径上的所有碰撞体
39
//   适用：近战攻击判定（一个挥砍可能打到多个敌人）、穿透弹
40
//
41
// 经验法则：如果你只需要最近的那个 → 用 Single 省性能
42
//           如果一颗子弹应该穿透多个目标 → 用 Multi

1
// ===== 在 Project Settings → Engine → Collision 中配置 =====
2
//
3
// 自定义 Object Channel（最多 18 个）：
4
//   Projectile     —— 投射物
5
//   Pickup         —— 可拾取物品
6
//   Enemy          —— 敌人
7
//   Interactable   —— 可交互物体
8
//
9
// 自定义 Trace Channel（最多 18 个）：
10
//   WeaponTrace    —— 武器碰撞线
11
//   InteractionRay —— 交互射线
12
//   FootIK         —— 脚部 IK 地面检测
13
//
14
// 在 C++ 中使用自定义通道：
15
//   ECC_GameTraceChannel1  对应第一个自定义 Trace Channel
16
//   ECC_GameTraceChannel2  对应第二个
17
//   ...
18
//   ECC_GameTraceChannel18 对应第十八个
19
//
20
//   推荐做法：在项目的头文件中定义别名
21
//   #define ECC_WeaponTrace ECC_GameTraceChannel1
22
//   #define ECC_InteractionRay ECC_GameTraceChannel2

1
// ===== Physical Material：表面属性数据 =====
2
//
3
// 每个碰撞体（Collision Shape）可以关联一个 UPhysicalMaterial
4
// 物理材质存储了该表面的物理属性：
5
//   - Friction（摩擦系数）：影响滑动物体的减速
6
//   - Restitution（弹性系数）：影响弹跳——0=完全非弹性，1=完全弹性
7
//   - Density（密度）：影响浮力
8
//   - SurfaceType（表面类型）：用于脚步声/粒子特效切换
9

10
// ---------- 获取碰撞表面的 Physical Material ----------
11
void CheckSurfaceType(const FHitResult& Hit)
12
{
13
    // 从 Hit 结果中获取物理材质
14
    UPhysicalMaterial* PhysMat = Hit.PhysMaterial.Get();
15

16
    if (PhysMat)
17
    {
18
        // 获取表面类型
19
        EPhysicalSurface SurfaceType = PhysMat->SurfaceType;
20

21
        switch (SurfaceType)
22
        {
23
            case EPhysicalSurface::SurfaceType_Default:
24
                UE_LOG(LogTemp, Log, TEXT("默认表面"));
25
                break;
26
            case SurfaceType1:   // 自定义表面——如 "Concrete"
27
                UE_LOG(LogTemp, Log, TEXT("混凝土"));
28
                break;
29
            case SurfaceType2:   // 如 "Wood"
30
                UE_LOG(LogTemp, Log, TEXT("木头"));
31
                break;
32
            case SurfaceType3:   // 如 "Metal"
33
                UE_LOG(LogTemp, Log, TEXT("金属"));
34
                break;
35
        }
36

37
        // 结合此信息——播放不同的脚步声
38
        PlayFootstepSound(SurfaceType);
39
    }
40
}
41

42
void PlayFootstepSound(EPhysicalSurface SurfaceType)
43
{
44
    USoundBase* SoundToPlay = nullptr;
45
    switch (SurfaceType)
46
    {
47
        case SurfaceType1: SoundToPlay = ConcreteFootstep; break;
48
        case SurfaceType2: SoundToPlay = WoodFootstep; break;
49
        case SurfaceType3: SoundToPlay = MetalFootstep; break;
50
        default: SoundToPlay = DefaultFootstep; break;
51
    }
52

53
    if (SoundToPlay)
54
    {
55
        UGameplayStatics::PlaySoundAtLocation(GetWorld(), SoundToPlay,
56
            GetActorLocation());
57
    }
58
}
59

60
UPROPERTY(EditDefaultsOnly) TObjectPtr<USoundBase> ConcreteFootstep;
61
UPROPERTY(EditDefaultsOnly) TObjectPtr<USoundBase> WoodFootstep;
62
UPROPERTY(EditDefaultsOnly) TObjectPtr<USoundBase> MetalFootstep;
63
UPROPERTY(EditDefaultsOnly) TObjectPtr<USoundBase> DefaultFootstep;

1
// ===== PhysicsConstraint：连接两个物理体 =====
2
//
3
// Constraint 模拟物理世界中"物体之间的连接限制"：
4
//   铰链（门轴）、弹簧（悬挂）、球窝关节（肩膀）、滑轨（电梯）
5
//
6
// 核心参数：
7
//   - Linear Limits：限制线性运动的范围（X/Y/Z 各轴）
8
//   - Angular Limits：限制旋转运动的范围（Swing1/Swing2/Twist）
9
//   - Linear Motor：驱动线性运动（如自动门）
10
//   - Angular Motor：驱动旋转运动（如旋转风扇）
11

12
// ---------- C++ 中创建和配置 Constraint ----------
13
UCLASS()
14
class APhysicsDoor : public AActor
15
{
16
    GENERATED_BODY()
17

18
public:
19
    APhysicsDoor()
20
    {
21
        RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("Root"));
22

23
        // 门框（静态）
24
        DoorFrame = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Frame"));
25
        DoorFrame->SetupAttachment(RootComponent);
26

27
        // 门扇（物理模拟）
28
        DoorPanel = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Door"));
29
        DoorPanel->SetupAttachment(RootComponent);
30
        DoorPanel->SetSimulatePhysics(true);  // 开启物理模拟
31

32
        // 铰链约束——门只能绕 Z 轴旋转
33
        HingeConstraint = CreateDefaultSubobject<UPhysicsConstraintComponent>(
34
            TEXT("Hinge"));
35
        HingeConstraint->SetupAttachment(RootComponent);
36

37
        // ★ 注意：SetConstrainedComponents 和 SetLinearLimits / SetAngularLimits
38
        //   必须在 BeginPlay() 中调用——构造函数阶段 Chaos 刚体尚未创建，连接无效
39
    }
40

41
    virtual void BeginPlay() override
42
    {
43
        Super::BeginPlay();
44

45
        // 连接门框和门扇（此时物理世界已就绪）
46
        HingeConstraint->SetConstrainedComponents(
47
            DoorFrame, NAME_None,   // 约束到门框（静态）
48
            DoorPanel, NAME_None    // 被约束的门扇（动态）
49
        );
50

51
        // 锁定位置——门不能平移（三轴合一接口）
52
        HingeConstraint->SetLinearLimits(
53
            ELinearConstraintMotion::LCM_Locked,   // X
54
            ELinearConstraintMotion::LCM_Locked,   // Y
55
            ELinearConstraintMotion::LCM_Locked,   // Z
56
            0.0f);                                  // LimitSize（Locked 时忽略）
57

58
        // 锁定两个旋转轴——仅释放 Z 轴（铰链轴）
59
        // ★ SetAngularLimits 的官方签名是交替排列：Motion, Angle, Motion, Angle, Motion, Angle
60
        HingeConstraint->SetAngularLimits(
61
            EAngularConstraintMotion::ACM_Locked, 0.0f,   // Swing1
62
            EAngularConstraintMotion::ACM_Locked, 0.0f,   // Swing2
63
            EAngularConstraintMotion::ACM_Free,   0.0f);  // Twist
64
    }
65

66
protected:
67
    UPROPERTY(VisibleAnywhere)
68
    TObjectPtr<UStaticMeshComponent> DoorFrame;
69

70
    UPROPERTY(VisibleAnywhere)
71
    TObjectPtr<UStaticMeshComponent> DoorPanel;
72

73
    UPROPERTY(VisibleAnywhere)
74
    TObjectPtr<UPhysicsConstraintComponent> HingeConstraint;
75
};
76

77
// ===== Constraint 的常见类型 =====
78
//
79
// 铰链（Hinge）：
80
//   锁定所有平移 + 锁定两个旋转轴 → 只留一个旋转轴
81
//   应用：门、旋转桥、摆锤
82
//
83
// 球窝（Ball-and-Socket）：
84
//   锁定所有平移 + 全部旋转自由
85
//   应用：肩膀关节、项链的珠子连接
86
//
87
// 滑轨（Slider / Prismatic）：
88
//   锁定两个平移轴 + 锁定所有旋转 → 只留一个滑动轴
89
//   应用：电梯、抽屉
90
//
91
// 弹簧（Spring）：
92
//   在限定范围内施加弹性力
93
//   应用：悬挂系统、软绳

1
// ===== Chaos Destruction：UE5 的破坏与碎裂系统 =====
2
//
3
// 核心流程：
4
// ① 在编辑器中对 Static Mesh 做 Voronoi 碎裂（Geometry Collection）
5
// ② 将 Geometry Collection 拖入场景（自动成为 Chaos 模拟物体）
6
// ③ 受到伤害/撞击时触发碎裂
7
// ④ Chaos 引擎接管碎片运动
8

9
// ---------- C++ 中触发破坏 ----------
10
UCLASS()
11
class ADestructibleWall : public AActor
12
{
13
    GENERATED_BODY()
14

15
public:
16
    // 受到伤害时触发破碎
17
    virtual float TakeDamage(float DamageAmount, FDamageEvent const& DamageEvent,
18
        AController* EventInstigator, AActor* DamageCauser) override
19
    {
20
        float ActualDamage = Super::TakeDamage(
21
            DamageAmount, DamageEvent, EventInstigator, DamageCauser);
22

23
        // 在伤害点施加 Chaos 破碎力
24
        ApplyDestructionForce(DamageEvent);
25

26
        return ActualDamage;
27
    }
28

29
    void ApplyDestructionForce(const FDamageEvent& DamageEvent)
30
    {
31
        if (DamageEvent.IsOfType(FPointDamageEvent::ClassID))
32
        {
33
            const FPointDamageEvent* PointDamage =
34
                static_cast<const FPointDamageEvent*>(&DamageEvent);
35

36
            // 对 Geometry Collection 的特定碎片施加力
37
            // 实际实现依赖 Chaos 的 Field System 或 GeometryCollectionComponent API
38
            FVector HitLocation = PointDamage->HitInfo.Location;
39
            FVector Impulse = PointDamage->ShotDirection * DestructionForce;
40

41
            // UE5 完整 API 略——核心是 GeometryCollectionComponent::ApplyExternalStrain
42
            // 或通过 RadialForce 组件施加 Chaos Field
43
        }
44
    }
45

46
    UPROPERTY(EditAnywhere, Category = "Destruction")
47
    float DestructionForce = 5000.0f;
48
};
49

50
// ===== Chaos 关键概念速记 =====
51
//
52
// Geometry Collection：
53
//   - 替代传统的 StaticMesh——专为可破坏物体设计
54
//   - 内部存储 Voronoi 碎片信息和 Cluster 层级
55
//   - 创建方式：右键 StaticMesh → Create Geometry Collection
56
//
57
// Cluster：
58
//   - 碎片的层级分组——顶层是大块碎片，底层是小碎片
59
//   - 小的撞击只触发上层 Cluster 碎裂——大块掉落
60
//   - 大的撞击触发深层碎裂——全部碎成小块
61
//
62
// Chaos Field System：
63
//   - 施加空间力场——不依赖逐个接触
64
//   - RadialFalloff：中心向外递减的力量场（爆炸）
65
//   - UniformVector：统一方向力（重力反转）
66
//   - AnchorField：将某些碎片锚定（不移动）
67
//
68
// Cache System：
69
//   - 录制破坏模拟结果——多人游戏中所有客户端看到一致的破坏
70
//   - 播放时零物理开销——纯动画回放

1
// ===== 陷阱 #1：Trace 时忘记忽略自己 =====
2
void BadTrace()
3
{
4
    FHitResult Hit;
5
    GetWorld()->LineTraceSingleByChannel(Hit,
6
        GetActorLocation(),
7
        GetActorLocation() + GetActorForwardVector() * 1000,
8
        ECC_Visibility);
9
    // ✗ 射线从自己内部发出——第一个命中的就是自己！
10
    //    结果：永远打到自己的碰撞体
11
}
12
// ✓ FCollisionQueryParams Params; Params.AddIgnoredActor(this);
13

14
// ===== 陷阱 #2：Trace 起点在碰撞体内部 =====
15
void BadTraceStart()
16
{
17
    // ✗ 起点在角色的胶囊体内部
18
    FVector Start = GetActorLocation();
19
    // → 射线立即与自己的胶囊体重叠——Hit.bStartPenetrating = true
20
    //   但 Hit.GetActor() 可能是自己（已忽略）或 nullptr
21
}
22
// ✓ 起点向前偏移到碰撞体外部：
23
// FVector Start = GetActorLocation() + GetActorForwardVector() * 50.0f;
24

25
// ===== 陷阱 #3：在 Tick 中做大量 Trace 没有缓存 =====
26
void ABadEnemy::Tick(float DeltaTime)
27
{
28
    // ✗ 10 个敌人 × 每帧 5 条射线检测 = 50 条射线/帧
29
    //    在移动端可能占用 2~3ms——独占物理线程预算
30
    for (int i = 0; i < 5; ++i)
31
        GetWorld()->LineTraceSingleByChannel(...);
32
}
33
// ✓ 降低检测频率（每 3 帧检测一次）或使用 Async Trace
34

35
// ===== 陷阱 #4：物理模拟的物体没有设置 Sleep 阈值 =====
36
// ✗ 所有物理物体永远活跃——100 个碎石永远不会 Sleep
37
//    → 每帧 100 个物体的动力学积分——数 ms 的开销
38
// ✓ 在 Project Settings → Physics 中设置合理的 Sleep 阈值
39
//    或者手动：BodyInstance.SetSleepThresholds(...)
40

41
// ===== 陷阱 #5：碰撞预设使用 Custom 但没理解默认响应 =====
42
// ✗ 设置 Collision Profile = Custom → 所有通道默认 "Block"
43
//    → 角色被所有东西卡住——包括不应该阻挡的 Trigger 体积
44
// ✓ Custom 预设下必须显式设置每个通道的响应
45

46
// ===== 陷阱 #6：Multi Trace 返回的 Hits 已经按距离排序好了 =====
47
//   UE5 底层 GeomSweepMulti / RaycastMulti 在返回前已强制按 Distance 升序排列。
48
//   Hits[0] 百分百是距离起点最近的那个碰撞点——严禁画蛇添足手动 Sort，浪费 CPU。
49

50
// ===== 陷阱 #7：改变碰撞设置后没有调用 UpdateOverlaps =====
51
void ChangeCollisionRuntime()
52
{
53
    MyComp->SetCollisionResponseToChannel(ECC_Pawn, ECR_Overlap);
54
    // ✗ 如果此时已经有一个 Pawn 贴着这个组件——
55
    //    重叠事件不会重新触发！直到 Pawn 离开再回来
56
}
57
// ✓ 手动刷新重叠状态：
58
// MyComp->UpdateOverlaps();
59

60
// ===== 陷阱 #8：忘记在多 Trace 时忽略已命中的 Actor =====
61
void BadMultipleTrace()
62
{
63
    // ✗ 第一次 Trace 命中了 EnemyA → 对其应用伤害
64
    //    第二次 Trace（同一帧）又从 EnemyA 开始——又命中了 EnemyA → 双重伤害！
65
    // ✓ 累积 AddIgnoredActor：Params.AddIgnoredActor(HitActor);
66
}

1
Q: "Object Channel 和 Trace Channel 的区别？"
2
A: Object Channel 定义"我是谁"——每个物体的 ObjectType（Pawn/WorldStatic/Vehicle）。
3
   Trace Channel 定义"我想检测什么"——射线或 Sweep 查询时指定的通道（Visibility/Camera）。
4
   碰撞响应矩阵是"Object × Trace"——例如"Pawn 对 Visibility 的响应是 Block"，
5
   意思是"用 Visibility 通道做射线检测时，Pawn 会阻挡射线并被命中"。
6

7
Q: "LineTrace 和 Sweep 的区别？"
8
A: LineTrace 沿一条无限细的直线检测——只返回第一个交点。
9
   Sweep 沿路径移动一个形状（球/盒/胶囊）——检测整个形状在路径上碰撞到的所有物体。
10
   Sweep 可以返回"首次阻挡点"（Single）或"所有命中"（Multi）。
11
   子弹用 LineTrace，近战攻击判定用 SphereSweep 或 BoxSweep。
12

13
Q: "什么时候用 Physics Simulation，什么时候用 Trace 查询？"
14
A: 物理模拟用于持续动力学（掉落/弹跳/碎裂）——依赖帧间积分和碰撞求解。
15
   Trace 查询用于实时判断（射线检测/攻击判定/地面检测）——不依赖物理引擎的动力学模拟。
16
   如果你只需要"这个位置有什么"→ 用 Trace。如果你需要"这个物体怎么运动"→ 用 Simulation。