1
// ===== UObject —— 不需要"存在在世界上"的东西 =====
2
// 数据对象、配置、资产、子系统——它们不需要 Transform
3
UCLASS()
4
class UWeaponData : public UDataAsset  // ← 数据，不在世界中有位置
5
{
6
    UPROPERTY(EditDefaultsOnly)
7
    float Damage;
8
};
9

10
UCLASS()
11
class UMyGameInstanceSubsystem : public UGameInstanceSubsystem  // ← 逻辑管理，没有位置
12
{
13
    // 纯逻辑，管理全局状态
14
};
15

16
// ===== AActor —— 需要"在关卡中有个位置"的东西 =====
17
// 玩家、敌人、道具、门、触发器——它们在 3D 世界中有坐标
18
UCLASS()
19
class AMyCharacter : public ACharacter  // ← 在世界中有位置，有 Transform
20
{
21
    // 可以被放置到关卡中
22
};
23

24
// 判断是否应该继承 AActor 的唯一标准：
25
// "这个东西需要在世界中有个 Transform 吗？"
26
// 是 → AActor（或 ACharacter、APawn 等子类）
27
// 否 → UObject

1
// ===== SpawnActor：在游戏世界中创建一个 Actor =====
2
// 这是创建 Actor 的唯一正确方式——它不仅仅 new 了一个对象，
3
// 还完成了注册到世界、分配 NetGUID、初始化 Component 等一系列工作
4

5
UCLASS()
6
class AMyProjectile : public AActor
7
{
8
    GENERATED_BODY()
9

10
public:
11
    AMyProjectile()
12
    {
13
        // ⚠️ 构造函数中只做三件事：
14
        // 1. 创建 DefaultSubobject
15
        // 2. 设置成员默认值
16
        // 3. 设置 Component 的 Attachment
17

18
        MeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Mesh"));
19
        RootComponent = MeshComponent;  // 设置 RootComponent
20

21
        InitialLifeSpan = 5.0f;  // 5 秒后自动销毁
22
    }
23
    UPROPERTY(VisibleAnywhere)
24
    UStaticMeshComponent* MeshComponent;
25
};
26

27
// ===== 在游戏代码中生成 Actor =====
28
void AMyGameMode::SpawnProjectile(FVector Location, FRotator Rotation)
29
{
30
    UWorld* World = GetWorld();
31

32
    // FActorSpawnParameters 控制生成行为
33
    FActorSpawnParameters SpawnParams;
34
    SpawnParams.Owner = this;                          // 所属者
35
    SpawnParams.Instigator = GetInstigator();           // 发起者（伤害来源）
36
    SpawnParams.SpawnCollisionHandlingOverride =
37
        ESpawnActorCollisionHandlingMethod::AdjustIfPossibleButAlwaysSpawn;
38
    // ↑ 常用选项：
39
    //   AlwaysSpawn — 无论如何都生成（穿透碰撞）
40
    //   AdjustIfPossibleButAlwaysSpawn — 尝试找空位，找不到也生成
41
    //   AdjustIfPossibleButDontSpawnIfColliding — 找不到空位就不生成
42
    //   DontSpawnIfColliding — 与任何物体碰撞就不生成
43

44
    AMyProjectile* Projectile = World->SpawnActor<AMyProjectile>(
45
        AMyProjectile::StaticClass(),  // 类型
46
        Location,                       // 位置
47
        Rotation,                       // 旋转
48
        SpawnParams                     // 参数
49
    );
50

51
    if (Projectile)
52
    {
53
        // 生成成功！Actor 已完成 PostActorCreated 和 BeginPlay
54
    }
55
}
56

57
// ===== SpawnActorDeferred：延迟生成 —— 在 BeginPlay 之前塞入初始化参数 =====
58
// 大厂高频考点：普通 SpawnActor 返回时 BeginPlay 已经执行完毕，
59
// 如果你需要在 Actor 诞生前修改属性（如子弹伤害加成），怎么办？
60
// → 用 SpawnActorDeferred 创造一个"空档期"
61

62
AMyProjectile* Bullet = World->SpawnActorDeferred<AMyProjectile>(
63
    AMyProjectile::StaticClass(),
64
    Transform,
65
    Owner,
66
    Instigator
67
);
68
// ↑ 此时构造函数和 PostActorCreated 已执行完毕，
69
//   但 BeginPlay 和 Construction Script 尚未触发——这是一个完美的初始化空档！
70

71
if (Bullet)
72
{
73
    // 在这个空档期内安全地修改属性：
74
    Bullet->DamageMultiplier = 2.5f;
75
    Bullet->TeamId = 1;
76

77
    // 手动完成最终生成——只有现在才触发 Construction Script 和 BeginPlay
78
    Bullet->FinishSpawning(Transform);
79
}
80

81
// ===== NewObject：创建不需要在世界上存在的 UObject =====
82
// NewObject 不涉及关卡、不分配 Transform、不注册 Component
83
UWeaponData* DataAsset = NewObject<UWeaponData>();
84
// 只用于 UObject，不能用于 Actor！

1
// Actor 从 SpawnActor 到 BeginPlay 的完整调用链：
2

3
// 1. AActor::AActor()                          — 构造函数，创建 DefaultSubobject
4
// 2. PostInitProperties()                      — 所有 UPROPERTY 初始化后
5
// 3. PostLoad()                                — 从磁盘序列化恢复数据后（仅加载时）
6
// 4. PostActorCreated()                        — Actor 已在世界中注册完成
7
//     ↑ 这里可以访问 World、GameMode、其他 Actor
8
//     ↑ Component 已经注册到世界
9
//     ↑ 蓝图 Construction Script 在这之后执行
10
// 5. PreInitializeComponents()                — Component 初始化前
11
// 6. InitializeComponents()                   — 所有 Component 初始化
12
// 7. PostInitializeComponents()               — Component 初始化完成
13
// 8. BeginPlay()                              — 游戏开始！（最重要的函数）
14
//     ↑ 这是你写游戏逻辑的"起点"
15

16
// ===== 典型用法 =====
17
UCLASS()
18
class AMyActor : public AActor
19
{
20
    GENERATED_BODY()
21

22
public:
23
    AMyActor()
24
    {
25
        // ✓ 只做：创建 Component、设置默认值
26
        Mesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Mesh"));
27
        RootComponent = Mesh;
28
        Health = 100;
29
    }
30

31
    virtual void PostActorCreated() override
32
    {
33
        Super::PostActorCreated();
34
        // ✓ 此时 World 已可用，可以访问其他 Actor
35
        // ✓ 常用于：SpawnActor 生成后立即做特殊初始化
36
        UE_LOG(LogTemp, Log, TEXT("Actor 已在世界中创建完毕"));
37
    }
38

39
    virtual void PostInitializeComponents() override
40
    {
41
        Super::PostInitializeComponents();
42
        // ✓ Component 全部初始化完毕，可以设置 Component 初始状态
43
        // ⚠️ 此时其他 Actor 的 BeginPlay 可能还没调用
44
    }
45

46
    virtual void BeginPlay() override
47
    {
48
        Super::BeginPlay();
49
        // ✓✓✓ 游戏逻辑的起点！
50
        // ✓ 所有 Component 的就绪
51
        // ✓ 网络复制已经开始
52
        // ✓ 可以安全地调用蓝图重写函数
53
        // ✓ 可以访问 GameMode、PlayerController 等
54
        SetupWeaponSystem();
55
    }
56

57
private:
58
    UPROPERTY()
59
    UStaticMeshComponent* Mesh;
60

61
    UPROPERTY()
62
    int32 Health;
63
};

1
// 蓝图有一个"构造脚本"——在编辑器中每当你移动 Actor 或修改属性时都会执行
2
// C++ 没有构造脚本，但有 OnConstruction 函数：
3

4
virtual void OnConstruction(const FTransform& Transform) override
5
{
6
    Super::OnConstruction(Transform);
7

8
    // 等价于蓝图的 Construction Script
9
    // 在编辑器中修改属性、拖动 Actor 时都会触发
10
    // ⚠️ 编辑器中也会执行！不要在这里写只在游戏运行时的逻辑
11
    // ✓ 适合：根据属性动态构建视觉效果（如根据长度拉伸网格）
12

13
    if (PillarMesh)
14
    {
15
        // 根据 Height 属性拉伸柱子
16
        PillarMesh->SetWorldScale3D(FVector(1.0f, 1.0f, PillarHeight / 100.0f));
17
    }
18
}
19

20
// 区分记忆法：
21
// 构造函数 — 编辑器打开时执行一次（设置 CDO）
22
// OnConstruction — 编辑器中每次修改属性都执行（动态预览）
23
// BeginPlay — 仅游戏运行时执行（游戏逻辑）

1
UCLASS()
2
class AMyActor : public AActor
3
{
4
    GENERATED_BODY()
5

6
public:
7
    AMyActor()
8
    {
9
        // ✓ 默认关闭 Tick —— 除非你真的需要它
10
        PrimaryActorTick.bCanEverTick = false;  // ← 默认应该是 false！
11
    }
12

13
    // 当你确实需要 Tick 时：
14
    virtual void Tick(float DeltaTime) override
15
    {
16
        Super::Tick(DeltaTime);
17

18
        // ⚠️ Tick 中只做必须每帧更新的工作
19
        // ✗ 不要在 Tick 中 FindActor / GetAllActorsOfClass
20
        // ✗ 不要在 Tick 中动态构造 UObject
21
        // ✓ 缓存在 BeginPlay 中获取的引用
22
        // ✓ 用 Timer 替代低频 Tick
23

24
        // 如果你只需要每 N 秒更新一次，用 Timer：
25
        // GetWorldTimerManager().SetTimer(...)
26
    }
27
};
28

29
// ===== Tick 组 —— 控制 Actor Tick 的执行顺序 =====
30
// PrimaryActorTick.TickGroup 决定了何时执行 Tick：
31
// TG_PrePhysics      — 物理模拟前（适合设置输入、准备物理状态）
32
// TG_DuringPhysics   — 物理模拟中（适合物理响应逻辑）
33
// TG_PostPhysics     — 物理模拟后（适合基于物理结果的逻辑）
34
// TG_PostUpdateWork  — 所有物理和动画更新完成后
35

36
// ===== Tick 间隔 —— 不一定要每帧 Tick =====
37
PrimaryActorTick.TickInterval = 0.5f;  // 每 0.5 秒 Tick 一次
38
// 适合：低频状态检查（如 AI 感知刷新、区域检测）

1
// ===== 条件销毁 =====
2
void AMyActor::TakeDamage(float Damage)
3
{
4
    Health -= Damage;
5
    if (Health <= 0)
6
    {
7
        Destroy();  // 标记为待销毁，不会立即删除
8
    }
9
}
10

11
// Destroy() 在当前帧、当前调用栈内同步执行完所有清理逻辑后才返回
12
// 实际的销毁流程（全同步，无延迟）：
13
// 1. Destroy() 被调用
14
// 2. 立即同步执行：Component 注销 → EndPlay() 回调 → 所有监听者收到通知
15
// 3. 标记 Garbage 标记位（EInternalObjectFlags::Garbage），
16
//    加入待 GC 回收队列（UE5 中 RF_PendingKill 已被彻底从源码中删除）
17
// 4. Destroy() 返回——此时 EndPlay 已经执行完毕！
18
// 5. 后续某一帧 GC 触发清扫 → 彻底释放堆内存
19

20
// ===== EndPlay —— Actor 的"遗言" =====
21
virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override
22
{
23
    Super::EndPlay(EndPlayReason);
24

25
    switch (EndPlayReason)
26
    {
27
    case EEndPlayReason::Destroyed:
28
        // 手动调用 Destroy()
29
        CleanupOwnedResources();
30
        break;
31
    case EEndPlayReason::LevelTransition:
32
        // 关卡切换——Actor 可能在下一关还有用
33
        break;
34
    case EEndPlayReason::EndPlayInEditor:
35
        // 在编辑器中停止 PIE
36
        break;
37
    case EEndPlayReason::RemovedFromWorld:
38
        // 从关卡中被移除（Streaming 卸载）
39
        break;
40
    }
41
}
42

43
// ===== 定时自毁 =====
44
// 在构造函数中设置：
45
InitialLifeSpan = 10.0f;  // 10 秒后自动 Destroy()
46

47
// 或在运行时：
48
SetLifeSpan(5.0f);
49

50
// ⚠️ Destroy() 后不要使用 Actor 指针！
51
AActor* Actor = GetOwner();
52
Actor->Destroy();  // EndPlay 已同步执行完毕，Garbage 标记已设置
53
// 此时堆内存仍在（GC 尚未 Sweep），但 Actor 已从世界注销、组件已卸载、
54
// IsActorBeingDestroyed() 返回 true，IsValid() 返回 false
55
// Actor->GetActorLocation();  // ⚠️ 仍能读到残留数据，但逻辑上已非法
56
// 真正的崩溃延迟到 GC Sweep 彻底释放堆内存之后

1
// ===== 三个核心层次 =====
2

3
// ① UActorComponent —— 最基础，无 Transform
4
UCLASS()
5
class UHealthComponent : public UActorComponent
6
{
7
    GENERATED_BODY()
8
    // 纯逻辑：管理血量、伤害、死亡
9
    // 没有世界位置——它只是一个挂在 Actor 上的逻辑模块
10
};
11

12
// ② USceneComponent —— 有 Transform，但不渲染
13
class UCameraComponent : public USceneComponent
14
{
15
    // 有位置（Transform），但没有视觉
16
    // SceneComponent 用于需要位置但不渲染的东西
17
};
18

19
// ③ UPrimitiveComponent —— 有 Transform，且可渲染/可碰撞
20
class UStaticMeshComponent : public UPrimitiveComponent
21
{
22
    // 有位置、有网格、有碰撞——完整的"游戏物体"
23
};

1
UCLASS()
2
class AMyActor : public AActor
3
{
4
    GENERATED_BODY()
5

6
public:
7
    AMyActor()
8
    {
9
        // 每个 Actor 必须有一个 RootComponent
10
        // RootComponent 决定了 Actor 的整体位置、旋转、缩放
11

12
        // 方式一：用一个 Mesh 作为 Root
13
        Mesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Mesh"));
14
        RootComponent = Mesh;  // Mesh 就是 Root
15

16
        // 方式二：用一个空的 SceneComponent 作为根节点
17
        // （当你有多个并列的子组件时更推荐）
18
        SceneRoot = CreateDefaultSubobject<USceneComponent>(TEXT("SceneRoot"));
19
        RootComponent = SceneRoot;
20

21
        // 然后把其他组件挂在 Root 下面
22
        Camera = CreateDefaultSubobject<UCameraComponent>(TEXT("Camera"));
23
        Camera->SetupAttachment(RootComponent);  // ← 挂到 Root 上
24
    }
25

26
    UPROPERTY(VisibleAnywhere)
27
    UStaticMeshComponent* Mesh;
28

29
    UPROPERTY(VisibleAnywhere)
30
    USceneComponent* SceneRoot;
31

32
    UPROPERTY(VisibleAnywhere)
33
    UCameraComponent* Camera;
34
};
35

36
// ⚠️ 常见疏忽：忘记设置 RootComponent
37
// Actor 允许不拥有 RootComponent——它仍能被正常 Spawn 并 Tick，
38
// 但此时 GetActorLocation() 永远返回 FVector::ZeroVector，
39
// 且无法挂载任何 USceneComponent 子组件（没有根节点供附着）。
40
// 这个 Actor 在 3D 世界中"隐形"了——失去了空间和物理属性。

1
// ===== 基本附着 =====
2
void UMyActor::SetupComponents()
3
{
4
    // 创建层级：Root → Body → Head → Helmet
5
    USceneComponent* Root = CreateDefaultSubobject<USceneComponent>(TEXT("Root"));
6
    RootComponent = Root;
7

8
    UStaticMeshComponent* Body = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Body"));
9
    Body->SetupAttachment(Root);           // Body 相对 Root
10

11
    UStaticMeshComponent* Head = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Head"));
12
    Head->SetupAttachment(Body, TEXT("HeadSocket"));  // Head 挂到 Body 的 Socket 上
13

14
    UStaticMeshComponent* Helmet = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Helmet"));
15
    Helmet->SetupAttachment(Head);         // Helmet 挂到 Head
16
    // ↑ 移动 Root → Body、Head、Helmet 全部跟随
17
    // ↑ 移动 Head  → Helmet 跟随，Body 不动
18
}
19

20
// ===== Attachment 变换规则 =====
21
// 有三个关键的 Transform：
22
FTransform WorldTransform = Component->GetComponentTransform();     // 世界空间
23
FTransform RelativeTransform = Component->GetRelativeTransform();   // 相对父级
24
FTransform SocketTransform = Component->GetSocketTransform(NAME_None); // Socket
25

26
// ===== 运行时动态附着（现代 UE5 推荐写法）=====
27
void AttachWeaponToHand(USceneComponent* Weapon, USkeletalMeshComponent* Character)
28
{
29
    // ✓ 现代 UE5 C++ 规范：通过目标组件的 GetMesh() 等访问器获取精确附着点，
30
    //    使用标准 C++ 接口 AttachToComponent（K2_ 前缀仅供蓝图 VM 使用，C++ 中禁用）
31

32
    // 方式一：附加到 Socket
33
    Weapon->AttachToComponent(
34
        Character->GetMesh(),  // ← 明确指定目标组件，而不是整个 Actor
35
        FAttachmentTransformRules::SnapToTargetNotIncludingScale,
36
        TEXT("WeaponSocket")
37
    );
38

39
    // 方式二：保持当前相对位置
40
    Weapon->AttachToComponent(
41
        Character->GetMesh(),
42
        FAttachmentTransformRules::KeepRelativeTransform,
43
        NAME_None  // 不绑定 Socket，直接附着到组件原点
44
    );
45

46
    // 方式三：保持世界位置不变
47
    Weapon->AttachToComponent(
48
        Character->GetMesh(),
49
        FAttachmentTransformRules::KeepWorldTransform,
50
        NAME_None
51
    );
52

53
    // ⚠️ 务必确保父组件已注册——未注册的组件上调用附着会静默失败！
54
    //    check(Character->GetMesh()->IsRegistered());
55
}
56

57
// ===== FAttachmentTransformRules 选项 =====
58
// SnapToTargetNotIncludingScale — 贴到目标位置/旋转，保留自身 Scale
59
// SnapToTargetIncludingScale     — 贴到目标位置/旋转，使用目标 Scale
60
// KeepRelativeTransform          — 保持当前的相对 Transform
61
// KeepWorldTransform             — 保持当前的世界位置
62
// KeepRelativeOffset             — 保持世界位置不变但计算新的相对偏移

1
// UChildActorComponent 允许你在一个 Actor 内部生成并管理另一个 Actor
2
// 典型场景：
3
// - 武器 Actor 嵌入角色 Actor
4
// - 粒子特效 Actor 嵌入触发器 Actor
5
// - 门 Actor 中嵌入一个交互提示 Actor
6

7
UCLASS()
8
class AWeaponActor : public AActor
9
{
10
    GENERATED_BODY()
11
public:
12
    void Fire() { /* ... */ }
13
};
14

15
UCLASS()
16
class AMyCharacter : public ACharacter
17
{
18
    GENERATED_BODY()
19

20
public:
21
    AMyCharacter()
22
    {
23
        WeaponChild = CreateDefaultSubobject<UChildActorComponent>(TEXT("WeaponChild"));
24
        WeaponChild->SetupAttachment(GetMesh(), TEXT("WeaponSocket"));
25

26
        // 在蓝图中设置 ChildActorClass，或者在 C++ 中：
27
        // WeaponChild->SetChildActorClass(AWeaponActor::StaticClass());
28
    }
29

30
    UPROPERTY(VisibleAnywhere)
31
    UChildActorComponent* WeaponChild;
32

33
    void FireWeapon()
34
    {
35
        if (AActor* WeaponActor = WeaponChild->GetChildActor())
36
        {
37
            Cast<AWeaponActor>(WeaponActor)->Fire();
38
        }
39
    }
40
};
41

42
// ⚠️ UChildActorComponent 的性能注意事项：
43
// - 每个 ChildActorComponent 会在内部 Spawn 一个完整的 Actor
44
// - 内部 Actor 有自己的 Tick、自己的 Component 层级
45
// - 大量使用会导致性能下降
46
// - 如果不需移动/独立逻辑，考虑直接用 USceneComponent + 静态网格代替

1
// ===== CreateDefaultSubobject —— 构造函数中创建 =====
2
// 只在构造函数中使用！它创建的 Component 会随 Actor 一起序列化
3
// 和复制，属于 Actor 的"永久零件"。
4

5
AMyActor::AMyActor()
6
{
7
    // ✓ 构造函数中用 CreateDefaultSubobject
8
    Mesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Mesh"));
9
    // ↑ 这个 Component 会参与序列化、网络复制、蓝图可见
10
}
11

12
// ===== NewObject —— 运行时动态创建 =====
13
// 在 BeginPlay 或之后使用。创建的 Component 需要手动注册，
14
// 不会被序列化保存。
15

16
void AMyActor::SpawnDynamicComponent()
17
{
18
    if (!GetWorld()) return;
19

20
    UStaticMeshComponent* DynamicMesh = NewObject<UStaticMeshComponent>(
21
        this,                        // Outer —— 防止 GC 回收！
22
        TEXT("DynamicMesh")          // Name（FName 参数）
23
    );
24

25
    // ⚠️ 必须手动注册！否则 Component 不会工作
26
    // ⚠️ RegisterComponent() 只能在 GameThread（主线程）调用！
27
    //    其底层会将网格数据、光源数据注册进渲染器场景（FScene::AddPrimitive），
28
    //    如果在异步回调或 ParallelFor 中误触动态注册，
29
    //    会导致 RHI 线程与渲染线程死锁崩溃
30
    //
31
    // ★ 关键顺序：先 Attach（确定相对变换），后 Register（带着正确的变换注册进世界）
32
    //    如果先 Register 再 Attach → 组件先以世界原点(0,0,0)注册进渲染/物理场景，
33
    //    随后的 Attach 迫使渲染和物理代理销毁并重新注册 → 性能浪费 + 潜在闪烁
34
    DynamicMesh->AttachToComponent(
35
        RootComponent,
36
        FAttachmentTransformRules::KeepRelativeTransform
37
    );
38
    DynamicMesh->RegisterComponent();  // ← 此时带着正确的相对变换一步到位注册
39

40
    // ✓ 现在 DynamicMesh 可以正常渲染和 Tick
41
}
42

43
// ===== 移除动态创建的 Component =====
44
void AMyActor::RemoveDynamicComponent(UActorComponent* Comp)
45
{
46
    if (Comp)
47
    {
48
        Comp->DestroyComponent();  // 从世界中注销 + 标记待 GC
49
        // 或
50
        Comp->UnregisterComponent();  // 仅注销，不销毁
51
    }
52
}

1
// 陷阱 1：忘记 RegisterComponent
2
USceneComponent* Comp = NewObject<USceneComponent>(this);
3
Comp->AttachToComponent(RootComponent, FAttachmentTransformRules::KeepRelativeTransform);
4
// ✗ Component 没有注册！不会渲染，不会 Tick，GetWorld() 返回 nullptr
5
// ✓ 必须调用 Comp->RegisterComponent();
6

7
// 陷阱 2：在 Component 注册前访问世界
8
USceneComponent* Comp = NewObject<USceneComponent>(this);
9
UWorld* World = Comp->GetWorld();  // ✗ nullptr！还没注册
10
Comp->RegisterComponent();
11
World = Comp->GetWorld();          // ✓ 现在有了
12

13
// 陷阱 3：CreateDefaultSubobject 的名称冲突
14
AMyActor::AMyActor()
15
{
16
    auto* Mesh1 = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Mesh"));
17
    auto* Mesh2 = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Mesh"));
18
    // ✗ 两个 Component 同名！引擎会修正，但可能导致引用混乱
19
}
20

21
    // 陷阱 4：销毁的 Component 仍被引用 —— GC Sweep 后变野指针
22
void SomeFunction()
23
{
24
    UStaticMeshComponent* Comp = GetComponentByClass<UStaticMeshComponent>();
25
    Comp->DestroyComponent();
26
    // DestroyComponent 内部会立刻触发 UnregisterComponent() 并解除附着，
27
    // 将组件从渲染、物理、Tick 系统中彻底卸载，不再可见/不再有物理响应。
28
    // 但堆上的 C++ 内存此刻仍然是 100% 完整的——绝非"底层内存结构已残废"！
29
    //
30
    // Comp->GetComponentLocation();  // ✓ 当前仍可安全读取（内存在 GC Sweep 前完好）
31
    // Comp->GetWorld();              // 返回 nullptr——已从世界注销
32
    //
33
    // 真正危险的时刻：GC 触发的下一次清扫（Sweep）彻底释放堆内存后，
34
    // Comp 才变成真正的野指针 → 此时任何解引用都 Access Violation 闪退
35
    //
36
    // ✓ DestroyComponent() 后立即置 nullptr，防止 GC 清扫后误用：
37
    Comp = nullptr;
38
}

1
// 纯 ECS（如 Unity DOTS、EnTT）：
2
// Entity 只是一个 ID 数字，Component 是纯数据 struct，System 遍历所有 Entity
3
//
4
// UE 的 Actor-Component 模型（一种"混合 ECS"）：
5
// - Actor ≈ Entity（有 ID、有 Transform）
6
// - Component ≈ Component（数据和逻辑的混合体，不是纯数据）
7
// - System 被分散到了多个地方（World、GameMode、Subsystem、Tick）
8

9
// ===== 对比表 =====
10
//              | 纯 ECS             | UE Actor-Component
11
// ------------ | ------------------ | -------------------------
12
// Entity       | 只是一个整数 ID     | AActor——是一个类，有生命周期
13
// Component    | 纯数据 struct       | UActorComponent——封装数据 + 逻辑
14
// System       | 独立的查询+处理逻辑  | Tick / GameMode / Subsystem
15
// 数据分布     | 按 Component 类型连续 | 按 Actor 分散存储
16
// 内存友好度   | ★★★★★（缓存行友好）  | ★★★☆☆（对象分散在堆上）
17
// 继承支持     | ❌ 无（通过组合）     | ✅ 支持（但 Epic 不鼓励深层继承）
18
// C++ 复杂度  | ★★★☆☆               | ★★☆☆☆（更接近传统 OOP）
19
// 蓝图友好     | ❌                    | ★★★★★（可视化、拖拽式编程）

1
// ===== ✗ 传统继承思维 —— 容易导致恐怖的深层继承链 =====
2
class AEntity : public AActor {};
3
class APawn : public AEntity {};
4
class AFighter : public APawn {};
5
class AArcher : public AFighter {};
6
class AFireArcher : public AArcher {};
7
class AIceArcher : public AArcher {};
8
// 需求变了："我要一个会射箭的战士，但他不会魔法"
9
// → 继承链爆炸！无法灵活组合
10

11
// ===== ✓ UE Component 思维 —— 用 Component 描述能力 =====
12
UCLASS()
13
class AModularCharacter : public ACharacter
14
{
15
    GENERATED_BODY()
16
public:
17
    // 能力 = Component 的组合
18
    UPROPERTY(VisibleAnywhere)
19
    UHealthComponent* Health;
20

21
    UPROPERTY(VisibleAnywhere)
22
    UInventoryComponent* Inventory;
23

24
    UPROPERTY(VisibleAnywhere)
25
    UCombatComponent* Combat;  // 可以挂载武器
26

27
    // 如果你想让他会魔法？加一个 MagicComponent
28
    // 如果你想让他会飞行？加一个 FlightComponent
29
    // 如果你想让他会游泳？加一个 SwimComponent
30
    // 不需要继承！不需要改类！直接在编辑器中添加/移除 Component！
31

32
    // 运行时检查能力：
33
    bool CanFly() const { return FindComponentByClass<UFlightComponent>() != nullptr; }
34
    bool CanCastMagic() const { return FindComponentByClass<UMagicComponent>() != nullptr; }
35
};

1
// 崩溃 #1：访问已销毁的 Actor
2
AActor* Actor = GetOwner();
3
Actor->Destroy();
4
Actor->GetActorLocation();  // ⚠️ 不可靠：内存在 GC Sweep 后才真正释放
5
// ✓ 解决方案：始终在访问前检查 IsValid()
6
if (IsValid(Actor))
7
{
8
    Actor->GetActorLocation();
9
}
10

11
// 崩溃 #2：没有 RootComponent 的 Actor —— 不会崩溃，但会残废
12
AMyActor::AMyActor()
13
{
14
    // 忘记了 RootComponent = xxx;
15
    // → Actor 仍能被正常 Spawn 并在世界中 Tick，但：
16
    //   · GetActorLocation() 永远返回 FVector::ZeroVector
17
    //   · 无法挂载任何 USceneComponent 子组件（没有根节点供附着）
18
    //   · 失去了空间和物理属性——在 3D 世界中"隐形"
19
}
20
// ✓ 检查：每个需要空间存在的 Actor 必须有一个 RootComponent
21

22
// 崩溃 #3：在 Component 注册前使用
23
USceneComponent* Comp = NewObject<USceneComponent>(this);
24
Comp->AttachToComponent(RootComponent, ...);
25
Comp->GetComponentLocation();  // ✗ 没注册，Transform 未初始化！
26
// ✓ 先 RegisterComponent()
27

28
// 崩溃 #4：后台线程访问 Component（回顾第7章的 GameThread 铁律）
29
AsyncTask(ENamedThreads::AnyBackgroundThreadNormalTask, [this]() {
30
    MeshComponent->SetMaterial(0, NewMaterial);  // ✗ 后台线程！
31
});
32

33
// 崩溃 #5：重复注册同名 Component
34
void BadFunction()
35
{
36
    auto* C1 = NewObject<UStaticMeshComponent>(this, TEXT("SameName"));
37
    auto* C2 = NewObject<UStaticMeshComponent>(this, TEXT("SameName"));
38
    C1->RegisterComponent();
39
    C2->RegisterComponent();  // ← 可能因名称冲突导致不可预测的行为
40
}