UE4 GamePlay架构介绍

导语

UE4的官网虽然提供了不少文档介绍UE的方方面面，但是在具体开发细节上其实很多地方都不够完善，多数需要自己去摸索，这里就将以介绍从我们项目使用UE4以来总结的一下UE GamePlay框架开发经验，以熟悉和了解整体框架概念为主。

一、 UE4的基本对象介绍

1 不同引擎的世界观

每个游戏引擎都有其独特的架构和设计理念，这些设计理念影响了开发者如何构建和管理游戏世界。以下是对Unity、Cocos2d-x和Unreal Engine（UE）这三种引擎的世界观和对象模型的详细比较。

1. Unity

世界观

• GameObject：Unity的基本构建块是GameObject。每个GameObject可以代表场景中的任何实体，如角色、道具、光源等。
• Component：GameObject本身并不包含任何行为或属性，而是通过附加的Component来实现功能。每个Component负责特定的功能，例如物理、渲染、输入处理等。开发者可以通过组合不同的Component来创建复杂的行为。

特点

• 灵活性：由于GameObject和Component的分离，开发者可以灵活地组合和重用功能。
• 组件化设计：这种设计使得功能的扩展和维护变得更加简单，开发者可以轻松添加或移除功能。
• 场景管理：Unity使用场景（Scene）来组织GameObject，场景可以包含多个GameObject的组合。

2. Cocos2d-x

世界观

• CCNode：Cocos2d-x的基本构建块是CCNode。所有的可视化元素（如精灵、图层、场景等）都是CCNode的子类。
• 内嵌逻辑：Cocos2d-x的设计理念是将逻辑和渲染紧密结合，许多功能直接嵌入在CCNode中，开发者可以通过继承和扩展CCNode来实现自定义行为。

特点

• 简单易用：Cocos2d-x的API相对简单，适合快速开发2D游戏。
• 层次结构：CCNode形成了一个层次结构，开发者可以通过父子关系来管理节点的显示和行为。
• 性能优化：由于Cocos2d-x主要针对2D游戏，优化了渲染性能和内存管理。

3. Unreal Engine (UE)

世界观

• Actor：UE的基本构建块是Actor。每个Actor可以代表场景中的一个实体，具有位置、旋转和缩放等属性。
• Component：与Unity类似，Actor可以包含多个Component，这些Component提供了不同的功能，如物理、渲染、音频等。开发者可以通过组合不同的Component来实现复杂的行为。

特点

• 强大的编辑器：UE提供了一个功能强大的可视化编辑器，开发者可以通过拖放的方式快速构建场景和Actor。
• 蓝图系统：UE的蓝图系统允许开发者以可视化的方式编写逻辑，降低了编程的门槛。
• 高性能：UE专注于高质量的图形和性能，适合开发大型3D游戏。

4. 总结比较

特性	Unity	Cocos2d-x	Unreal Engine
基本对象	GameObject	CCNode	Actor
组件化设计	通过Component实现功能	内嵌逻辑	通过Component实现功能
灵活性	高	中	高
编辑器	可视化编辑器	代码驱动	强大的可视化编辑器
适用场景	2D/3D游戏	主要用于2D游戏	主要用于3D游戏
开发语言	C#	C++/Lua	C++/蓝图

结论

每个游戏引擎都有其独特的设计哲学和适用场景。Unity以其灵活的组件化设计和强大的社区支持而受到广泛欢迎，Cocos2d-x则因其简单易用和高效的2D渲染而适合快速开发2D游戏，而Unreal Engine则以其强大的图形能力和高性能而适合开发大型3D游戏。选择合适的引擎取决于项目的需求、团队的技能和目标平台。

我们这里先来介绍上面世界观中提到的最基础的两个对象Actor和Component，和UObject之间的继承关系：

2 UE中的基本对象

在Unreal Engine（UE）中，UObject 是所有对象的基类，构成了UE对象系统的核心。以下是对 UObject 的详细介绍及其功能：

1. UObject 的基本概念

• 基类：UObject 是UE中所有对象的基类，所有自定义类（如Actor、Component、Material等）都直接或间接地继承自 UObject。这使得所有对象都具备统一的特性和功能。

2. UObject 的主要功能

Object：

反射（Reflection）：UObject 提供了反射机制，使得开发者可以在运行时查询对象的属性和方法。这对于蓝图系统和编辑器功能至关重要，允许开发者动态地访问和修改对象的状态。

• 序列化（Serialization）：UObject 支持对象的序列化和反序列化，允许将对象的状态保存到磁盘或从磁盘加载。这对于保存游戏状态、网络复制和编辑器中的资产管理非常重要。

• 内存管理（Memory Management）：UObject 提供了自动内存管理功能，包括引用计数和垃圾回收（Garbage Collection）。这意味着开发者不需要手动管理内存，减少了内存泄漏的风险。

• 对象性能监视（Object Performance Monitoring）：UObject 提供了一些工具和接口，用于监视和分析对象的性能。这对于优化游戏性能和调试非常有用。

• 运行时类型信息（RTTI, Run-Time Type Information）：UObject 支持运行时类型信息，使得开发者可以在运行时检查对象的类型。这对于多态性和动态类型处理非常重要。

• 蓝图开发（Blueprint Development）：UObject 是蓝图系统的基础，所有蓝图类都继承自 UObject。这使得开发者可以通过可视化脚本编程来创建游戏逻辑，而不需要深入C++代码。

3. UObject 的使用场景

• 游戏对象：所有游戏中的对象（如角色、道具、环境元素等）都可以通过 UObject 创建和管理。

• 编辑器资产：在UE编辑器中，许多资产（如材质、纹理、音频等）都是 UObject 的子类，允许开发者在编辑器中进行可视化管理。

• 蓝图类：开发者可以创建蓝图类，这些类在底层都是 UObject 的实例，允许通过蓝图系统实现复杂的游戏逻辑。

4. 总结

UObject 是Unreal Engine中最基础的对象类型，提供了反射、序列化、内存管理等一系列核心功能。它的设计使得UE能够支持复杂的游戏开发需求，同时为开发者提供了强大的工具和接口。理解 UObject 的工作原理和功能是掌握UE开发的基础，对于创建高效、可维护的游戏项目至关重要。

Actor：

在Unreal Engine（UE）中，Actor 是游戏世界中的基本对象，字面意思是“演员”。它不仅继承了 UObject 提供的基础功能，还具备网络同步和组合组件（Component）的能力。虽然 Actor 和 Unity 中的 GameObject 在概念上有相似之处，但它们在设计理念和实现上存在显著差异。

Actor 的基本概念

在Unreal Engine（UE）中，Actor 是游戏世界中的基本对象，具有以下几个重要特性：

1. 基础对象

• 定义：Actor 是UE中用于表示游戏世界中可放置的对象的类。它可以是任何可以在场景中存在的实体，例如角色、道具、环境元素等。
• 组件：每个 Actor 可以包含多个组件，这些组件定义了 Actor 的行为和外观。组件可以是视觉表现（如网格组件）、物理属性（如碰撞组件）或其他功能（如音频组件、粒子效果组件等）。

2. 网络同步

• 多人游戏支持：Actor 支持网络功能，允许在多人游戏中同步状态和行为。这意味着当一个玩家在游戏中对 Actor 进行操作时，其他玩家也能实时看到这些变化。
• 网络复制：UE提供了网络复制机制，开发者可以指定哪些属性和方法需要在网络中同步，从而确保游戏状态的一致性。

3. 组件组合

• 灵活性：Actor 可以包含多个组件（如 MeshComponent、CollisionComponent、AudioComponent 等），这些组件可以共同工作以实现复杂的功能。通过组合不同的组件，开发者可以创建出具有多种行为和特性的 Actor。
• 功能扩展：组件的组合使得 Actor 的功能可以灵活扩展。例如，一个角色 Actor 可以同时拥有视觉表现、碰撞检测、动画控制和声音播放等多个组件，从而实现丰富的游戏体验。

总结

Actor 是Unreal Engine中非常重要的概念，它不仅是游戏世界中的基本构建块，还通过组件化的设计提供了极大的灵活性和扩展性。理解 Actor 的基本概念及其功能是开发UE游戏的基础，有助于开发者更好地利用引擎的强大功能来创建复杂的游戏逻辑和交互。

Actor 与 GameObject 的比较

在游戏开发中，Unreal Engine（UE）的 Actor 和 Unity 的 GameObject 是两个核心概念，尽管它们在功能上有相似之处，但在设计理念和实现方式上存在显著差异。

1. 设计理念

Unity 的 GameObject：

• 轻量级显示对象：在Unity中，GameObject 是一个轻量级的显示对象，主要用于表示场景中的实体。它本身不具备任何功能，所有的功能都通过组件来实现。
• 自带 Transform 组件：每个 GameObject 都自带一个 Transform 组件，表示其在3D空间中的位置、旋转和缩放。这使得每个对象在场景中都有明确的空间定位。
• 组件独立性：组件之间相互独立，用户可以灵活地添加、移除和管理这些组件。开发者可以根据需要自由组合不同的组件，以实现所需的功能。

UE 的 Actor：

• 功能强大的基础对象：在UE中，Actor 是一个功能更为强大的基础对象。它并不自带 Transform 组件，而是通过 SceneComponent 来管理位置和层次结构。
• 组件组合：Actor 可以包含多个 PrimitiveComponent，这些组件可以融合更多的逻辑功能，例如物理、网格和碰撞等。通过这种方式，Actor 可以实现复杂的行为和交互。
• 功能职责：UE的设计理念是将更多的功能职责赋予基础对象，使得 Actor 在功能上更为强大，但这也增加了上手的复杂性。开发者需要理解组件之间的关系以及如何有效地组合它们。

2. 组件管理

• Unity：在Unity中，组件是独立的，用户可以自由添加和移除。每个 GameObject 的组件功能相互独立，用户需要手动管理这些组件的关系。这样的设计使得开发者可以灵活地构建和调整对象的功能。

• UE：在UE中，组件的功能往往是融合的。例如，物理、网格和碰撞功能可以通过一个 MeshComponent 来实现。Actor 可以嵌套多个 PrimitiveComponent，使得功能更加集中和强大。这种设计使得开发者可以更高效地管理复杂的对象，但也要求开发者对引擎的工作原理有更深入的理解。

3. 总结

• 设计理念的差异：Unity 的 GameObject 设计更为简单，适合快速开发和原型制作，而 UE 的 Actor 设计更为复杂，适合需要高度定制和复杂逻辑的项目。
• 适用场合：选择使用UE还是Unity，取决于项目的需求和开发团队的熟悉程度。两者各有优劣，适用于不同类型的游戏开发。理解这些差异有助于开发者在不同引擎之间进行有效的转换和适应。

组件管理的比较

在游戏开发中，组件管理是实现对象功能和行为的关键部分。Unity 和 Unreal Engine（UE）在组件管理方面有着不同的设计理念和实现方式，以下是对这两者的比较：

1. Unity 的组件管理

• 独立性：

  • 在Unity中，组件是独立的，每个 GameObject 可以拥有多个组件，这些组件之间的功能相互独立。开发者可以根据需要自由添加、移除或替换组件。

• 灵活性：

  • 这种独立性使得开发者可以灵活地组合不同的组件，以实现所需的功能。例如，一个 GameObject 可以同时拥有 Rigidbody（物理）、Collider（碰撞）和 MeshRenderer（渲染）等组件，开发者可以根据具体需求进行调整。

• 手动管理：

  • 用户需要手动管理这些组件之间的关系和交互。例如，开发者需要编写代码来处理组件之间的通信，确保它们能够协同工作。这种方式提供了高度的灵活性，但也可能导致复杂性增加，尤其是在处理多个组件时。

2. UE 的组件管理

• 功能融合：

  • 在UE中，组件的功能往往是融合的。例如，MeshComponent 可以同时处理物理、网格和碰撞等功能。这样，开发者可以通过一个组件来实现多种功能，简化了对象的管理。

• 集中管理：

  • Actor 可以嵌套多个 PrimitiveComponent，这些组件可以共同工作，提供更强大的功能。例如，一个 Actor 可以包含一个 StaticMeshComponent（静态网格）、一个 BoxCollisionComponent（盒形碰撞）和一个 AudioComponent（音频），这些组件可以在同一个 Actor 中协同工作，形成一个完整的游戏对象。

• 自动化和简化：

  • UE的设计使得许多功能的集成和管理变得更加自动化，开发者可以更专注于实现游戏逻辑，而不必过多关注组件之间的手动管理。这种方式虽然在某些情况下可能会限制灵活性，但在处理复杂对象时可以显著提高效率。

3. 总结

• 灵活性 vs. 集中管理：

  • Unity 的组件管理提供了更高的灵活性，适合需要快速迭代和原型制作的项目，但可能导致管理复杂性增加。
  • UE 的组件管理则通过功能融合和集中管理来简化开发过程，适合需要高度定制和复杂逻辑的项目，但可能在某些情况下限制了灵活性。

• 选择依据：

  • 开发者在选择使用Unity还是UE时，应考虑项目的需求、团队的熟悉程度以及对组件管理灵活性和复杂性的具体要求。理解这两种引擎的组件管理方式有助于更有效地利用它们的特性，提升开发效率。

对象的层次结构比较

在游戏开发中，对象的层次结构是组织和管理游戏世界中实体的重要方式。Unity 和 Unreal Engine（UE）在对象层次结构的实现上有显著的不同，以下是对这两者的比较：

1. Unity 的对象层次结构

• Transform 组件：

  • 在Unity中，所有的 GameObject 都自带一个 Transform 组件。这个组件用于管理对象在3D空间中的位置、旋转和缩放。

• 灵活的嵌套：

  • GameObject 可以自由嵌套，形成灵活的层次结构。开发者可以将一个 GameObject 作为另一个 GameObject 的子对象，这样子对象会相对于父对象进行变换（例如，移动、旋转等）。这种层次结构使得组织和管理场景中的对象变得直观且高效。

• 场景管理：

  • 通过这种层次结构，开发者可以轻松地管理复杂的场景，例如将多个对象组合成一个整体，或者通过父子关系来实现特定的行为（如角色的武器、道具等）。

2. UE 的对象层次结构

SceneComponent 的使用

在 Unreal Engine（UE）中，SceneComponent 是一个重要的组件，用于管理 Actor 的位置、旋转和缩放等空间属性。与 Unity 中的 Transform 组件不同，UE 的设计将空间管理功能封装在 SceneComponent 中，使得 Actor 的层次结构和空间变换更加灵活和强大。以下是对 SceneComponent 的详细介绍及其使用方式：

1. SceneComponent 的基本概念

• 不自带 Transform：

  • 在 UE 中，Actor 本身并不直接包含 Transform 组件。相反，Transform 属性（位置、旋转、缩放）是通过 SceneComponent 来管理的。这种设计使得 Actor 可以更灵活地组合和管理多个组件。

• 空间管理：

  • SceneComponent 负责处理 Actor 的空间属性，包括位置、旋转和缩放。每个 SceneComponent 都可以有自己的 Transform，并且可以作为其他组件的父级或子级，从而形成层次结构。

2. SceneComponent 的功能

• 层次结构：

  • SceneComponent 可以嵌套在其他 SceneComponent 中，形成复杂的层次结构。这使得开发者可以创建具有多层次关系的对象，例如一个角色的武器、装备等都可以作为其子组件。

• 变换继承：

  • 子组件会继承父组件的变换属性。这意味着，如果父组件移动或旋转，所有子组件也会相应地移动或旋转。这种继承关系使得管理复杂对象变得更加简单和直观。

• 附加功能：

  • SceneComponent 可以与其他类型的组件（如 MeshComponent、AudioComponent、CollisionComponent 等）结合使用，形成一个完整的 Actor。例如，一个 StaticMeshComponent 可以附加到 SceneComponent 上，从而使得网格在场景中具有位置和变换。

3. 使用场景

• 创建复杂对象：

  • 开发者可以使用 SceneComponent 来创建复杂的游戏对象。例如，一个车辆 Actor 可以包含多个 SceneComponent，分别用于车身、轮胎、引擎等，每个组件可以独立管理其变换。

• 游戏逻辑管理：

  • SceneComponent 也可以用于管理游戏逻辑。例如，开发者可以创建一个 SceneComponent 来处理特定的游戏行为（如跟随、旋转等），并将其附加到 Actor 上。

• 不需要显示的对象：

  • 由于 SceneComponent 可以存在于不需要直接渲染的 Actor 中，开发者可以创建一些仅用于逻辑处理的对象，例如游戏状态管理器、触发器等。

4. 总结

• 灵活性与强大功能：

  • SceneComponent 的设计使得 UE 的 Actor 在空间管理和层次结构方面具有更高的灵活性和强大功能。开发者可以通过组合不同的 SceneComponent 来创建复杂的对象和行为。

• 适用场景：

  • 这种设计特别适合需要复杂逻辑和状态管理的项目，能够有效地组织和管理游戏中的对象，提高开发效率。

通过理解和利用 SceneComponent，开发者可以在 UE 中构建出更为复杂和动态的游戏世界。

• 层次结构的灵活性：

  • UE允许存在一些不需要显示或具体位置的对象，例如游戏规则和状态，这些对象通常继承自 AInfo（Actor 的子类）。这使得开发者可以创建不直接参与场景渲染的对象，例如管理游戏状态的控制器或逻辑处理器。

• 复杂对象的管理：

  • 通过 SceneComponent，开发者可以创建复杂的层次结构，允许多个组件嵌套在同一个 Actor 中。这种设计使得 Actor 可以包含多个子组件，形成一个完整的功能单元，便于管理和扩展。

3. 总结

• 层次结构的实现：

  • Unity 的层次结构通过 Transform 组件实现，所有 GameObject 都可以自由嵌套，形成直观的层次关系，适合快速开发和原型制作。
  • UE 的层次结构通过 SceneComponent 实现，允许更灵活的对象管理，包括不需要显示的对象。这种设计适合需要复杂逻辑和状态管理的项目。

• 选择依据：

  • 开发者在选择使用Unity还是UE时，应考虑项目的需求、团队的熟悉程度以及对对象层次结构的具体要求。理解这两种引擎的层次结构实现方式有助于更有效地组织和管理游戏中的对象，提高开发效率。

5. 总结

• 设计理念的差异：UE 和 Unity 在设计理念上有显著差异。UE的 Actor 设计更为复杂，功能更为强大，适合需要高度定制和复杂逻辑的项目。而Unity的 GameObject 设计更为简单，适合快速开发和原型制作。

• 适用场合：选择使用UE还是Unity，取决于项目的需求和开发团队的熟悉程度。两者各有优劣，适用于不同类型的游戏开发。理解这些差异有助于开发者在不同引擎之间进行有效的转换和适应。

Component：

Unreal Engine 中的组件设计与继承关系

在 Unreal Engine（UE）中，组件（Component）的设计理念是为了简化 Actor 的功能扩展，避免复杂的继承关系。以下是对 UE 组件设计的详细分析，包括其继承关系、功能模块化的优势，以及如何在实际开发中应用这些组件。

1. 组件的设计初衷

• 避免复杂的继承链：

  • 在没有组件的早期版本中，Actor 每增加一项功能就需要创建一个新的子类，导致继承链变得复杂且难以管理。组件的引入使得功能可以通过组合的方式进行扩展，简化了 Actor 的设计。

• 功能模块化：

  • 组件负责单一的逻辑职责，开发者可以根据需要将其添加到 Actor 中，或在不需要时将其移除。这种灵活性使得 Actor 可以根据具体需求自由组合功能模块，而不必卷入庞杂的继承关系。

2. 组件的继承关系

• ActorComponent：

  • 所有要组合到 Actor 的组件都继承自 ActorComponent。这包括与位置和场景层次无关的组件，如 InputComponent、TimelineComponent、MoveComponent 和 AIComponent 等。

• SceneComponent：

  • SceneComponent 是 ActorComponent 的重要子类，所有需要表达3D位置和在场景中进行层次嵌套的组件都继承自它。常见的组件包括：
    • PrimitiveComponent（可见组件）
    • AudioComponent（声音组件）
    • ChildActorComponent（用于嵌套其他 Actor 的组件）

• RootComponent：

  • 每个 Actor 都有一个 RootComponent，这是一个 SceneComponent，作为 Actor 的根节点。对于不需要位置表示和场景层级管理的 Actor，RootComponent 可以为空指针。

3. 场景管理与层次关系

• AttachToActor 和 AttachToComponent：

  • Actor 的 RootComponent 可以通过 AttachToActor 和 AttachToComponent 等接口附加到其他 Actor 的 RootComponent 或特定的 SceneComponent 上。这使得 Actor 的层次关系可以通过其 SceneComponent 进行管理，而不是依赖于 Actor 本身。

• 动态层次关系：

  • 例如，ActorA 的某个 SceneComponent 可以附加到 ActorB 的 RootComponent 上，这样 ActorA 的 SceneComponent 会跟随 ActorB 移动，而 ActorA 本身则保持在原地。这种设计使得 Actor 的层次关系更加灵活。

• ChildActorComponent：

  • 如果需要将 Actor 设计成父子组合的关系，可以使用 ChildActorComponent。当父 Actor 被销毁时，子 Actor 也会随之被销毁。需要注意的是，ChildActorComponent 中保存了子 Actor 的指针，如果该指针所在的 Actor 是网络复制的，必须确保指针在使用前已完成复制。

4. 组件的实际应用

• 功能独立性：

  • 组件的设计初衷是作为独立的功能模块，与具体游戏逻辑无关。理想情况下，组件应该能够在不同的游戏项目中重复使用。

• 插件化：

  • 对于能够通用的组件，可以考虑将其做成插件，以便在多个项目中使用。对于耦合度高且不考虑重复利用的组件，可以直接写在游戏模块内。

• 开发实践：

  • 在实际开发中，开发者应尽量将组件设计得通用且独立，以便于后续的维护和扩展。同时，合理利用 UE 的组件系统，可以有效提高开发效率，减少代码重复。

总结

Unreal Engine 的组件设计通过引入 ActorComponent 和 SceneComponent，有效地解决了早期 Actor 继承链复杂的问题。组件的灵活性和模块化使得开发者能够更高效地管理游戏对象的功能和层次关系。通过合理使用组件，开发者可以创建出更为复杂和动态的游戏世界，同时保持

Unreal Engine 基础对象总结

在 Unreal Engine（UE）中，基础对象的设计和使用是构建游戏的核心。与 Unity 相比，UE 提供了一套更为复杂和全面的游戏开发框架，尤其是在游戏玩法（GamePlay）方面。以下是对 UE 基础对象的总结，以及它们与 Unity 的相似和不同之处。

1. UE 与 Unity 的基本对象比较

GameObject 和 Component 的比较

在游戏开发中，Unity 和 Unreal Engine（UE）都采用了组件化的设计理念，但它们在实现和使用上存在一些显著的差异。以下是对 Unity 的 GameObject 和 Component 以及 UE 的 Actor 和 Component 的详细比较。

Unity 的 GameObject 和 Component

• GameObject：

  • Unity 的核心是 GameObject，它是场景中所有对象的基础。每个 GameObject 可以代表一个角色、道具、环境元素等。
  • GameObject 本身并不具备任何功能，所有的行为和特性都是通过附加的组件来实现的。

• Component：

  • 组件是附加到 GameObject 上的功能模块，负责定义 GameObject 的行为和属性。例如，Transform 组件用于控制位置、旋转和缩放，Rigidbody 组件用于物理模拟，Collider 组件用于碰撞检测。
  • 开发者可以根据需要自由组合不同的组件，以实现所需的功能。这种灵活性使得 Unity 特别适合快速原型开发和多样化的游戏类型。

Unreal Engine 的 Actor 和 Component

• Actor：

  • 在 UE 中，Actor 是场景中的基本实体，所有可以放置在关卡中的对象都继承自 Actor。Actor 可以是静态的（如建筑物）或动态的（如角色）。
  • Actor 本身可以包含多种内置功能，如网络同步、生命周期管理等，提供了更为复杂的行为模型。

• Component：

  • 与 Unity 类似，UE 的 Component 用于为 Actor 添加特定的功能。开发者可以创建自定义组件，封装特定的逻辑，以便在多个 Actor 中复用。
  • UE 的组件系统也支持多种类型的组件，如 StaticMeshComponent、SkeletalMeshComponent、CameraComponent 等，允许开发者为 Actor 添加丰富的功能。

主要区别

1. 复杂性：

   • Unity 的 GameObject 设计相对简单，开发者需要通过组合组件来实现功能，灵活性高，但初学者可能需要更多时间理解如何有效组合组件。
   • UE 的 Actor 概念更为复杂，内置了更多的功能和默认行为，适合需要快速实现复杂逻辑的开发者。

2. 功能内置：

   • Unity 的 GameObject 需要通过组件来实现所有功能，开发者需要手动管理和组合这些组件。
   • UE 的 Actor 自身就具备一些内置功能，开发者可以直接利用这些功能，减少了重复工作。

Actor 的内置功能与复杂行为模型

在 Unreal Engine（UE）中，Actor 是场景中的基本实体，除了作为游戏对象的基础外，它还具备多种内置功能，这些功能使得 Actor 能够实现复杂的行为模型。以下是一些关键的内置功能和它们的作用：

1. 网络同步

• 网络功能：

  • UE 的 Actor 支持网络同步，这使得开发者能够轻松实现多人游戏的功能。通过内置的网络框架，Actor 可以在客户端和服务器之间同步状态和行为。
  • 开发者可以使用 Replicated 属性标记需要同步的变量，UE 会自动处理这些变量在网络中的传输和更新。

• 角色控制：

  • PlayerController 和 Pawn 的结合使得玩家的输入和行为能够通过网络进行同步，确保所有玩家在游戏中看到的状态是一致的。

2. 生命周期管理

• 生命周期事件：

  • Actor 提供了一系列生命周期事件，如 BeginPlay、Tick 和 EndPlay，开发者可以在这些事件中实现初始化、更新和清理逻辑。
  • BeginPlay 在 Actor 被放置到场景中时调用，适合进行初始化设置；Tick 每帧调用，适合处理动态更新；EndPlay 在 Actor 被销毁时调用，适合进行资源清理。

• 激活与禁用：

  • Actor 可以被激活或禁用，开发者可以根据游戏逻辑控制 Actor 的活动状态，从而优化性能和资源使用。

3. 组件管理

• 组件的添加与管理：
  • Actor 可以包含多个 Component，这些组件可以在运行时动态添加或移除。开发者可以根据需要调整 Actor 的功能和行为。
  • 通过组件的组合，开发者可以实现复杂的行为，例如将物理、动画和声音组件结合在一起，创建一个完整的游戏角色。

4. 物理与碰撞

• 物理模拟：
  • Actor 可以与物理引擎集成，支持重力、碰撞和其他物理效果。开发者可以通过 StaticMeshComponent 或 SkeletalMeshComponent 来实现物理交互。
  • 碰撞检测可以通过设置不同的碰撞通道和响应来实现，确保 Actor 在游戏世界中与其他对象正确交互。

5. 动画与状态机

• 动画系统：
  • 对于角色类 Actor，UE 提供了强大的动画系统，支持状态机、动画蓝图等功能。开发者可以通过这些工具实现复杂的动画逻辑和角色行为。
  • 动画可以与 Actor 的状态和输入相结合，创建流畅的角色控制体验。

总结

Unreal Engine 中的 Actor 不仅是场景中的基本实体，还具备多种内置功能，如网络同步、生命周期管理、组件管理、物理与碰撞处理以及动画系统。这些功能使得 Actor 能够实现复杂的行为模型，适合开发高质量的游戏。通过利用这些内置功能，开发者可以更高效地构建游戏逻辑，减少重复工作，从而专注于创造独特的游戏体验。

3. 使用场景：
   • Unity 更适合快速开发和原型设计，尤其是在多样化的游戏类型中。
   • UE 更适合需要复杂逻辑和高性能的游戏开发，特别是在大型项目和高质量图形表现方面。

总结

Unity 的 GameObject 和 Component 组合提供了极大的灵活性，适合多种类型的游戏开发。而 UE 的 Actor 和 Component 则在复杂性和内置功能上提供了更多的支持，适合需要快速实现复杂游戏逻辑的开发者。选择哪种引擎和设计模式，往往取决于项目的具体需求和开发团队的经验。

2. UE GamePlay 框架的优势

• 深思熟虑的设计：

  • UE 的 GamePlay 框架源于其在 FPS 游戏开发中的应用，经过多年的迭代和优化，提供了许多现成的功能，如角色控制、网络同步、动画系统等。这些功能可以大大减少开发时间，尤其是在开发类似类型的游戏时。

• 适应性强：

  • 对于开发 FPS、动作冒险等类型的游戏，UE 的默认框架能够提供极大的便利，开发者可以直接利用现有的功能进行扩展。
  • 例如，开发一款吃鸡游戏时，UE 的网络功能和角色控制系统可以直接使用，开发者只需关注游戏的独特逻辑和玩法。

3. 开发类型差异的挑战

• 类型差异：

  • 对于与 FPS 类型差异较大的游戏，如三消游戏或实时战略（RTS）游戏，UE 的默认框架可能并不完全适用。虽然基本的相机控制、输入处理和 HUD 功能可以利用，但大部分游戏逻辑仍需重新开发。
  • 在这种情况下，开发者可能需要花费更多时间去适应和重构框架，以满足特定游戏类型的需求。

• 设计思路的顺应与违背：

  • 顺应 UE 的设计思路，开发者可以更顺利地利用引擎的优势，快速实现游戏功能。
  • 但如果违背其设计框架，虽然仍然可以实现目标，但可能会导致开发效率降低，浪费引擎提供的便利性。

4. UE GamePlay 框架下各对象的用法

• Actor：

  • Actor 是 UE 中的基本实体，所有可以放置在场景中的对象都继承自 Actor。开发者可以通过继承 Actor 创建自定义的游戏对象，并为其添加 Component 来扩展功能。

• Component：

  • Component 用于为 Actor 添加特定的功能，如物理、声音、动画等。开发者可以创建自定义组件，封装特定的逻辑，以便在多个 Actor 中复用。

• Pawn 和 Character：

  • Pawn 是可以被玩家或 AI 控制的 Actor，而 Character 是 Pawn 的一个子类，提供了更为复杂的运动和动画功能，适合用于角色控制。

• GameMode 和 GameState：

  • GameMode 定义了游戏的规则和流程，控制游戏的开始、结束和状态管理。GameState 则用于存储游戏的状态信息，允许在网络游戏中进行同步。

• PlayerController：

  • PlayerController 负责处理玩家的输入和与游戏的交互。它是连接玩家与游戏世界的桥梁，开发者可以在此实现自定义的输入逻辑。

总结

Unreal Engine 提供了一套强大的基础对象和 GamePlay 框架，适合多种类型的游戏开发。

二， UE4的GamePlay框架介绍

UE的GamePlay部分的大概的架构关系如下图：

Unreal Engine 中的 GamePlay 对象架构

在 Unreal Engine（UE）中，GamePlay 对象的架构是基于 Object 类的层次结构构建的。所有的 GamePlay 对象都继承自 Object，这为它们提供了反射、序列化和统一内存管理等基础功能。以下是对 UE GamePlay 架构中对象的详细分析：

1. Object 类

• 基础类：

  • Object 是 UE 中所有类的基类，提供了基本的功能和特性。所有的 UClass（以 U 开头的类）都直接或间接地继承自 Object。
  • 反射系统允许开发者在运行时查询对象的属性和方法，支持蓝图和编辑器的功能。

• 序列化：

  • Object 提供了序列化功能，使得对象的状态可以被保存和加载。这对于游戏存档、网络传输和编辑器操作非常重要。

• 内存管理：

  • UE 使用统一的内存管理系统，确保对象的创建和销毁是高效且安全的。通过智能指针（如 TSharedPtr 和 TWeakPtr），开发者可以有效管理对象的生命周期。

2. Actor 类

• 基础游戏对象：

  • Actor 是 UE 中的基础游戏对象，所有可以放置在关卡中的实体都继承自 Actor。这包括角色、道具、环境元素等。
  • Actor 继承了 Object 的所有功能，并增加了网络同步和组件管理的能力。

• 网络同步：

  • Actor 提供了内置的网络同步功能，使得开发者能够轻松实现多人游戏的功能。通过属性复制和远程过程调用（RPC），Actor 的状态可以在客户端和服务器之间同步。

• 组件管理：

  • Actor 可以包含多个 Component，这些组件为 Actor 提供了特定的功能和行为。开发者可以通过组合不同的组件来实现复杂的游戏逻辑。

3. U 开头的类与 A 开头的类

• U 开头的类：

  • 以 U 开头的类通常是继承自 Object 的类，代表各种非游戏对象，如数据结构、工具类、蓝图类等。这些类不直接参与游戏世界的物理交互，但可以在游戏逻辑中发挥重要作用。
  • 例如，UTexture、UMaterial 和 UDataAsset 等类都是以 U 开头的，它们用于管理资源和数据。

• A 开头的类：

  • 以 A 开头的类是继承自 Actor 的类，代表游戏世界中的实体。这些类可以被放置在关卡中，并参与游戏的物理和逻辑交互。
  • 例如，ACharacter、AEnemy 和 AItem 等类都是以 A 开头的，它们可以在游戏中被实例化并与玩家或其他对象进行交互。

4. World/Level 中的对象管理

• 关卡中的对象：

  • 在 UE 中，所有放置在 World 或 Level 中的 GamePlay 对象都是继承自 Actor。这意味着它们可以利用 Actor 提供的网络同步和组件管理功能。
  • 当关卡切换时，这些 Actor 对象会被加载和卸载，确保游戏状态的正确管理。

• 非关卡对象：

  • 其他不继承自 Actor 的对象（如 UObject 类）则存在于 World 或 Level 之上，不会随着关卡的切换而消失。这些对象通常用于管理游戏的全局状态或数据，例如游戏管理器、音频管理器等。

总结

Unreal Engine 的 GamePlay 对象架构通过 Object 和 Actor 的层次结构，为开发者提供了强大的功能和灵活性。所有 GamePlay 对象都继承自 Object，而 Actor 则是游戏世界中的基础对象，支持网络同步和组件管理。通过这种设计，UE 能够有效地管理游戏中的各种对象，确保游戏逻辑的高效实现和资源的合理使用。

Pawn 和 Controller

在 Unreal Engine（UE）的 GamePlay 架构中，Pawn 和 Controller 是开发者最常接触的两个重要对象。它们在游戏中扮演着不同的角色，协同工作以实现玩家与游戏世界的交互。以下是对这两个对象的详细介绍。

Pawn

• 定义：

  • Pawn 是游戏中的一个可控制的实体，类似于棋子或兵卒。并非所有的 Actor 都可以被玩家直接操作，Pawn 专门用于处理那些可以被玩家或 AI 控制的 Actor。

• 功能：

  • Pawn 内部集成了多种基础功能，包括 AI 寻路、物理碰撞和移动控制等。这些功能使得 Pawn 能够在游戏世界中进行有效的交互。
  • 由于 UE 的历史背景，Pawn 还保留了一些与 FPS 游戏相关的逻辑变量，如 Damage 和 KillZ，这可能会让初学者感到困惑，但这些设计是为了方便 FPS 游戏的开发。

• 子类：

  • UE 提供了几种不同类型的 Pawn，例如：
    • SpectatorPawn：用于处理没有实体的玩家漫游。
    • Character：提供人形 Pawn 的基础功能，适合用于角色控制。

• 自定义：

  • 如果游戏中的玩家控制的 Actor 与 UE 默认提供的 Pawn 有较大差异，开发者可以从 Actor 开始，创建自己的 Pawn 类。

Controller

• 定义：

  • Controller 是 Pawn 的控制器，负责处理与 Pawn 相关的控制逻辑，包括网络同步、输入处理、相机操作等。

• 设计原因：

  • 设计 Controller 的原因在于将控制逻辑与 Pawn 的表现逻辑分离。这样，当 Pawn 死亡时，Controller 仍然可以存在并切换到其他 Pawn 上进行控制。
  • Controller 不能简单地作为 Component 附加到 Pawn 上，因为它们之间并不是组成与被组成的关系。

• 继承自 Actor：

  • Controller 继承自 Actor，是因为它需要使用 Actor 提供的基础设施（如网络、组件、序列化等）。如果从 UObject 继承，开发者将不得不重新实现 Actor 提供的许多功能。

• 可见性：

  • 尽管 Controller 继承自 Actor，它的设计目的主要是用于控制，而非显示。因此，UE 默认将其隐藏，以避免误用。

逻辑分配

• 在 Pawn 中实现的逻辑：

  • 与显示相关的逻辑，如移动、动画、碰撞检测等，应该在 Pawn 中实现。这些逻辑直接影响 Pawn 在 3D 世界中的表现。

• 在 Controller 中实现的逻辑：

  • 控制逻辑，如何时移动（基于输入或 AI 决策）、何时播放动画、碰撞后如何处理等，应该在 Controller 中实现。
  • 需要注意的是，Controller 的生命周期通常比 Pawn 更长，因此在 Pawn 销毁后，玩家的逻辑（如复活期间的处理）也应在 Controller 中进行。

总结

Pawn 和 Controller 是 UE GamePlay 架构中不可或缺的两个组件。Pawn 代表了游戏中的可控制实体，而 Controller 则负责管理这些实体的控制逻辑。通过将控制逻辑与表现逻辑分离，UE 提供了灵活的架构，使得开发者能够更高效地实现复杂的游戏机制。这种设计不仅适用于 FPS 游戏，也可以扩展到其他类型的游戏中。

World 和 Level

在 Unreal Engine（UE）中，World 和 Level 是管理和表示 3D 世界的重要概念。它们作为 Actor 对象的容器，负责组织和管理游戏中的各种对象。以下是对这两个概念的详细介绍。

World

• 定义：

  • World 代表游戏的整体场景表现，管理着游戏世界中的所有表现对象。它是游戏运行时的核心容器，负责协调和管理所有的 Actor。

• 特性：

  • 通常情况下，一个游戏实例对应一个 World。然而，在编辑器中，每个编辑窗口可能会对应一个独立的 World，这使得开发者可以在不同的上下文中进行编辑和测试。
  • World 中包含一个特殊的对象 WorldSettings，它是从 Actor 继承而来的。WorldSettings 主要用于存储与该 World 相关的属性信息，但它本身并不在场景中可见，因此没有位置概念。

• 管理功能：

  • World 负责管理游戏中的所有 Actor，包括它们的生命周期、更新和渲染等。它还处理物理、光照、音效等全局设置。

Level

• 定义：

  • Level 是 World 的一个组成部分，通常一个 World 只包含一个主 Level。在动态加载多关卡的情况下，World 可以包含多个子关卡（Sub Level）。

• 功能：

  • Level 允许开发者将游戏世界分割成多个部分，从而实现更高效的内存管理和加载。没有 Level 的概念，无法将一个无缝的大世界场景全部加载到内存中，这会导致性能问题。

• LevelScriptActor：

  • 与 Level 相关的一个特殊类是 LevelScriptActor，也称为关卡蓝图。它用于处理特定关卡的逻辑，例如场景的淡入淡出、物体之间的关联和初始化等。
  • 需要注意的是，LevelScriptActor 默认不提供 Actor 对应的 Component 编辑界面。这表明 UE 认为 LevelScriptActor 主要用于处理简单的关卡逻辑，而不希望开发者在其中引入过于复杂的逻辑。

总结

World 和 Level 是 UE 中管理 3D 世界的基础结构。World 作为游戏的整体容器，负责管理所有的 Actor 和全局设置，而 Level 则是 World 的一个组成部分，用于组织和分割游戏场景。通过这种结构，UE 能够高效地处理复杂的游戏世界，支持动态加载和管理多个关卡。LevelScriptActor 的引入则为关卡逻辑提供了灵活性，使得开发者能够在不增加复杂性的情况下实现特定的关卡功能。

GameMode、GameState 和 PlayerState

在 Unreal Engine（UE）中，除了 World 和 Level，还有几个重要的对象与游戏的规则和信息管理相关。这些对象包括 GameMode、GameState 和 PlayerState。下面是对这些对象的详细介绍。

GameMode

• 定义：

  • GameMode 是负责整个游戏世界逻辑的对象。它管理游戏的基本规则、状态和流程。

• 主要职责：

  • 基础对象的类型登记：GameMode 负责注册和管理游戏中使用的各种基础对象类型，例如玩家角色、敌人、道具等。
  • 游戏状态管理：它跟踪游戏的当前状态（如进行中、暂停、结束等），并根据需要进行状态切换。
  • World 切换：在需要切换不同的游戏世界时，GameMode 负责处理相关逻辑。

• 网络特性：

  • 在联网游戏中，GameMode 只存在于服务器端，客户端并不保存该对象。这意味着 GameMode 是非复制的，只有在服务器上创建，客户端无法直接访问。

• 继承：

  • 如果开发者希望在 GameMode 中添加自定义逻辑，但又不想保留早期 FPS 游戏中的复杂逻辑，可以选择继承自 GameModeBase 类。GameModeBase 是一个更简化的版本，去除了许多具体的游戏逻辑。

GameState

• 定义：

  • GameState 是与游戏状态相关的对象，主要用于存储需要同步给所有客户端的游戏信息和逻辑。

• 主要职责：

  • GameState 由 GameMode 管理，并被设置为复制属性。这意味着它的状态会在服务器和所有客户端之间同步。
  • 它可以存储游戏的全局信息，例如当前得分、游戏时间、玩家数量等。

PlayerState

• 定义：

  • PlayerState 是与玩家相关的信息存储对象，主要用于保存需要在多个客户端之间同步的玩家信息。

• 主要职责：

  • PlayerState 可以复制到所有客户端，而 PlayerController 只存在于服务器和单个客户端。因此，所有需要同步的玩家信息（如得分、生命值、玩家名称等）都可以保存在 PlayerState 中。
  • 每个 PlayerController 都与一个 PlayerState 一一对应，确保每个玩家的状态信息能够在网络中正确传递。

总结

在 UE 中，GameMode、GameState 和 PlayerState 是管理游戏规则和信息的重要对象。GameMode 负责整个游戏的逻辑和状态管理，GameState 用于同步游戏状态到所有客户端，而 PlayerState 则专注于存储和同步每个玩家的状态信息。这种结构使得 UE 能够高效地处理网络游戏中的状态同步和逻辑管理，确保玩家之间的互动和游戏体验的一致性。

Player

在 Unreal Engine（UE）中，Player 是一个重要的概念，它代表了玩家的抽象表示。与 Pawn 和 Controller 不同，Player 直接继承自 Object，并且在游戏的架构中扮演着独特的角色。以下是对 Player 的详细介绍。

Player

• 定义：

  • Player 是一个表示玩家的对象，直接继承自 Object。它的设计目的是为了在 World 之上表示玩家的存在。

• 为什么不继承自 Actor：

  • Player 不适合继承自 Actor，因为 Actor 只能存在于 World 中，而 Player 的概念超越了 World 的范围。Player 是一个更高层次的抽象，代表了玩家的身份和状态，而不局限于游戏世界中的具体表现。

• 子类：

  • Player 有两个主要的子类：LocalPlayer 和 NetConnection。

  • LocalPlayer：

    • LocalPlayer 只存在于客户端，表示本地玩家的视口，并负责接收输入系统的消息。每个 LocalPlayer 与客户端的视口一一对应，确保玩家的输入能够正确传递到游戏中。

  • NetConnection：

    • NetConnection 代表网络连接，分为 ServerConnection 和 ClientConnections。这两个成员变量定义在 NetDriver 中。
      • ServerConnection：只存在于客户端，表示与服务器的连接。
      • ClientConnections：是一个数组，存在于服务器，代表所有客户端的连接。

Player 与 PlayerController 的关系

• Player 决定了 PlayerController 的创建时机。当服务器的 GameMode 接收到来自 Player（实际上是一个 ClientConnection）的登录消息时，会在服务器上创建对应类型的 PlayerController，并将其复制到客户端。客户端随后会找到对应的 LocalPlayer 进行关联。

自定义 LocalPlayer

• UE 允许开发者自定义 LocalPlayer，但与 PlayerController 在 GameMode 中定义类型不同，LocalPlayer 的类型是在引擎设置（Engine Settings）中定义的。这是因为 Player 本身并不依赖于具体的 World，而是一个引擎层面的概念。Player 和 GameMode 之间是一对多的关系，因此不适合在 GameMode 中定义 LocalPlayer 类型。

总结

Player 是 UE 中一个重要的概念，它提供了一种在 World 之上表示玩家的方式。通过 LocalPlayer 和 NetConnection 的设计，Player 能够有效地管理本地和网络玩家的状态和输入。Player 的存在使得游戏能够在不同的上下文中处理玩家的身份和连接，同时与 PlayerController 形成了紧密的协作关系。这样的设计为开发者提供了灵活性，使得他们能够根据需要自定义玩家的行为和特性。

Engine 和 GameInstance

在 Unreal Engine（UE）中，Engine 和 GameInstance 是引擎架构的最上层对象，它们在游戏的生命周期和管理中扮演着至关重要的角色。以下是对这两个对象的详细介绍。

Engine

• 定义：

  • Engine 是整个 Unreal Engine 的核心对象。它是引擎的基础，负责管理引擎中的系统基础模块。

• 特性：

  • 每个 UE 进程对应一个唯一的 Engine 实例。引擎的初始化过程从 Engine 开始，之后才会创建其他所有对象和模块。
  • Engine 负责管理引擎的生命周期，包括资源管理、渲染、输入处理等核心功能。

GameInstance

• 定义：

  • GameInstance 是引擎的第二个主要对象，它是在 Engine 初始化完成后创建的。GameInstance 代表了游戏的实例，通常在游戏运行时只会有一个 GameInstance 实例，但在编辑器模式下可能会有多个实例。

• 主要职责：

  • 游戏实例的初始化和结束：GameInstance 负责管理游戏的启动和关闭过程。
  • World 的管理：它负责管理游戏中的 World，包括加载和切换不同的 World。
  • Player 的创建和销毁管理：GameInstance 负责管理玩家的创建和销毁，包括 PlayerController 和 Player 的生命周期。
  • OnlineSession 的管理：它处理与在线会话相关的逻辑，例如创建、加入和管理多人游戏会话。
  • NetDriver 的管理：GameInstance 还负责管理网络驱动程序，处理网络连接和数据传输。

• 管理对象：

  • GameInstance 中管理了许多与游戏相关的对象和逻辑，这些对象的概念超出了 World 的范围。因此，开发者在实现游戏逻辑时，可以根据需求在 GameInstance 中添加具体的逻辑和对象。

• 自定义 GameInstance：

  • 开发者可以自定义自己的 GameInstance 类。与 Player 类似，GameInstance 直接继承自 Object，并且可以在引擎设置（Engine Settings）中定义自定义类型。这种设计使得 GameInstance 能够灵活地适应不同游戏的需求。

总结

Engine 和 GameInstance 是 Unreal Engine 架构中的两个核心对象。Engine 作为引擎的基础，负责管理系统的核心模块，而 GameInstance 则负责游戏的实例管理，包括 World、玩家、在线会话等。通过合理利用这两个对象，开发者可以有效地管理游戏的生命周期和逻辑，确保游戏的稳定性和可扩展性。

三， 结语

Unreal Engine 4（UE4）和 Unity 各自有其独特的优势和特点，适用于不同类型的游戏开发需求。以下是对这两个引擎的一些比较，以及 UE4 的一些主要特点和优势。

Unity 的特点

1. 易用性：

   • Unity 的界面友好，适合初学者。其组件化的设计使得开发者可以快速上手，创建简单的游戏原型。

2. 跨平台支持：

   • Unity 支持多种平台，包括移动设备、PC、主机和网页，开发者可以轻松地将游戏发布到多个平台。

3. 丰富的资产商店：

   • Unity Asset Store 提供了大量的资源和插件，开发者可以快速找到所需的素材和工具，节省开发时间。

4. 灵活的脚本系统：

   • Unity 使用 C# 作为主要的编程语言，许多开发者对 C# 的熟悉程度较高，便于快速开发。

Unreal Engine 4 的特点

1. 高质量的图形渲染：

   • UE4 在图形渲染方面表现出色，支持高质量的光照、阴影和材质效果，适合开发需要高视觉效果的游戏。

2. 丰富的 GamePlay 对象：

   • UE4 提供了丰富的内置 GamePlay 对象和系统，如 Actor、Pawn、Controller、GameMode 等，开发者可以利用这些对象快速构建复杂的游戏逻辑。

3. 蓝图可视化脚本：

   • UE4 的蓝图系统允许开发者通过可视化的方式编写游戏逻辑，降低了编程的门槛，使得非程序员也能参与到游戏开发中。

4. 强大的物理和动画系统：

   • UE4 提供了强大的物理引擎和动画工具，适合开发需要复杂物理交互和动画效果的游戏。

5. 社区和文档支持：

   • UE4 拥有活跃的开发者社区和丰富的文档资源，开发者可以轻松找到解决方案和学习资料。

结论

选择使用 Unity 还是 UE4 主要取决于项目的需求、团队的技能和开发者的偏好。对于需要高质量图形和复杂 GamePlay 逻辑的项目，UE4 是一个非常合适的选择。通过深入理解 UE4 的 GamePlay 架构和对象设计理念，开发者可以在合适的项目中充分发挥引擎的优势，实现事半功倍的效果。

总之，了解每个引擎的特点和适用场景，结合具体的项目需求，才能做出最优的选择。无论是 Unity 还是 UE4，都是强大的工具，能够帮助开发者实现他们的创意和目标。