第九章 Game Framework 与 Subsystem 体系：掌控游戏世界的运转#

一句话理解：UE 的游戏框架是一套职责分明的七件套（GameInstance → GameMode → GameState → PlayerController → Pawn → PlayerState → HUD），每个类只做一件事。但 UE5 之后，你的游戏逻辑不应该全塞进 GameMode——Subsystem 是从 GameMode 中”解耦出来的逻辑切片”，它不依赖关卡、不依赖 Actor，只跟随其 Owner 的生命周期。理解这两层，你就真正理解了”UE 游戏怎么跑起来的”。

9.1 概念直觉 —— 一个请求从”进入游戏”到”角色生成”走了哪些类？#

9.1.1 全景：七件套职责地图#

flowchart TD GI["GameInstance\n👑 进程级单例\n跨关卡持久存在"] subgraph 关卡内 ["关卡生命周期（一个 World）"] GM["GameMode\n📜 服务器端规则\n谁赢？怎么生？"] GS["GameState\n📊 服务器→客户端广播\n比分、计时、天气"] PC["PlayerController\n🎮 玩家"大脑"\n输入→处理→UI"] subgraph 玩家端 ["每个玩家拥有"] PS["PlayerState\n📋 玩家数据\n名字、击杀数、延迟"] Pawn["Pawn / Character\n🏃 玩家在世界的'身体'\n移动、动画、碰撞"] HUD["HUD / UMG\n🖥️ 屏幕显示\n血条、准星、小地图"] end end GI --> GM GM --> GS GM --> PC PC --> Pawn PC --> HUD PC --> PS GS --> PS style GI fill:#d00000,stroke:#e85d04,color:white style GM fill:#d00000,stroke:#e85d04,color:white style PC fill:#e85d04,stroke:#f48c06,color:white style GS fill:#e85d04,stroke:#f48c06,color:white

9.1.2 一张表记住”谁在谁上面”#

1
// ===== Game Framework 七件套 · 存在范围速查 =====
2
//
3
// GameInstance           ← 进程启动→退出（最持久，跨关卡唯一）
4
//   └─ UWorld           ← 关卡加载→卸载
5
//        ├─ GameMode    ← 服务器端，关卡存在期间（切换关卡会销毁重建）
6
//        ├─ GameState   ← 服务器+客户端都复制，关卡存在期间
7
//        │                  ⚠️ 切换关卡时随 World 销毁！不能跨关卡保留！
8
//        ├─ PlayerController ← 玩家加入→退出
9
//        │    │              Seamless Travel 时保留，普通 Travel 销毁
10
//        │    ├─ Pawn   ← 玩家 Possess→UnPossess（可换，切换关卡销毁）
11
//        │    ├─ PlayerState ← 玩家加入→退出
12
//        │    │              Seamless Travel 时保留，普通 Travel 销毁
13
//        │    └─ HUD    ← 玩家拥有时（蓝图中常见）
14
//        └─ LevelScriptActor ← 关卡存在期间（每个关卡一个）
15

16
// ===== 网络角色速查（后续 Ch12 会详细展开）=====
17
// GameMode    — 只存在于服务器！客户端没有！
18
// GameState   — 服务器有权威，自动复制到所有客户端
19
// PlayerController — 每个连接的玩家各有一个，只在"自己的客户端"有权威
20
// Pawn        — 服务器有权威，客户端有"模拟代理"
21
// PlayerState — 服务器有权威，自动复制到所有客户端

9.2 Game Framework 七件套 —— 逐一拆解#

9.2.1 GameInstance —— 跨关卡的”进程级管家”#

1
// GameInstance 从游戏启动到退出一直存在，不随关卡切换而销毁。
2
// 这是你存放"整个游戏会话"级别数据的地方。
3

4
UCLASS()
5
class UMyGameInstance : public UGameInstance
6
{
7
    GENERATED_BODY()
8

9
public:
10
    // ✓ 适合放在 GameInstance 的数据：
11
    // - 全局配置（难度、画质、音量）
12
    // - 玩家登录信息
13
    // - 跨关卡背包/存档数据
14
    // - 多人大厅连接信息
15

16
    UPROPERTY(BlueprintReadOnly)
17
    FString PlayerNickname;
18

19
    UPROPERTY(BlueprintReadOnly)
20
    TMap<FName, int32> GlobalInventory;  // 跨关卡的背包！
21

22
    // ✗ 不适合：
23
    // - 关卡相关的状态（放 GameState）
24
    // - 具体角色的属性（放 PlayerState 或 Pawn 身上）
25

26
    virtual void Init() override
27
    {
28
        Super::Init();
29
        // GameInstance 的初始化——此时还没有 World，不能访问关卡
30
    }
31

32
    virtual void Shutdown() override
33
    {
34
        // 游戏退出时清理
35
        Super::Shutdown();
36
    }
37
};
38

39
// ⚠️ GameInstance 不参与网络复制！所有客户端各自有一套 GameInstance
40
// 如果你是 DS（Dedicated Server），GameInstance 只在服务器进程存在
41
// 客户端的数据通过 GameState / PlayerState 的 UPROPERTY(Replicated) 同步

9.2.2 GameMode —— 服务器端的”游戏规则书”#

1
// GameMode 只存在于服务器！客户端根本不知道 GameMode 的存在。
2
// 它定义了游戏的规则：怎么开局、怎么算赢、怎么生成玩家。
3

4
UCLASS()
5
class AMyGameMode : public AGameModeBase
6
{
7
    GENERATED_BODY()
8

9
public:
10
    AMyGameMode()
11
    {
12
        // 设置默认的 Pawn 类型——当玩家加入时自动生成
13
        DefaultPawnClass = AMyCharacter::StaticClass();
14

15
        // 设置 PlayerController 类型
16
        PlayerControllerClass = AMyPlayerController::StaticClass();
17

18
        // 设置 GameState 类型
19
        GameStateClass = AMyGameState::StaticClass();
20

21
        // 设置 PlayerState 类型
22
        PlayerStateClass = AMyPlayerState::StaticClass();
23

24
        // 设置 HUD 类型
25
        HUDClass = AMyHUD::StaticClass();
26
    }
27

28
    // ===== GameMode 的核心虚函数——你重写它们来定义游戏规则 =====
29

30
    // 玩家加入时——决定 Spawn 位置
31
    virtual AActor* ChoosePlayerStart_Implementation(AController* Player) override
32
    {
33
        // 从所有 PlayerStart Actor 中选一个
34
        // 默认按"最不拥挤"原则分配
35
        return Super::ChoosePlayerStart_Implementation(Player);
36
    }
37

38
    // 玩家死后——决定何时重生、在哪重生
39
    virtual void RestartPlayer(AController* NewPlayer) override
40
    {
41
        Super::RestartPlayer(NewPlayer);
42
        // 默认行为：在 ChoosePlayerStart 返回的位置 Spawn DefaultPawnClass
43
    }
44

45
    // 比赛是否应该结束？
46
    virtual bool ReadyToEndMatch_Implementation() override
47
    {
48
        // 你的胜负条件在这里判断
49
        return false;
50
    }
51

52
    // 比赛结束时调用
53
    virtual void HandleMatchHasEnded() override
54
    {
55
        Super::HandleMatchHasEnded();
56
        // 显示结算界面、冻结操作……
57
    }
58

59
    // 玩家登录时——可以在此拒绝连接
60
    virtual void PreLogin(const FString& Options, const FString& Address,
61
                          const FUniqueNetIdRepl& UniqueId, FString& ErrorMessage) override
62
    {
63
        Super::PreLogin(Options, Address, UniqueId, ErrorMessage);
64
        // 如果设了 ErrorMessage = "房间已满"，此玩家会被拒绝
65
    }
66

67
    // ⚠️ 不要在 GameMode 中放 UI 逻辑！
68
    // GameMode 只在服务器——客户端看不到它
69
    // UI 逻辑放 PlayerController 或 HUD
70
};
71

72
// ===== AGameMode vs AGameModeBase =====
73
// AGameModeBase — 最简模式（单人/合作游戏）
74
// AGameMode     — 完整模式（继承 GameModeBase，加了匹配状态机：
75
//                 等待玩家→准备→比赛中→赛后→结算）

9.2.3 GameState —— 所有人都在看的”记分板”#

1
// GameState 存在于服务器，并自动复制到所有客户端。
2
// 它是 Game Framework 中唯一"服务器权威、所有人可见"的状态容器。
3

4
UCLASS()
5
class AMyGameState : public AGameStateBase
6
{
7
    GENERATED_BODY()
8

9
public:
10
    // ★ 关键：用 Replicated 让属性自动同步到所有客户端
11
    UPROPERTY(Replicated, BlueprintReadOnly, Category = "Game")
12
    int32 TeamAScore;
13

14
    UPROPERTY(Replicated, BlueprintReadOnly, Category = "Game")
15
    int32 TeamBScore;
16

17
    UPROPERTY(Replicated, BlueprintReadOnly, Category = "Game")
18
    float RemainingTime;
19

20
    UPROPERTY(Replicated, BlueprintReadOnly, Category = "Game")
21
    FName CurrentWeather;  // ← 例子：天气系统状态
22

23
    // ===== 网络复制规则（GetLifetimeReplicatedProps）=====
24
    virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override
25
    {
26
        Super::GetLifetimeReplicatedProps(OutLifetimeProps);
27

28
        // 对所有客户端复制（默认）
29
        DOREPLIFETIME(AMyGameState, TeamAScore);
30
        DOREPLIFETIME(AMyGameState, TeamBScore);
31

32
        // 条件复制示例：RemainingTime 跳过主控端（本地有预测），只同步给模拟端
33
        DOREPLIFETIME_CONDITION(AMyGameState, RemainingTime, COND_SkipOwner);
34

35
        // 如果确实需要"除 Owner 外所有人"的条件复制，使用：
36
        // DOREPLIFETIME_CONDITION(AMyGameState, RemainingTime, COND_SkipOwner);
37
        // ↑ COND_SkipOwner = 对除 Owner 外的所有客户端复制
38
    }
39

40
    // ✓ 适合放 GameState：
41
    // - 比分、计时、比赛阶段（所有人需要知道）
42
    // - 天气、全局事件
43
    // - 所有在线玩家列表（PlayerArray 已经内建）
44
    //   → GameState->PlayerArray 存放了所有 PlayerState 引用
45

46
    UFUNCTION(BlueprintCallable, Category = "Game")
47
    void AddScore(int32 TeamId, int32 Points)
48
    {
49
        // 这段代码只在服务器执行（GameMode 中调用）
50
        if (TeamId == 0) TeamAScore += Points;
51
        else TeamBScore += Points;
52
        // ★ 修改会自动复制到所有客户端！
53
    }
54
};
55

56
// ===== GameState 的 PlayerArray =====
57
// GameState 内部维护了 PlayerArray（TArray<APlayerState*>），
58
// 每个连接的玩家都有一个对应的 PlayerState
59
void AMyPlayerController::GetAllPlayerNames()
60
{
61
    if (AGameStateBase* GS = GetWorld()->GetGameState())
62
    {
63
        for (APlayerState* PS : GS->PlayerArray)
64
        {
65
            UE_LOG(LogTemp, Log, TEXT("玩家：%s，击杀：%d"), *PS->GetPlayerName(), PS->GetScore());
66
        }
67
    }
68
}

9.2.4 PlayerController —— 玩家的”大脑”#

1
// PlayerController 是玩家和游戏世界之间的"桥梁"
2
// 它接收输入 → 控制 Pawn → 管理 UI → 处理网络 RPC
3

4
UCLASS()
5
class AMyPlayerController : public APlayerController
6
{
7
    GENERATED_BODY()
8

9
public:
10
    virtual void BeginPlay() override
11
    {
12
        Super::BeginPlay();
13

14
        // 设置输入模式——决定输入流向
15
        // 方式一：纯 UI（菜单、登录界面）
16
        // SetInputMode(FInputModeUIOnly());
17

18
        // 方式二：纯游戏（没有 UI 交互）
19
        // SetInputMode(FInputModeGameOnly());
20

21
        // 方式三：混合模式（游戏+UI，最常用）
22
        FInputModeGameAndUI InputMode;
23
        InputMode.SetLockMouseToViewportBehavior(EMouseLockMode::LockAlways);
24
        InputMode.SetHideCursorDuringCapture(true);
25
        SetInputMode(InputMode);
26

27
        // 显示鼠标光标
28
        bShowMouseCursor = false;  // FPS 游戏通常关闭
29
    }
30

31
    // ===== Possess / UnPossess —— 控制 Pawn =====
32
    virtual void OnPossess(APawn* InPawn) override
33
    {
34
        Super::OnPossess(InPawn);
35
        // 此时"附身"了一个 Pawn——可以开始控制它
36
        UE_LOG(LogTemp, Log, TEXT("现在控制：%s"), *InPawn->GetName());
37
    }
38

39
    virtual void OnUnPossess() override
40
    {
41
        Super::OnUnPossess();
42
        // Pawn 被夺走（死亡、换角色……）
43
    }
44

45
    // ===== Server RPC —— 从客户端调用，在服务器执行 =====
46
    UFUNCTION(Server, Reliable)
47
    void ServerRequestRespawn();
48

49
    void ServerRequestRespawn_Implementation()
50
    {
51
        // 这段代码在服务器上执行！
52
        // 客户端请求重生 → 服务器处理
53
        if (AGameModeBase* GM = GetWorld()->GetAuthGameMode())
54
        {
55
            GM->RestartPlayer(this);
56
        }
57
    }
58

59
    // ===== Client RPC —— 从服务器调用，在"拥有此控制器的客户端"上执行 =====
60
    UFUNCTION(Client, Reliable)
61
    void ClientShowGameOverMessage(const FString& Message);
62

63
    void ClientShowGameOverMessage_Implementation(const FString& Message)
64
    {
65
        // 这段代码只在这个玩家的客户端上执行！
66
        // 用于显示个人消息（你死了/你赢了/你获得了成就……）
67
        if (GEngine)
68
        {
69
            GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, Message);
70
        }
71
    }
72

73
    // ✓ PlayerController 适合做的事：
74
    // - 输入处理（绑定 InputAction）
75
    // - 控制 Pawn 移动/视角
76
    // - 管理 UI（创建 Widget、切换界面）
77
    // - RPC 通信（Server/Client 函数）
78
    // - 摄像机管理
79

80
    // ✗ PlayerController 不适合做的事：
81
    // - 游戏规则判断（放 GameMode）
82
    // - 持久化状态（放 PlayerState 或 GameState）
83
    // - 全局逻辑（放 Subsystem）
84
};
85

86
// ⚠️ 核心区分：PlayerController vs PlayerState
87
//
88
// PlayerController — 玩家的"输入输出装置"
89
//   · 属于"拥有者客户端"——每个客户端有自己的独立版本
90
//   · 换关卡时可能销毁重建
91
//   · 放：输入、UI、摄像机、RPC
92
//
93
// PlayerState — 玩家的"档案数据"
94
//   · 从服务器复制到所有客户端（所有人能看到你的击杀数）
95
//   · Seamless Travel 时保留，普通 Travel 时销毁
96
//   · 放：名字、分数、击杀数、Ping、队伍 ID

9.2.5 Pawn / Character —— 玩家在世界的”身体”#

1
// APawn — 最基础的"可控实体"
2
// ACharacter — APawn + 胶囊碰撞体 + 骨骼网格 + 移动组件（最常用）
3

4
UCLASS()
5
class AMyCharacter : public ACharacter
6
{
7
    GENERATED_BODY()
8

9
public:
10
    AMyCharacter()
11
    {
12
        // ACharacter 默认创建了：
13
        // - UCapsuleComponent（碰撞）
14
        // - USkeletalMeshComponent（模型）
15
        // - UCharacterMovementComponent（移动）
16
        // 你只需要加自己的 Component
17

18
        HealthComponent = CreateDefaultSubobject<UHealthComponent>(TEXT("Health"));
19
        InventoryComponent = CreateDefaultSubobject<UInventoryComponent>(TEXT("Inventory"));
20
    }
21

22
    virtual void BeginPlay() override
23
    {
24
        Super::BeginPlay();
25

26
        // 检查是否由玩家控制
27
        if (IsPlayerControlled())
28
        {
29
            // 初始化玩家专属逻辑
30
        }
31
        else
32
        {
33
            // AI 控制的角色——初始化行为树
34
            if (AAIController* AI = Cast<AAIController>(GetController()))
35
            {
36
                // 启动 AI 行为树
37
            }
38
        }
39
    }
40

41
    // ===== 获取控制者 =====
42
    APlayerController* GetMyPlayerController() const
43
    {
44
        return Cast<APlayerController>(GetController());
45
    }
46

47
    // ===== 获取 PlayerState =====
48
    AMyPlayerState* GetMyPlayerState() const
49
    {
50
        return GetPlayerState<AMyPlayerState>();
51
    }
52

53
protected:
54
    UPROPERTY(VisibleAnywhere)
55
    UHealthComponent* HealthComponent;
56

57
    UPROPERTY(VisibleAnywhere)
58
    UInventoryComponent* InventoryComponent;
59
};
60

61
// ===== Pawn vs Character —— 什么时候用 Pawn？=====
62
// 用 APawn（而不是 ACharacter）的场景：
63
// - 无人机、飞行摄像机——不需要胶囊体和行走动画
64
// - VR 手部表示——不需要角色移动逻辑
65
// - 载具内部视角——载具本身是 Pawn
66
// - 弹幕射击中的子弹观察者
67
//
68
// 核心判断：
69
// "这个实体需要双足行走、骨骼动画、胶囊碰撞、行走移动？"
70
//  → 是：ACharacter
71
//  → 否：APawn（更轻量）

9.2.6 PlayerState —— 玩家的”档案袋”#

1
// PlayerState 是玩家的"永久数据"——随玩家连接存在，换关卡不丢。
2
// 从服务器复制到所有客户端（所有人都能看到别人的 PlayerState）。
3

4
UCLASS()
5
class AMyPlayerState : public APlayerState
6
{
7
    GENERATED_BODY()
8

9
public:
10
    // ★ 这些属性自动复制到所有客户端
11
    UPROPERTY(Replicated, BlueprintReadOnly)
12
    int32 KillCount;
13

14
    UPROPERTY(Replicated, BlueprintReadOnly)
15
    int32 DeathCount;
16

17
    UPROPERTY(Replicated, BlueprintReadOnly)
18
    int32 TeamId;
19

20
    UPROPERTY(Replicated, BlueprintReadOnly)
21
    bool bIsReady;  // 大厅中是否准备就绪
22

23
    virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override
24
    {
25
        Super::GetLifetimeReplicatedProps(OutLifetimeProps);
26
        DOREPLIFETIME(AMyPlayerState, KillCount);
27
        DOREPLIFETIME(AMyPlayerState, DeathCount);
28
        DOREPLIFETIME(AMyPlayerState, TeamId);
29
        DOREPLIFETIME(AMyPlayerState, bIsReady);
30
    }
31

32
    UFUNCTION()
33
    void AddKill()
34
    {
35
        KillCount++;
36
        // 服务器修改后自动同步到所有客户端
37
    }
38

39
    // ===== PlayerState 内部的便利方法 =====
40
    // GetPlayerName()  — 玩家名字（内建复制）
41
    // GetScore()       — 内建的分数系统
42
    // GetUniqueId()    — 玩家网络唯一 ID
43
    // GetPing()        — 玩家延迟（毫秒）
44

45
    // ✓ 适合放 PlayerState：
46
    // - 名字、分数、击杀/死亡（所有人需要知道）
47
    // - 队伍 ID、角色职业选择
48
    // - 玩家延迟
49
    // - 大厅准备状态
50
    //
51
    // ✗ 不适合：
52
    // - UI 状态（放 PlayerController）
53
    // - 角色具体属性如 HP（放 Pawn 或 Component）
54
    // - 输入绑定（放 PlayerController）
55
};
56

57
// ⚠️ PlayerState 与 Pawn 的区别——面试最常见考点：
58
//
59
// PlayerState — 跟着"玩家连接"存在于 PlayerController 上
60
//   · 换关卡、换 Pawn（重生）都不销毁
61
//   · 自动复制到所有客户端
62
//   · 放：名字、击杀数、队伍
63
//
64
// Pawn — 跟着"游戏世界中的身体"存在
65
//   · 重生 = 销毁旧 Pawn + Spawn 新 Pawn（PlayerState 中的击杀数保留）
66
//   · 只有自己有权威
67
//   · 放：HP、当前位置、动画状态

9.2.7 HUD —— 屏幕上的”画布”#

1
// HUD 是最古老的 UI 方案——直接用 Canvas 绘制。
2
// 现代 UE5 项目中，大多数团队用 UMG Widget 替代 HUD，
3
// 但 HUD 仍然在轻量级 Debug 绘制和快速原型中常见。
4

5
UCLASS()
6
class AMyHUD : public AHUD
7
{
8
    GENERATED_BODY()
9

10
public:
11
    virtual void DrawHUD() override
12
    {
13
        Super::DrawHUD();
14

15
        // 每帧调用——用 Canvas 直接画
16
        // 绘制准星
17
        float CenterX = Canvas->ClipX * 0.5f;
18
        float CenterY = Canvas->ClipY * 0.5f;
19

20
        DrawLine(CenterX - 10, CenterY, CenterX + 10, CenterY, FLinearColor::Green, 2.0f);
21
        DrawLine(CenterX, CenterY - 10, CenterX, CenterY + 10, FLinearColor::Green, 2.0f);
22

23
        // 绘制 Debug 文字
24
        DrawText(TEXT("Press F1 for Debug Menu"), FVector2D(10, 10),
25
                 nullptr, 1.0f, FLinearColor::Yellow);
26
    }
27
};
28

29
// ===== 现代 UE5 推荐：用 UMG 替代 HUD =====
30
// HUD 适合：Debug 绘制、极简 UI
31
// UMG 适合：正式的游戏 UI、菜单、HUD
32
// 在 PlayerController 中创建 UMG Widget：
33
//
34
// void AMyPlayerController::BeginPlay()
35
// {
36
//     if (IsLocalPlayerController())  // 只在本地客户端创建
37
//     {
38
//         if (UMyMainWidget* Widget = CreateWidget<UMyMainWidget>(this, MainWidgetClass))
39
//         {
40
//             Widget->AddToViewport();
41
//         }
42
//     }
43
// }

9.3 游戏流程控制 —— 从”登录”到”比赛结束”的完整时序#

9.3.1 单人/合作游戏流程#

sequenceDiagram participant Client participant GI as GameInstance participant World as UWorld participant GM as GameMode participant PC as PlayerController participant Pawn Client->>World: 加载关卡（OpenLevel） World->>GM: InitGame() GM->>GM: 设置 DefaultPawnClass / GameStateClass World->>PC: Spawn PlayerController PC->>GM: 请求生成 Pawn GM->>GM: ChoosePlayerStart() GM->>World: SpawnActor(DefaultPawnClass) World-->>PC: 返回新 Pawn PC->>Pawn: Possess() Pawn->>Pawn: BeginPlay() Note over Pawn,GM: === 游戏运行中 === GM->>GM: ReadyToEndMatch()? → true GM->>GM: HandleMatchHasEnded() GM-->>PC: 通知比赛结束 PC->>Pawn: 禁用输入

9.3.1.1 多人网络下的玩家登录三部曲（大厂面试高频）#

1
// ===== Dedicated Server 处理新玩家连接的严格时序 =====
2
// 面试中经常被要求口述这个流程：
3

4
// 第一部：PreLogin —— 预登录校验（在此可拒绝连接）
5
void AMyGameMode::PreLogin(const FString& Options, const FString& Address,
6
                           const FUniqueNetIdRepl& UniqueId, FString& ErrorMessage)
7
{
8
    Super::PreLogin(Options, Address, UniqueId, ErrorMessage);
9

10
    // 从 Options 字符串中解析登录参数
11
    // 例：Open 127.0.0.1?Password=1234?TeamId=1
12
    // Options = "?Password=1234?TeamId=1"
13

14
    if (!ValidatePassword(UGameplayStatics::ParseOption(Options, TEXT("Password"))))
15
    {
16
        ErrorMessage = TEXT("密码错误");  // 玩家被拒绝连接
17
    }
18
    // 此时还没有 PlayerController —— 只有网络连接
19
}
20

21
// 第二部：Login —— 正式创建 PlayerController
22
// PlayerController* AMyGameMode::Login(
23
//     UPlayer* NewPlayer, ENetRole InRemoteRole,
24
//     const FString& Portal, const FString& Options,
25
//     const FUniqueNetIdRepl& UniqueId, FString& ErrorMessage)
26
// {
27
//     // 引擎内部调用 SpawnPlayerController，创建专属 PC
28
//     return Super::Login(NewPlayer, InRemoteRole, Portal, Options, UniqueId, ErrorMessage);
29
// }
30

31
// 第三部：PostLogin —— PC 已创建，开始同步和 Spawn Pawn
32
void AMyGameMode::PostLogin(APlayerController* NewPlayer)
33
{
34
    Super::PostLogin(NewPlayer);
35
    // ✓ 此时 PlayerController 已完全创建，可以安全地进行 RPC 通知
36
    // ✓ 默认会在此处调用 RestartPlayer(NewPlayer) 生成 Pawn
37
    // ✓ 这是你"欢迎新玩家、同步初始状态"的标准入口
38

39
    // 例：广播新玩家加入
40
    if (AMyGameState* GS = GetGameState<AMyGameState>())
41
    {
42
        // 通过 GameState 通知所有客户端"有新人加入"
43
    }
44
}
45

46
// 时序口诀：PreLogin（校验→拒绝/通过）→ Login（创建PC）→ PostLogin（开始RPC+生成Pawn）

9.3.2 Seamless Travel（无缝切换关卡）#

1
// ===== Seamless Travel vs 普通 OpenLevel =====
2
//
3
// 普通 OpenLevel：
4
//   1. 卸载当前关卡 → 所有 Actor 销毁 → PlayerController/PlayerState 也销毁
5
//   2. 加载新关卡 → 重新创建一切
6
//   3. 玩家看到加载画面
7
//
8
// Seamless Travel：
9
//   1. 当前关卡保留
10
//   2. 新关卡在"后台"加载
11
//   3. 加载完成后，保留 PlayerController 和 PlayerState，
12
//      只销毁"关卡相关的 Actor"
13
//   4. 在新关卡中重新 Spawn Pawn
14
//   5. 玩家几乎感知不到切换
15

16
// ===== 启用 Seamless Travel =====
17
// 在 GameMode 构造函数中：
18
AMyGameMode::AMyGameMode()
19
{
20
    bUseSeamlessTravel = true;
21
}
22

23
// ===== 切换到新关卡 =====
24
void AMyGameMode::TransitionToNextLevel()
25
{
26
    // 普通方式——玩家看到加载画面
27
    // GetWorld()->ServerTravel("/Game/Maps/NextLevel");
28

29
    // Seamless——前提是 GameMode 中 bUseSeamlessTravel = true
30
    GetWorld()->SeamlessTravel("/Game/Maps/NextLevel");
31
}
32

33
// ===== Seamless Travel 中 Actor 的"去留规则" =====
34
// 场景 Actors —— 全部销毁
35
// GameMode —— 销毁（新关卡使用新的 GameMode，在 WorldSettings 中配置）
36
// GameState —— 销毁！⚠️ GameState 绑定在 UWorld 上，切换 World 时必然销毁
37
//             → 如需跨关卡传递全局状态，必须通过：
38
//               ① GameMode::GetSeamlessTravelActorList() 显式注册保留的 Actor
39
//               ② GameInstance（进程级单例，天然跨关卡）
40
// PlayerController —— 保留（引擎自动处理）
41
// PlayerState —— 保留（引擎自动处理）
42
// GameInstance —— 保留（本来就不随关卡销毁）
43

44
// ===== Actor 如何处理 Seamless Travel =====
45
UCLASS()
46
class AMyActor : public AActor
47
{
48
    // 如果你的 Actor 需要在 Seamless Travel 中保留：
49
    virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override
50
    {
51
        Super::GetLifetimeReplicatedProps(OutLifetimeProps);
52
        // bNetLoadOnClient = true 的 Actor 可以跨关卡传递
53
    }
54
};
55

56
// ⚠️ Seamless Travel 只对"服务器发起的"切换有效
57
// 客户端调用 ClientTravel 是非无缝的

9.4 Subsystem 体系 —— UE5 的”全局逻辑切片”#

为什么需要 Subsystem？ 在 UE4 时代，所有游戏逻辑都堆在 GameMode 里。一个中大型项目，GameMode 动辄几千行，极难维护。UE5 引入了 Subsystem——它不依赖 Actor、不依赖关卡、自动跟随宿主生命周期，让你把全局逻辑切成小块。

9.4.1 四种 Subsystem 与它们的”宿主”#

flowchart TD subgraph 宿主生命周期 ["宿主生命周期（从长到短）"] GI_["GameInstance\n进程级"] World_["UWorld\n关卡级"] LP_["LocalPlayer\n本地玩家级"] Editor_["编辑器\n仅编辑器"] end GI_ --> UGIS["UGameInstanceSubsystem\n跨关卡持久<br/>适合：存档、大厅、音频管理"] World_ --> UWS["UWorldSubsystem\n随关卡存在<br/>适合：关卡逻辑、AI 管理、寻路"] LP_ --> ULPS["ULocalPlayerSubsystem\n随本地玩家存在<br/>适合：本地输入、成就、设置"] Editor_ --> UES["UEditorSubsystem\n编辑器启动时存在<br/>适合：编辑器工具、自动化"] style GI_ fill:#d00000,stroke:#e85d04,color:white style World_ fill:#e85d04,stroke:#f48c06,color:white style UGIS fill:#d00000,stroke:#e85d04,color:white style UWS fill:#e85d04,stroke:#f48c06,color:white

9.4.2 UGameInstanceSubsystem —— 跨关卡全局逻辑#

1
// 最常用的 Subsystem 类型——跟随 GameInstance 存在，进程级单例。
2

3
UCLASS()
4
class UAudioManagerSubsystem : public UGameInstanceSubsystem
5
{
6
    GENERATED_BODY()
7

8
public:
9
    // ===== 生命周期 =====
10
    virtual void Initialize(FSubsystemCollectionBase& Collection) override
11
    {
12
        Super::Initialize(Collection);
13
        // GameInstance 初始化时调用——此时还没有 World
14
        UE_LOG(LogTemp, Log, TEXT("音频管理器初始化"));
15
    }
16

17
    virtual void Deinitialize() override
18
    {
19
        // 游戏退出时调用——在此清理资源
20
        UE_LOG(LogTemp, Log, TEXT("音频管理器关闭"));
21
        Super::Deinitialize();
22
    }
23

24
    // 业务逻辑
25
    UFUNCTION(BlueprintCallable)
26
    void PlayBGM(USoundBase* Music)
27
    {
28
        if (CurrentBGM != Music)
29
        {
30
            CurrentBGM = Music;
31
            // 实际播放逻辑...
32
        }
33
    }
34

35
    UFUNCTION(BlueprintCallable)
36
    void SetMasterVolume(float Volume)
37
    {
38
        MasterVolume = FMath::Clamp(Volume, 0.0f, 1.0f);
39
        // 应用到所有音频...
40
    }
41

42
    float GetMasterVolume() const { return MasterVolume; }
43

44
private:
45
    UPROPERTY()
46
    USoundBase* CurrentBGM;
47

48
    float MasterVolume = 1.0f;
49
};
50

51
// ===== 在任何地方获取 Subsystem =====
52
void AMyActor::AdjustVolume()
53
{
54
    // 获取 GameInstance → 获取 Subsystem
55
    UGameInstance* GI = GetGameInstance();
56
    if (UAudioManagerSubsystem* AudioMgr = GI->GetSubsystem<UAudioManagerSubsystem>())
57
    {
58
        AudioMgr->SetMasterVolume(0.5f);
59
    }
60
}

9.4.3 UWorldSubsystem —— 关卡级逻辑解耦#

1
// 随关卡加载/卸载自动创建和销毁——把原来塞在 GameMode 里的逻辑抽出来
2

3
UCLASS()
4
class UEnemySpawnManager : public UTickableWorldSubsystem
5
{
6
    GENERATED_BODY()
7

8
public:
9
    virtual void Initialize(FSubsystemCollectionBase& Collection) override
10
    {
11
        Super::Initialize(Collection);
12
        // 关卡加载后调用
13
    }
14

15
    virtual void Deinitialize() override
16
    {
17
        // 关卡卸载前调用
18
        CleanupAllEnemies();
19
        Super::Deinitialize();
20
    }
21

22
    // ★ 继承 UTickableWorldSubsystem 即可自动获得 Tick（基类 UWorldSubsystem 没有 Tick！）
23
    virtual void Tick(float DeltaTime) override
24
    {
25
        Super::Tick(DeltaTime);
26
        // 每帧调用——不需要注册到任何地方！
27
    }
28

29
    virtual TStatId GetStatId() const override
30
    {
31
        RETURN_QUICK_DECLARE_CYCLE_STAT(UEnemySpawnManager, STATGROUP_Tickables);
32
    }
33

34
    UFUNCTION(BlueprintCallable)
35
    void SpawnEnemyWave(int32 Count)
36
    {
37
        UWorld* World = GetWorld();
38
        if (!World) return;
39

40
        for (int32 i = 0; i < Count; i++)
41
        {
42
            FVector SpawnLoc = GetRandomSpawnLocation();
43
            FActorSpawnParameters Params;
44
            Params.SpawnCollisionHandlingOverride =
45
                ESpawnActorCollisionHandlingMethod::AdjustIfPossibleButAlwaysSpawn;
46

47
            AEnemyCharacter* Enemy = World->SpawnActor<AEnemyCharacter>(
48
                EnemyClass, SpawnLoc, FRotator::ZeroRotator, Params);
49

50
            if (Enemy)
51
            {
52
                ActiveEnemies.Add(Enemy);
53
            }
54
        }
55
    }
56

57
    UFUNCTION(BlueprintCallable)
58
    int32 GetAliveEnemyCount()
59
    {
60
        // ★ RemoveAll 搭配 Lambda 清理无效引用，同时统计活着的敌人
61
        ActiveEnemies.RemoveAll([](const AEnemyCharacter* Enemy)
62
        {
63
            return !IsValid(Enemy);
64
        });
65
        return ActiveEnemies.Num();
66
    }
67
    }
68

69
    // ✓ WorldSubsystem 还拥有的能力：
70
    // - DoesSupportWorldType() —— 限制只在特定 World 类型创建
71
    //    例如：只在 PIE 游戏中创建，不在编辑器中创建
72
    virtual bool DoesSupportWorldType(const EWorldType::Type WorldType) const override
73
    {
74
        return WorldType == EWorldType::Game || WorldType == EWorldType::PIE;
75
    }
76

77
    // - PostInitialize() —— 所有 Subsystem 都初始化完后调用
78
    //    此时可以安全地访问"依赖的其他 Subsystem"
79

80
private:
81
    UPROPERTY()
82
    TArray<AEnemyCharacter*> ActiveEnemies;
83

84
    UPROPERTY(EditDefaultsOnly)
85
    TSubclassOf<AEnemyCharacter> EnemyClass;
86

87
    FVector GetRandomSpawnLocation() const
88
    {
89
        // 在关卡中随机寻找生成点...
90
        return FVector::ZeroVector;
91
    }
92

93
    void CleanupAllEnemies()
94
    {
95
        for (AEnemyCharacter* Enemy : ActiveEnemies)
96
        {
97
            if (IsValid(Enemy))
98
            {
99
                Enemy->Destroy();
100
            }
101
        }
102
        ActiveEnemies.Empty();
103
    }
104

105
    // ⚠️ 性能优化：敌人管理池不要求顺序时，可用 RemoveSwap 逐个移除（O(1) 交换删除），
106
    //    TArray 没有 RemoveAllSwap 批量接口——条件批量删除请用 RemoveAll：
107

108
    // ===== ⚠️ WorldSubsystem 与 Level Streaming（流关卡）的关系 =====
109
    // 面试高频陷阱题：
110
    // "主关卡（Persistent Level）动态加载子关卡 A 时，WorldSubsystem 会重建吗？"
111
    //
112
    // 答案：不会！WorldSubsystem 绑定的是整个 UWorld 实例，而不是某个 ULevel。
113
    // 只要主关卡（Persistent Level）不销毁，无论加载/卸载多少子流关卡，
114
    // WorldSubsystem 都只有全局唯一的一个实例，Tick 也完全不受影响。
115
    //
116
    // 这是 WorldSubsystem 相对 Level Blueprint / Level Script Actor 的巨大优势——
117
    // 后者只存在于特定子关卡中，流关卡卸载时随之销毁。
118
};

9.4.4 ULocalPlayerSubsystem —— 本地玩家专属逻辑#

1
// 每个"本地玩家"拥有一个实例——适合单人/分屏场景
2

3
UCLASS()
4
class UAchievementSubsystem : public ULocalPlayerSubsystem
5
{
6
    GENERATED_BODY()
7

8
public:
9
    virtual void Initialize(FSubsystemCollectionBase& Collection) override
10
    {
11
        Super::Initialize(Collection);
12
        LoadAchievements();
13
    }
14

15
    UFUNCTION(BlueprintCallable)
16
    void UnlockAchievement(FName AchievementId)
17
    {
18
        if (!UnlockedAchievements.Contains(AchievementId))
19
        {
20
            UnlockedAchievements.Add(AchievementId);
21
            OnAchievementUnlocked.Broadcast(AchievementId);
22
            SaveAchievements();
23
        }
24
    }
25

26
    UFUNCTION(BlueprintPure)
27
    bool IsAchievementUnlocked(FName AchievementId) const
28
    {
29
        return UnlockedAchievements.Contains(AchievementId);
30
    }
31

32
    DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnAchievementUnlocked, FName, AchievementId);
33
    UPROPERTY(BlueprintAssignable)
34
    FOnAchievementUnlocked OnAchievementUnlocked;
35

36
private:
37
    TSet<FName> UnlockedAchievements;
38

39
    void LoadAchievements() { /* 从存档加载 */ }
40
    void SaveAchievements() { /* 保存到存档 */ }
41
};
42

43
// ===== 获取 LocalPlayerSubsystem =====
44
void AMyPlayerController::UnlockSomething()
45
{
46
    if (ULocalPlayer* LP = GetLocalPlayer())
47
    {
48
        if (UAchievementSubsystem* Achievements = LP->GetSubsystem<UAchievementSubsystem>())
49
        {
50
            Achievements->UnlockAchievement(TEXT("FirstBlood"));
51
        }
52
    }
53
}
54

55
// ===== ⚠️ 致命陷阱：ULocalPlayerSubsystem 在 Dedicated Server 上不存在！=====
56
// ULocalPlayerSubsystem 依赖于 ULocalPlayer，而 ULocalPlayer 是本地客户端的
57
// 概念——它代表"坐在屏幕前拿着手柄的那个玩家"。
58
//
59
// Dedicated Server（DS）上没有 ULocalPlayer！服务器上只有网络连接端的
60
// APlayerController，不存在"本地玩家"的概念。因此：
61
//
62
// ✗ ULocalPlayerSubsystem 在 DS 上永远不会被创建
63
// ✗ 不要把多人对战的伤害奖励、全局游戏逻辑放进 ULocalPlayerSubsystem
64
// ✓ 多人全局逻辑 → UWorldSubsystem 或 UGameInstanceSubsystem
65
// ✓ 单人/分屏/本地逻辑 → ULocalPlayerSubsystem（此时安全）
66
//
67
// 判断口诀：你的逻辑如果需要在 DS 上运行 → 不能用 LocalPlayerSubsystem

9.4.5 UEditorSubsystem —— 编辑器工具逻辑#

1
// 只在编辑器中存在——PIE 时也会存在（取决于实现）
2

3
UCLASS()
4
class UMyLevelValidatorSubsystem : public UEditorSubsystem
5
{
6
    GENERATED_BODY()
7

8
public:
9
    virtual void Initialize(FSubsystemCollectionBase& Collection) override
10
    {
11
        Super::Initialize(Collection);
12
        // 编辑器启动时调用
13
        UE_LOG(LogTemp, Log, TEXT("关卡验证器已启动"));
14
    }
15

16
    // 检查当前关卡中是否所有 NavMesh 都正确覆盖
17
    UFUNCTION(BlueprintCallable)
18
    bool ValidateNavMeshCoverage()
19
    {
20
        // 只在编辑器中运行的逻辑
21
        // 遍历关卡中的 NavMeshBoundsVolume...
22
        return true;
23
    }
24
};

9.4.6 Subsystem 依赖链与初始化顺序#

1
// Subsystem 之间的依赖关系通过 FSubsystemCollectionBase 声明
2

3
UCLASS()
4
class UMyGameSubsystem : public UGameInstanceSubsystem
5
{
6
    GENERATED_BODY()
7

8
public:
9
    // ★ 声明依赖：MyGameSubsystem 必须在 OtherSubsystem 之后初始化
10
    virtual void Initialize(FSubsystemCollectionBase& Collection) override
11
    {
12
        // 显式声明依赖——引擎保证 OtherSubsystem 先于本类完成 Initialize()
13
        Collection.InitializeDependency<UOtherSubsystem>();
14

15
        Super::Initialize(Collection);
16

17
        // 现在可以安全地获取依赖的 Subsystem
18
        UOtherSubsystem* Other = GetGameInstance()->GetSubsystem<UOtherSubsystem>();
19
        // Other 已经完成初始化！
20
    }
21
};
22

23
// ===== Subsystem 初始化顺序规则 =====
24
// 1. 先按"声明依赖"排序——被依赖的先初始化
25
// 2. 同优先级的按"类的自然顺序"
26
// 3. PostInitialize() 在所有 Subsystem 的 Initialize() 完毕后批量调用
27
//    → 不需要声明依赖——PostInitialize 中一定可以访问所有同级的 Subsystem
28

29
// ===== Subsystem 与 GameMode 的初始化时序 =====
30
// GameInstance::Init()
31
//   └→ 所有 UGameInstanceSubsystem::Initialize()
32
//       └→ 所有 UGameInstanceSubsystem::PostInitialize()
33
//
34
// UWorld::BeginPlay()（关卡加载后）
35
//   └→ 所有 UWorldSubsystem::Initialize()
36
//       └→ 所有 UWorldSubsystem::PostInitialize()
37
//           └→ GameMode::InitGame()
38
//               └→ Actor::BeginPlay()

9.5 Subsystem vs GameMode —— 解耦实战#

9.5.1 重构前：所有逻辑堆在 GameMode#

1
// ===== ✗ 重构前的 GameMode——典型的"上帝类" =====
2
UCLASS()
3
class ABadGameMode : public AGameModeBase
4
{
5
    GENERATED_BODY()
6

7
public:
8
    // 这个 GameMode 做了太多事：
9
    // 音频、敌人管理、天气、计分、成就……全都塞在这一个类里！
10

11
    void PlayBGM(USoundBase* Music) { /* ... */ }
12
    void SpawnEnemyWave() { /* ... */ }
13
    void ChangeWeather(FName Weather) { /* ... */ }
14
    void AddScore(int32 Team, int32 Points) { /* ... */ }
15
    void UnlockAchievement(FName Id) { /* ... */ }
16

17
    // 几千行代码混杂在一起……
18
};

9.5.2 重构后：用 Subsystem 解耦#

1
// ===== ✓ 重构后：每个关注点一个 Subsystem =====
2

3
// 音频 → UGameInstanceSubsystem（跨关卡）
4
// 已在 9.4.2 中定义：UAudioManagerSubsystem
5

6
// 敌人管理 → UWorldSubsystem（随关卡）
7
// 已在 9.4.3 中定义：UEnemySpawnManager
8

9
// 天气系统 → UWorldSubsystem
10
UCLASS()
11
class UWeatherSubsystem : public UTickableWorldSubsystem
12
{
13
    GENERATED_BODY()
14

15
public:
16
    virtual void Tick(float DeltaTime) override
17
    {
18
        Super::Tick(DeltaTime);
19
        // 天气渐变逻辑……
20
    }
21

22
    virtual TStatId GetStatId() const override
23
    {
24
        RETURN_QUICK_DECLARE_CYCLE_STAT(UWeatherSubsystem, STATGROUP_Tickables);
25
    }
26

27
    UFUNCTION(BlueprintCallable)
28
    void ChangeWeather(FName NewWeather)
29
    {
30
        CurrentWeather = NewWeather;
31
        OnWeatherChanged.Broadcast(NewWeather);
32
    }
33

34
    UPROPERTY(BlueprintReadOnly)
35
    FName CurrentWeather;
36

37
    DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnWeatherChanged, FName, NewWeather);
38
    UPROPERTY(BlueprintAssignable)
39
    FOnWeatherChanged OnWeatherChanged;
40
};
41

42
// 成就系统 → ULocalPlayerSubsystem（每个玩家独立）
43
// 已在 9.4.4 中定义：UAchievementSubsystem
44

45
// ===== 重构后的 GameMode——极度精简 =====
46
UCLASS()
47
class AGoodGameMode : public AGameModeBase
48
{
49
    GENERATED_BODY()
50

51
public:
52
    AGoodGameMode()
53
    {
54
        DefaultPawnClass = AMyCharacter::StaticClass();
55
        PlayerControllerClass = AMyPlayerController::StaticClass();
56
        GameStateClass = AMyGameState::StaticClass();
57
        PlayerStateClass = AMyPlayerState::StaticClass();
58
    }
59

60
    // GameMode 只做"只有 GameMode 才能做"的事：
61
    // 1. 决定怎么生玩家、生在哪
62
    // 2. 决定胜负条件
63
    // 3. 处理玩家登录/离开
64

65
    virtual void RestartPlayer(AController* NewPlayer) override
66
    {
67
        Super::RestartPlayer(NewPlayer);
68
        // 重生后通知天气系统（如果需要）
69
    }
70

71
    virtual bool ReadyToEndMatch_Implementation() override
72
    {
73
        // 胜负判断
74
        return false;
75
    }
76

77
    // 这就是全部！其他逻辑全部在 Subsystem 中
78
};

9.6 实战：一个完整的多人射击游戏框架#

1
// ===== 场景：构建一个多人射击游戏的基础框架 =====
2
// 需求：
3
// - 玩家加入大厅 → 选择队伍 → 等待开始
4
// - 比赛开始 → 计分 → 计时结束 → 显示结果
5
// - 玩家数据跨关卡保留（击杀/死亡）
6
// - 全局音频管理
7

8
// ---------- 1. GameInstance + Subsystem 组合 ----------
9
UCLASS()
10
class UShooterGameInstance : public UGameInstance
11
{
12
    GENERATED_BODY()
13

14
public:
15
    virtual void Init() override
16
    {
17
        Super::Init();
18
        // Subsystem 会自动初始化，不需要手动创建
19
    }
20

21
    // 跨关卡数据
22
    UPROPERTY()
23
    TMap<FString, int32> PlayerLifetimeStats;  // 玩家累积数据
24
};
25

26
// ---------- 2. GameMode ----------
27
UCLASS()
28
class AShooterGameMode : public AGameModeBase
29
{
30
    GENERATED_BODY()
31

32
public:
33
    AShooterGameMode()
34
    {
35
        bUseSeamlessTravel = true;  // 无缝切换关卡
36

37
        DefaultPawnClass = AShooterCharacter::StaticClass();
38
        PlayerControllerClass = AShooterPlayerController::StaticClass();
39
        GameStateClass = AShooterGameState::StaticClass();
40
        PlayerStateClass = AShooterPlayerState::StaticClass();
41
    }
42

43
    virtual void HandleSeamlessTravelPlayer(AController*& C) override
44
    {
45
        Super::HandleSeamlessTravelPlayer(C);
46
        // Seamless Travel 时把 PlayerController 传给新关卡
47
    }
48

49
    virtual AActor* ChoosePlayerStart_Implementation(AController* Player) override
50
    {
51
        // 按队伍分配出生点
52
        if (APlayerState* PS = Player->GetPlayerState<APlayerState>())
53
        {
54
            // 根据队伍选择对应的 PlayerStart
55
        }
56
        return Super::ChoosePlayerStart_Implementation(Player);
57
    }
58
};
59

60
// ---------- 3. GameState ----------
61
UCLASS()
62
class AShooterGameState : public AGameStateBase
63
{
64
    GENERATED_BODY()
65

66
public:
67
    UPROPERTY(Replicated, BlueprintReadOnly)
68
    int32 MatchTimeRemaining = 300;  // 5 分钟
69

70
    UPROPERTY(Replicated, BlueprintReadOnly)
71
    bool bMatchInProgress = false;
72

73
    UPROPERTY(Replicated, BlueprintReadOnly)
74
    EGamePhase CurrentPhase = EGamePhase::WaitingForPlayers;
75

76
    virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override
77
    {
78
        Super::GetLifetimeReplicatedProps(OutLifetimeProps);
79
        DOREPLIFETIME(AShooterGameState, MatchTimeRemaining);
80
        DOREPLIFETIME(AShooterGameState, bMatchInProgress);
81
        DOREPLIFETIME(AShooterGameState, CurrentPhase);
82
    }
83

84
    UFUNCTION()
85
    void OnRep_MatchTimeRemaining()
86
    {
87
        // 客户端收到计时更新——更新 UI
88
        OnMatchTimerUpdated.Broadcast(MatchTimeRemaining);
89
    }
90

91
    DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnMatchTimerUpdated, int32, TimeRemaining);
92
    UPROPERTY(BlueprintAssignable)
93
    FOnMatchTimerUpdated OnMatchTimerUpdated;
94
};
95

96
UENUM(BlueprintType)
97
enum class EGamePhase : uint8
98
{
99
    WaitingForPlayers,
100
    PreMatch,
101
    InProgress,
102
    PostMatch,
103
    EndOfMatch
104
};
105

106
// ---------- 4. PlayerController ----------
107
UCLASS()
108
class AShooterPlayerController : public APlayerController
109
{
110
    GENERATED_BODY()
111

112
public:
113
    virtual void BeginPlay() override
114
    {
115
        Super::BeginPlay();
116

117
        if (IsLocalPlayerController())
118
        {
119
            // 只在本地玩家的客户端创建 UI
120
            if (UMainHUDWidget* HUD = CreateWidget<UMainHUDWidget>(this, MainHUDClass))
121
            {
122
                HUD->AddToViewport();
123
            }
124
        }
125
    }
126

127
    // Server RPC：请求切换队伍
128
    UFUNCTION(Server, Reliable)
129
    void ServerSwitchTeam(int32 NewTeamId);
130

131
    void ServerSwitchTeam_Implementation(int32 NewTeamId)
132
    {
133
        if (AShooterPlayerState* PS = GetPlayerState<AShooterPlayerState>())
134
        {
135
            if (AShooterGameState* GS = GetWorld()->GetGameState<AShooterGameState>())
136
            {
137
                if (GS->CurrentPhase == EGamePhase::WaitingForPlayers)
138
                {
139
                    PS->TeamId = NewTeamId;  // 只在等待阶段允许换队
140
                }
141
            }
142
        }
143
    }
144

145
    // Client RPC：显示击杀提示
146
    UFUNCTION(Client, Reliable)
147
    void ClientNotifyKill(const FString& VictimName);
148

149
    void ClientNotifyKill_Implementation(const FString& VictimName)
150
    {
151
        // 在本地显示"你击杀了 xxx"
152
        if (GEngine)
153
        {
154
            GEngine->AddOnScreenDebugMessage(-1, 3.0f, FColor::Red,
155
                FString::Printf(TEXT("你击杀了 %s"), *VictimName));
156
        }
157
    }
158

159
protected:
160
    UPROPERTY(EditDefaultsOnly)
161
    TSubclassOf<UMainHUDWidget> MainHUDClass;
162
};
163

164
// ---------- 5. PlayerState ----------
165
UCLASS()
166
class AShooterPlayerState : public APlayerState
167
{
168
    GENERATED_BODY()
169

170
public:
171
    UPROPERTY(Replicated, BlueprintReadOnly)
172
    int32 Kills;
173

174
    UPROPERTY(Replicated, BlueprintReadOnly)
175
    int32 Deaths;
176

177
    UPROPERTY(Replicated, BlueprintReadOnly)
178
    int32 TeamId;
179

180
    virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override
181
    {
182
        Super::GetLifetimeReplicatedProps(OutLifetimeProps);
183
        DOREPLIFETIME(AShooterPlayerState, Kills);
184
        DOREPLIFETIME(AShooterPlayerState, Deaths);
185
        DOREPLIFETIME(AShooterPlayerState, TeamId);
186
    }
187
};
188

189
// ---------- 6. Pawn ----------
190
UCLASS()
191
class AShooterCharacter : public ACharacter
192
{
193
    GENERATED_BODY()
194

195
public:
196
    AShooterCharacter()
197
    {
198
        HealthComp = CreateDefaultSubobject<UHealthComponent>(TEXT("Health"));
199
    }
200

201
    virtual void BeginPlay() override
202
    {
203
        Super::BeginPlay();
204

205
        if (HasAuthority())  // 服务器端
206
        {
207
            HealthComp->OnDeath.AddDynamic(this, &AShooterCharacter::OnDeath);
208
        }
209
    }
210

211
    UFUNCTION()
212
    void OnDeath()
213
    {
214
        // 服务器处理死亡
215
        if (AShooterPlayerController* PC = Cast<AShooterPlayerController>(GetController()))
216
        {
217
            if (AShooterPlayerState* PS = PC->GetPlayerState<AShooterPlayerState>())
218
            {
219
                PS->Deaths++;
220
            }
221

222
            // 通知客户端
223
            PC->ClientNotifyKill(TEXT("你被击杀了"));
224

225
            // N 秒后重生
226
            // ⚠️ 必须用 TWeakObjectPtr 捕获！如果玩家在这 3 秒内断线，
227
            //    PC 被 GC 回收，裸指针直接 Access Violation 崩溃服务器
228
            FTimerHandle TimerHandle;
229
            TWeakObjectPtr<AShooterPlayerController> WeakPC(PC);
230
            GetWorld()->GetTimerManager().SetTimer(TimerHandle, [WeakPC]() {
231
                if (AShooterPlayerController* SafePC = WeakPC.Get())
232
                {
233
                    if (AGameModeBase* GM = SafePC->GetWorld()->GetAuthGameMode())
234
                    {
235
                        GM->RestartPlayer(SafePC);
236
                    }
237
                }
238
            }, 3.0f, false);
239
        }
240
    }
241

242
private:
243
    UPROPERTY()
244
    UHealthComponent* HealthComp;
245
};
246

247
// ===== 完整流程：玩家从登录到对战 =====
248
//
249
// 1. 玩家连接 → GameMode::PreLogin() → 通过
250
// 2. GameMode::Login() → 创建 PlayerController
251
// 3. PlayerController 初始化 → 自动创建 PlayerState
252
// 4. GameMode::RestartPlayer() → Spawn Pawn
253
// 5. PlayerController::Possess(Pawn) → 玩家可以操作
254
// 6. 比赛进行中 → GameState 广播计时/比分到所有客户端
255
// 7. 玩家死亡 → Pawn 销毁 → N 秒后 RestartPlayer → 新 Pawn
256
//     → PlayerState 中的 Kills/Deaths 不丢失！
257
// 8. 比赛结束 → GameMode::HandleMatchHasEnded()
258
// 9. Seamless Travel 到下一关 → PlayerState 和 PlayerController 保留

9.7 常见陷阱与面试深度追问#

9.7.1 Game Framework 常见错误 TOP 5#

1
// 陷阱 #1：客户端访问 GameMode
2
void AMyCharacter::BadFunction()
3
{
4
    // ✗ 客户端上没有 GameMode！GetAuthGameMode() 返回 nullptr
5
    // AGameModeBase* GM = GetWorld()->GetAuthGameMode();
6
    // if (GM) { ... }  // 客户端上永远为 false
7

8
    // ✓ 正确方式：用 GameState 或 PlayerController
9
    if (HasAuthority())  // 只在服务器执行
10
    {
11
        // 可以安全访问 GameMode
12
    }
13

14
    // ✓ 或者：把需要在客户端执行的数据放在 GameState 中
15
    // GameState 会自动复制到客户端
16
}
17

18
// 陷阱 #2：在 GameMode 中操作 UI
19
void ABadGameMode::BadFunction()
20
{
21
    // ✗ GameMode 只在服务器！不能在服务器上创建 UI
22
    // CreateWidget<UMyWidget>(...);  // 毫无意义——只存在于服务器内存
23
}
24

25
// 陷阱 #3：混淆 PlayerState 和 Pawn
26
void OnPlayerRespawn()
27
{
28
    // ✓ PlayerState 中的 KillCount 跨重生保留
29
    // ✓ Pawn 上的 Health 每次重生都是新的
30
    // ✗ 不要在 Pawn 上放"跨生命"的数据
31
}
32

33
// 陷阱 #4：Seamless Travel 忘记保留关键 Actor
34
// ✗ 在普通 Actor 的关卡引用会在 Seamless Travel 中失效
35
// ✓ 把跨关卡数据放 GameInstance 或 PlayerState
36

37
// 陷阱 #5：Subsystem 初始化顺序问题
38
UCLASS()
39
class UMyBadSubsystem : public UGameInstanceSubsystem
40
{
41
    virtual void Initialize(FSubsystemCollectionBase& Collection) override
42
    {
43
        // ✗ 此时访问另一个 Subsystem，它可能还没初始化！
44
        // auto* Other = GetGameInstance()->GetSubsystem<UOtherSubsystem>();
45

46
        Super::Initialize(Collection);
47

48
        // ✓ 使用 PostInitialize() 访问其他 Subsystem
49
    }
50

51
    virtual void PostInitialize() override
52
    {
53
        Super::PostInitialize();
54
        // ✓ 这里所有同级 Subsystem 一定已初始化完毕
55
        auto* Other = GetGameInstance()->GetSubsystem<UOtherSubsystem>();
56
        // 安全！
57
    }
58
};

9.7.2 Subsystem 使用决策树#

1
你的逻辑需要跨关卡存在吗？
2
├── 是 → UGameInstanceSubsystem
3
│       例：音频管理、大厅系统、全局配置、成就解锁缓存
4
│
5
├── 否 → 跟关卡有关？
6
│        ├── 是 → UWorldSubsystem
7
│        │       例：敌人管理器、天气系统、寻路缓存、关卡事件调度
8
│        │
9
│        └── 否 → 跟特定玩家有关？
10
│                 ├── 是 → ULocalPlayerSubsystem
11
│                 │       例：输入配置、成就通知、本地存档
12
│                 │
13
│                 └── 否 → 只是工具/辅助逻辑？
14
│                          用普通 UObject 即可，不需要 Subsystem
15
│
16
└── 只在编辑器中使用？
17
    └── UEditorSubsystem
18
        例：关卡验证、自动化处理、编辑器菜单

9.7.3 面试时怎么回答”Subsystem 解决了什么问题？“#

1
经典三段式回答：
2

3
1. 解耦 GameMode：
4
   "在 UE4 时代，GameMode 承载了太多职责——音频、AI 管理、天气、
5
    计分……全都塞在一个类里。UE5 的 Subsystem 让你把每个关注点
6
    拆成一个独立的类。"
7

8
2. 自动生命周期：
9
   "Subsystem 自动跟随宿主（GameInstance/World/LocalPlayer/Editor）
10
    的生命周期，不需要手动管理。继承 UTickableWorldSubsystem
11
    即可获得 Tick 支持——不需要注册到任何 Manager。"
12

13
3. 不需要 Actor：
14
   "Subsystem 是纯 UObject——不需要放在关卡里、不占用 Transform、
15
    不参与渲染。对于纯逻辑管理来说，比 Actor 轻量得多。"

9.8 30 秒速答#

面试被问：“GameMode 和 GameState 的区别是什么？为什么不能把所有数据都放 GameMode？”

GameMode 只存在于服务器——客户端根本看不到它。GameState 从服务器自动复制到所有客户端。所以：游戏规则（怎么赢、怎么生）放 GameMode；所有人都需要看到的状态（比分、计时、玩家列表）放 GameState。如果你把比分放在 GameMode 里，客户端根本读不到。

面试追问：“PlayerState 和 Pawn 的区别？为什么击杀数放 PlayerState 不放 Pawn？”

Pawn 会死——角色死亡时 Pawn 被销毁，重生时 Spawn 新 Pawn。PlayerState 跟随玩家连接存在，换关卡、换 Pawn 都不销毁。所以”跨生命”的数据（击杀数、死亡数、队伍 ID、玩家名字）放 PlayerState；“当前生命”的数据（HP、位置、弹药）放 Pawn 或其 Component。

面试追问：“什么时候用 Subsystem 而不是 GameMode？”

Subsystem 是为了把 GameMode 中”不应该是 GameMode 管”的逻辑抽出来。举例：全局音频管理不需要知道游戏规则——它只需要跟随 GameInstance 存在，用 UGameInstanceSubsystem。关卡中的敌人刷新逻辑也不属于 GameMode——用 UTickableWorldSubsystem，它甚至可以自己 Tick。一句话：GameMode 只做”只有 GameMode 才能做”的事（胜负判定、玩家登录/离开、Pawn 生成策略），其他全部给 Subsystem。

面试追问：“Seamless Travel 中哪些对象保留？哪些重建？”

保留：GameInstance（进程级单例，天然跨关卡）、PlayerController（引擎自动保留）、PlayerState（引擎自动保留）。销毁重建：GameMode（新关卡使用新配置）、GameState（绑定在 UWorld 上但随关卡重置）、关卡中的 Actor（包括 Pawn）、★ UWorldSubsystem（Seamless Travel 中旧 World 的 Subsystem 触发 Deinitialize() 并销毁——新 World 重新实例化并调用 Initialize()，内部动态状态彻底丢失。如需跨关卡保留状态，必须使用 UGameInstanceSubsystem）。

📚 第二部核心章节完结。 Game Framework 是 UE 游戏架构的”骨架”，Subsystem 是 UE5 的”肌肉”。理解这两层之后，接下来的输入系统（Ch10）、UI（Ch11）、网络复制（Ch12）和数据驱动（Ch13）都是在这副骨架上挂载的具体模块。

💡 前置依赖提醒：

Actor 生命周期与本节的 Pawn/PlayerController 关系 → 见 Ch8：Actor 与 Component

UObject 与 GC（Subsystem 本质是 UObject）→ 见 Ch3：UObject 与 GC

网络复制基础（Replicated/RPC 更多细节）→ 见 Ch12：序列化与网络复制

音乐

音乐