<html>-CSDN博客

------------------------------------------------------------------
说明：
本翻译是參考、修正、整理后的文档。如有错误，请善意提示；如需转载。请注上出处。谢谢！！

。

官方文档传送门：点击打开链接
參考翻译文档：点击打开链接
------------------------------------------------------------------

Unreal Engine 4 For unity

针对Unity开发人员的UE4

本页面的内容：

This guide provides an overview of UE4 from the viewpoint of a Unity user, and aims to help you translate your existing Unity experience into the world of UE4.
本文以Unity使用者的角度概述了UE4，旨在帮助已入Unity坑的你过渡到UE4的坑里面去。

The Editor （编辑器）

Below are pictures of the Unity Editor and Unreal Editor, color-coded to indicate common functionality. Each block is labeled to show the equivalent UE4 terminology. Unreal Editor's layout is fully customizable by dragging and dropping tabs around.
以下是Unity编辑器与Unreal编辑器的两张图，不同着色指出常见功能块。每一个块的标签表明了它们的等效术语。而且。Unreal编辑器可通过拖拽选项卡来自己定义布局（PS:unity也能够的）。

Editing Assets （编辑资源）

In Unity, the Inspector tab is used to edit selected assets in your Project. In UE4, the Details panel exposes properties of selected objects, while larger editing tasks lead to a dedicated window or tab. New tabbed windows will open for each edited asset, similar to a web browser. Of course, you can freely drag the tabs around or float them as standalone windows.
在Unity中，Inspector选项卡被用来编辑你项目中被选中的资源。

而在UE4中，Detail面板显示了所选对象的属性，且有专门的窗体或选项卡用来编辑更大的任务。新的选项卡式窗体会像浏览器那样打开来编辑资源。当然，你能够自由拖动或浮动它们作为独立的窗体。

Quick Glossary （术语快览）

The following section contains common Unity terms on the left and their UE4 equivalents (or rough equivalent) on the right. UE4 keywords link directly to more in-depth information inside Unreal Engine's Online Documentation.
以下部分左边为常见的Unity术语，右边为相应的UE4术语。UE4的术语链接可直接进入虚幻引擎在线文档中获取更具体的信息。


Category	Unity	UE4
Gameplay Types	Component	Component
	GameObject	Actor, Pawn
	Prefab	Blueprint Class
Editor UI	Hierarchy Panel	World Outliner
	Inspector	Details Panel
	Project Browser	Content Browser
	Scene View	Viewport
Meshes	Mesh	Static Mesh
	Skinned Mesh	Skeletal Mesh
Materials	Shader	Material, Material Editor
	Material	Material Instance
Effects	Particle Effect	Effect, Particle, Cascade
	Shuriken	Cascade
Game UI	UI	UMG (Unreal Motion Graphics)
Animation	Animation	Skeletal Animation System
	Mecanim	Persona , Animation Blueprint
2D	Sprite Editor	Paper2D
Programming	C#	C++
	Script	Blueprint
Physics	Raycast	Line Trace, Shape Trace
	Rigid Body	Collision, Physics
Runtime Platforms	iOS Player, Web Player	Platforms

Projects and files （项目与文件）

So what are all these directories and files? （这些文件夹和文件是什么？）

Just like Unity projects, Unreal projects always exist in their own directory and have their own project file. You can double-click on.uproject files to load your game into the Unreal Editor, or right-click for additional options. Project folders have various sub-folders that contain your game's content and source as well as various configuration files and binaries. The most important are the Content andSource sub-folders.
就像Unity项目，Unreal项目总是存在于它们自己的目录下，并有者自己的项目文件。

你能够双击或右键点击.uproject 文件来载入你的游戏到虚幻编辑器中。

项目目录下又有很多子目录，它们包括了你的游戏内容和资源。以及各种配置文件和二进制文件。当中最重要的是Content和 Source子目录。

Where do I put my assets?（我应该把资源放在哪里？）

In UE4, each project has a Content folder. Similar to a Unity project's Assets folder, this is where your game assets are stored. To import assets into your game, simply drop files into your project's Content directory and they will be automatically imported and appear in theContent Browser. The assets in the editor will update automatically as you make changes to the files using an external program.
与Unity的Assets目录类似，在UE4中，每一个项目都有一个Content目录用来存放资源。

为了导入资源到游戏中，你能够直接将文件拖到你项目的Content目录下。它们会自己主动被导入并显示在Content Browser中。当编辑器中的资源文件会在发现改编后自己主动更新。

image alt text

What common file formats are supported?（支持哪些文件格式？）

Unity supports a wide array of file formats. UE4 supports the most common file types:
Unity支持各种各样的文件格式。UE4支持最常见的的文件类型：


Asset Type	Supported Formats
3D	.fbx, .obj
Texture	.png, .jpeg, .bmp ,.tga, .dds, .exr, .psd, .hdr
Sound	.wav
Fonts	.ttf, .otf
Videos	.mov, .mp4, .wmv

How is my Scene stored?（场景怎样存储？）

In Unity, you place GameObjects in a scene and save that as a Scene asset file. Unreal has a Map file that is similar to a Unity Scene. Map files store data about your Level and the objects in it, as well as lighting data and certain level-specific settings.
Unity中，你把GameObject至于场景中并将其村委Scene资源文件。Unreal中的Map文件类似于Unity的Scene文件。Map文件存储了关卡数据、关卡中的对象、光照数据、以及关卡特定的属性设置。

How do I change my project's settings?（怎样更改项目设置？）

All project settings can be found from the main menu under Edit / Project Settings. Like Unity's project settings, these allow you to specify information about your project (such as project name and icons), configure game input bindings, and define how the engine behaves when running your project. You can learn more about individual project settings here. Unity also has what is called "player settings". In Unreal, these are "platform settings", and can be found under the "Platforms" category in your project settings.
UE4的全部项目设置能够在主菜单下的Edit / Project Settings中找到。就像能够在Unity的project settings改动你的项目信息（比方项目名和图标），配置游戏输入绑定。以及定义项目执行时的引擎行为一样。

你能够在这里获取很多其它关于project settings的信息。

Where do my source files go?（源文件应该放在哪里？）

In Unity, you are accustomed to placing C# source files in your assets folder.
在Unity,你习惯将C#发在assets目录里。

UE4 works differently. For projects that have C++ code, you will find a "Source" sub-folder under the project directory that has various files, including C++ source (.cpp) and header (.h) files, as well as some build scripts (.Build.cs, .Target.cs) However, Blueprint-only projects will not have a Source folder.
但UE4却不是这种。对于C++创建的项目。你会在项目文件夹下找到"Source"子文件夹。它包括了.cpp 和 .h文件，另一些编译脚本（.Build.cs, .Target.cs）。

而通过蓝图创建项目的就没有Source这个目录。

The easiest way to get started with C++ in UE4 is to use the editor to Add Code to Project (in the main File menu), or to simply create a new C++ project from scratch from one of the many templates. You can find C++ classes right in the Content Browser and can open the files in Visual Studio or Xcode by double-clicking on their icons.
UE4開始C++项目的最简单方法就是通过（主菜单下）Add Code to Project指令，或则选择C++模板新建项目。你能够在Content Browser中找到C++类，并使VS或者Xcode双击打开。

From GameObjects to Actors （从 GameObjects 到 Actors）

Where Is My GameObject?（GameObject呢？）

In Unity, a GameObject is a "thing" that can be placed in the world. The UE4 equivalent is an Actor. In the Unreal Editor, you can drag a new Empty Actor into the viewport from the Placement panel:
Unity中的GameObject是能够被放到世界里的东东。UE的Actor与之等效。

在Unreal编辑器中，你能够直接从Placement面板中拖动Empty Actor到 viewport（世界）中。

image alt text

You could build a game out of Empty Actors, but UE4 also includes special types of Actors with built-in features, such as a Pawn (for players or AI objects), or Character (for animated creatures.) Just like Empty Actors, you can drop these special types of Actors down, then add or customize their properties and components. You will learn more about it later, but for now try to remember that UE4 has a Gameplay Framework that works with these special Actors.
你能够使用Empty Actor来创建一个游戏，可是UE4也内置了其它如 Pawn(用于玩家或AI对象) \ Character（用于可动生物）一样特定类型的Actor. 就像Empty Actor一样。你能够将这些特定类型的Actor拖进场景中，然后为其加入或定制它们的属性和组件。稍后我们将学习与它相关的很多其它内容，但如今尽量去记住UE4有一个与这些特定Actor相关联的 Gameplay Framework 。

Actors in UE4 are a bit different than GameObjects in Unity. In Unity, GameObject is C# class which you cannot directly extend. In UE4, Actor is a C++ class which you can extend and customize using inheritance. We will talk about this more later on!
UE4的Actor和UnityDe GameObject有点不同的是：Unity中的GameObject是不可扩展的C#类。而UE4的Actors是可通过继承的方式扩展并自己定义的C++类。我们将在之后扩展讨论它。

Where Are My Components?（组件呢？)

In Unity, you add components to a GameObject to give it functionality.
在Unity，你能够通过为GameObject加入组件来为其加入功能。

In UE4, you add components to Actors. After you have dropped an Empty Actor in your level, click the Add Component button (in theDetails panel) and choose a component to add. Here, we are creating a torch by dropping an empty Actor, then adding a mesh component for the base, followed by a light source and then a particle system to create its flame.
在UE4，你加入组件给Actor.当你在关卡中放置一个Actor之后。点击ADD Component(在Detail面板中) 选择一个组件进行加入。这里。我们通过放置的Empty Actor创建一个火炬，然后加入mesh组件为其基础，再之后为其加入一个光源。最后再加入一个粒子系统来创建火焰。

image alt text

In Unity, a GameObject hold a flat list of components, but in UE4 an Actor actually contains a hierarchy of components attached to one another. You can see this in the example above, where the Light and Particle are attached to the Mesh. This has some important implications discussed later in Complex Actors and GameObjects.
在Unity中，GameObject的全部组件是处于一个平面列表中的，而在UE4中，Actor的组件能够存在层级关系。如上面的样例，Light 和 Particle 依附在了mesh上。这会有一些重要的意义。我们将在在之后的Complex Actors and GameObjects章节中讨论。

From Unity prefabs to UE4 Blueprint Classes(从 Unity 的 prefabs 到 UE4 的 Blueprint Classes)

Unity's workflow is based on prefabs. In Unity you build a set of GameObjects with components, then create a prefab from them. You can then place instances of the prefab in your world, or instantiate them at runtime.
Unity的工作流是给予prefabs的。

在Unity中。你创建了具有一系列组件的GameObject，然后通过他们创建prefabs.之后你能够拖放一个实例到你的世界中。或者在执行是实例化他们。

UE4's corresponding workflow is based on Blueprint Classes. In UE4, you build an Actor with components, select it, and click the "Blueprint / Add Script" button (in the Details panel). Then, choose a place to save your Blueprint Class, and click "Create Blueprint" to save your new Blueprint Class!
UE4对应的工作流是给予Buleprint Classes的。在UE4中，你创建了一个带有组件的Actor。选中后点击 Details面板中的"Blueprint / Add Script" 。然后。找个位置来存放你的的Blueprint Classes,最后点击"Create Blueprint" 保存。

image alt text

Your new Blueprint Classes can be found in the Content Browser. You can double-click to edit them directly, or you can drag and drop them into any level.
在Content Browser能够找到你的Blueprint Classes。你能够直接双击编辑它们，或者你能够将其拖进不论什么关卡中。

Where is Script Component and MonoBehaviour?

（脚本组件和 MonoBehaviour呢？）

In Unity, you have Script Components that you drop on GameObjects to add C# scripting. You create a class that inherits from MonoBehaviour to define what that component does.
在Unity中。你能够为GameObject加入C#脚本组件。通过继承MonoBehaviour创建一个类来定义组件的功能。

UE4 has something similar. You can create whole new Component classes of your own and drop those onto any Actor. You can create Component classes using either Blueprint Scripting or C++.
UE4也有类似的东西。你能够创建全然新的组件附加个不论什么Actor。你能够通过蓝图或C++来创建组件类。

So how do you create your own component class in UE4? In the Details panel's Add Component drop-down, you see you can create new components, or choose existing ones:
那么，怎样在UE4中创建自己的组件类呢。

在Details片板中的Add Component 下拉选项中，比能够看到创建系组建或选择已有组件。

image alt text

In Unity, when creating a new MonoBehaviour, you will be given a skeleton class file with a Start() function and an Update() function.
在Unity中，当你创建新的Monobehaviour时，你会得到带有Start()和Update()方法的类。

In UE4, you will also be given a skeleton class with a InitializeComponent() function and a TickComponent() function, which perform functions similar to Start and Update.
在UE4，你也会得到带有 InitializeComponent() 和 TickComponent() 方法的类。它们的功能与Start()和Update类似。

If you create a Blueprint Script Component you will be given these same functions as visual nodes:
假设你创建蓝图组件，你会得到具有一样功能的可视化节点。

image alt text

Scriptable Actor Blueprint Classes（可编辑的Actor蓝图）

Here is a cool feature in UE4: Your new Actor Blueprint Class can have its own Blueprint Visual Scripting! This allows you to add logic to an entire object, not only an individual component. Combined with inheritance (explained below), this gives you a lot of flexibility when designing your game.
UE4有个非常酷的功能：新建的Actor蓝图有自己蓝图来实现可视化编程。这让你能够为真个对象加入逻辑，而不仅限于特定的组件。与继承结合，这会在你设计游戏的时候提供非常大的灵活性。

In addition to Blueprint Classes supporting visual scripting, UE4 also supports C++ Classes implemented with code. Here are both, side-by-side.
除了可视化编程的蓝图之外，UE4还支持通过代码实现功能的C++类。

下面是三种编程方式：

Unity C# UE4 C++

Unity C#	UE4 C++
`using UnityEngine; using System.Collections; public class MyComponent : MonoBehaviour { int Count; // Use this for initialization. void Start () { Count = 0; } // Update is called once per frame. void Update () { Count = Count + 1; Debug.Log(Count); } }`	#pragma once #include "GameFramework/Actor.h" #include "MyActor.generated.h" UCLASS() class AMyActor : public AActor { GENERATED_BODY() int Count; // Sets default values for this actor's properties. AMyActor() { // Allows Tick() to be called PrimaryActorTick.bCanEverTick = true; } // Called when the game starts or when spawned. void BeginPlay() { Super::BeginPlay(); Count = 0; } // Called every frame. void Tick(float DeltaSeconds) { Super::Tick(DeltaSeconds); Count = Count + 1; GLog->Log(FString::FromInt(Count)); } };

using UnityEngine;
using System.Collections;

public class MyComponent : MonoBehaviour
{
    int Count;

    // Use this for initialization.
    void Start ()
    {
        Count = 0;
    }

    // Update is called once per frame.
    void Update () 
    {

        Count = Count + 1;
        Debug.Log(Count);
    }
}

#pragma once
#include "GameFramework/Actor.h"
#include "MyActor.generated.h"

UCLASS()
class AMyActor : public AActor
{
    GENERATED_BODY()
    int Count;

    // Sets default values for this actor's properties.
    AMyActor() 
    {
        // Allows Tick() to be called
        PrimaryActorTick.bCanEverTick = true;  
    }

    // Called when the game starts or when spawned.
    void BeginPlay()
    {
        Super::BeginPlay();
        Count = 0;
    }

    // Called every frame.
    void Tick(float DeltaSeconds)
    {
        Super::Tick(DeltaSeconds);
        Count = Count + 1;
        GLog->Log(FString::FromInt(Count));
    }
};


UE4 Blueprint

UE4 Blueprint Classes can be extended （UE4的蓝图可被扩展）

Unity prefabs and UE4 Blueprint Classes can be instantiated in your game similarly. However, Unity has complications related to nesting prefabs within other prefabs, which limit their role as extensible building blocks.
Unity的prefabs和UE4的 Blueprint Classes 能够在你的游戏中相似的被实例化出来。

然而，Unity会有prefabs嵌套prebabs的并发机制，这样的机制限制了它们作为可扩展块的功能。

In UE4, you can create a new Blueprint Class which extends an existing Blueprint Class and augments it with new properties, components, and visual scripting functionality.
在UE4。你能够穿件新的Blueprint Class，来扩展已存在的蓝图类。并通过新的属性、组件可可视化脚脚本方法来增强它。

For example, in UE4 you can create a Blueprint Class named Monster which implements basic monster functionality such as chasing people. You can then create further Blueprint Classes which extend it, such as Dragon (a type of Monster which adds fire-breathing features), Grue (a Monster which is likely to eat you when it is dark), and for example 8 others. These subclasses of Monster all inherit the basic functionality from Monster, and add new capabilities on top.
举个栗子。在UE4中，你能够创建一个名为Monster的蓝图类，它实现了怪物如突击人类的基本功能。然后，你能够创建很多其它的蓝图来扩展它，如Dragon(可喷火的怪兽)，Grue(会在黑暗中吃掉你的怪兽)，和其它8种怪兽。

这些Monster的子类都继承了Monster的基本功能，并加入了新功能。

In Unity, you would implement this by creating many different GameObject prefabs: one for Dragon, one for Grue, and so on. Now, say you want to add some new functionality to all monsters, such as the ability to speak using your new Speak Component. In Unity, you have to go and update all 10 prefabs to individually copy and paste the new functionality into it.
在Unity ，你能够通过创建不同的GameObject预设来实现这种功能：Dragon预设、Grue预设、等等。如今，你想为全部的怪兽加入新的功能。比方使用你的Speak组件来使它们说人话。在Unity中，你须要对这10个预设一个一个地更新，来为它们加入新的功能。

In UE4, you can simply modify the Monster Blueprint Class to add this new ability to speak. That's all! Dragon, Grue, and the 8 other subclasses of Monster automatically inherit the new speaking functionality, and you do not need to touch them.
在UE4。你仅仅需简单地改动Monster蓝图来加入这样的说话能力。这就够了，Dragon、Grue和其它8个Monster的子类都会自己主动继承这样的说话能力，你不用再一一点击它们。

But there is more! Everything we have said here about Blueprint Classes also applies to C++ Classes, and everything is equally true of Actors and Components. These systems are designed to support large-scale development of extensible functionality, and can scale to projects with 10's or 100's of developers.
更值得一提的是，我们所说的关于Blueprint Classes的一切相同适用于C++ Classes 。适用于Actor和Component。这样的系统是为大规模可扩展功能的开发而设计的，并可扩展到10到100人的项目其中去。

Should I use Blueprint Scripting, C++, or both?

（我该使用蓝图、C++，还是都使用？）

Blueprint Visual Scripting is ideal for simple in-game logic flow and sequencing of actions. It is a great system for designers, artists, and visually-oriented programmers, because it is easy to access and control in-game objects visually. You can even create small standalone-game using just Blueprints; see the Tappy Chicken sample for a full-fledged example.
蓝图的可视化编程是针对于简单的游戏逻辑流和动作顺序的。它对设计者、艺术家和视觉导向的程序猿来说，是一种友好的系统，以为它能够通过可视化的方式来控制游戏对象。你甚至能够仅仅用蓝图就开发独立游戏；能够參考Tappy Chicken案例。

C++ programming is for larger-scale tasks, such as building gameplay systems, complex AI, and new engine features. If you already have some C++ experience, check out the Introduction to C++ Programming in UE4 page.
C++编程用来处理大规模任务，比方创建游戏系统、复杂AI和新的引擎特性。假设你有点C++经验，參考一下 Introduction to C++ Programming in UE4 。

Most projects will use a mix of Blueprints and C++. Many developers prototype game functionality using Blueprints, because it is so easy and fun, and later move some or all of it to C++ for performance and engineering rigor.
大多数项目会混合使用蓝图和C++。很多开发人员使用蓝图制作游戏原型，由于它简单又有趣。然后出于性能和project严谨方面的考虑，将部分或所有移植到C++上。

Blueprint Classes can extend C++ Classes （蓝图能够扩展C++类）

Much of the magic of UE4 game development comes from the interplay between programmers implementing new features in C++, with designers and artists utilizing them in Blueprints and then asking for more! Here's how a team might structure a UE4-based shooter game implementing pickups using a mix of C++ Classes systems programming, and Blueprint Classes for behavior and appearance:
UE4开发游戏的巨大魔力来自于程序员使用C++实现新功能、设计者和艺术家使用蓝图，以及其它之间的相互作用。以下展示了一个团队怎样针对行为和外在效果，使用C++和蓝图混合编程实现pickup功能。来架构射击游戏。

image alt text

Transform Components（Transform组件）（PS:不知道翻译成变换组建好不好）

In Unity each GameObject has a Transform component, which gives the GameObject a position, rotation, and scale in the world.
Unity中每一个GameObject都有一个Transform组件，它为GameObject提供了在世界中的位置、旋转和比例信息。

Similarly in UE4, Actors have a Root Component, which can be any subclass of Scene Component. A Scene Component gives the Actor a location, rotation, and scale in the world which is applied hierarchically to all components underneath it. Many of the components that you will use are subclassed from Scene Component, because it is really useful to have a position!
类似的在UE4种，Actor有一个Root Component，它能够是Scene Component的随意子类。 Scene Component为Actor在世界中提供了位置、旋转和比例，并逐层应用于Actor下的全部组件。

你会用到的组件，大部分是Scenne Component的子类，由于拥有位置信息十分实用。

Even if you place an Empty Actor, UE4 will create a "Default Scene Root" for that Actor, which is just a plain Scene Component. If you drop a new Scene component in of your own, it will replace the Default Scene Root.
即使你放置了一个Empty Actor。UE4也会为其创建一个"Default Scene Root" ，它也是一个简单的Scene Component。

假设你你自己加入了一个写的Scene Component。他会替代掉Default Scene Root。

Compound Objects （复合对象）

In Unity, you create compound objects by constructing a hierarchy of GameObjects and parenting their transforms together:
在Unity中。你通过构造Gameobject层级建立Transform的父子关系来创建复合对象。

image alt text

In UE4, you create compound game objects by nesting components hierarchically:
在UE4中。我们能够通过嵌套组件的层级关系来创建复合对象。

image alt text

As you can see from the diagram, nested hierarchies can be created by attaching Scene Components to one another, since they have a transform - similar to parenting transforms in Unity. Actor Components (the base-class for all components) can only be attached directly to the Actor itself.
从图表中你能够看到，能够通过依附还有一个Scene Component来嵌套层级关系，由于它们有类似Unity中父子变换关系的transform。Actor组件（最基础的组件）能够能够直接依附到Actor本身上。

Do I build everything out of Components? （我是使用组件来构建不论什么东西吗？）

Its really up to you, but most often you will use a combination of custom component types along with Actor classes that use those components. We mentioned this earlier, but UE4 has many special types of Actors that guarantee a certain level of capability and always include certain components. For example, a Character always contains a Character Movement Component.
这取决于你，可是多数情况下。你会结合使用自己定义的组件类型和使用这些组件的Actor类。早先我么提到过，可是UE4有非常多特定类型的Actor,它们保证了所需的功能并包括了所需的组件。比如，Character包括了Character Movement Component。

There are several sub-classed Actor types you will quickly encounter in the engine and are useful in almost every type of game. Here is a list of our most common built-in Actors:
在UE4中你非常快就会遇到一些Actor的子类，他们不管在什么类型的游戏中都是非常重要的。下面列出了常见的Actor.

Pawn - A type of Actor representing a controllable game object, typically the player's avatar. Pawns are moved by Players and AI alike through an owning Controller.
Character - A more specialized version of Pawn designed for biped avatars that handle a lot of the complexity of those kinds of game objects.
Controller - Possesses and controls a Pawn. By separating the Pawn from the controller, you can write AI Controllers that can manipulate a pawn using the same interface the player would.
Player Controller - A more specialized Controller designed for getting input from a player's Gamepad, Touch, or Mouse/Keyboard, and using that input to drive the Pawn or Character they possess.

Pawn - 代表可被控制的游戏对象，通常被觉得是玩家的化身。
Pawn通过Player或AI Controller来控制移动。
Character - 它是Pawn的扩展,专门针对两足动物及处理这类对象的复杂关系。

Controller - 拥有并控制一个Pawn.为了差别Pawn和controller，你能够写个AI Controller来草种Pawn使用与Player同样的接口。
Player Controller - 它是一种特殊的Controller。用来接收来自玩家的游戏手柄、触摸、或者鼠标\键盘的输入。并用这些输入来驱动它们所占有的Pawn或者Character。

So is everything an Actor?

（全部的东西都是Actor?）

Not everything. Actors are most common class used for gameplay in UE4 and the only type that can be Spawned into the World. So everything you place in your level will be an Actor.
并非这种，Actor是UE4种最常见可导进World中的类。所以。全部你能放进关卡中的东西都是Actor。

The other important type to know about is Object. Object is actually the base class of all Unreal classes, including Actor and many others. This is a much lower-level construct than Actor, but still has features that you will expect from a Unreal class, such as reflection andserialization. Object is a very basic class we use when we need to define a new type that just does not fit the mold of an Actor. For example, Actor Component is the base class for all Components, and derives from Object instead of Actor.
另外一个重要的类是Object。Obeject实际上是全部Unreal类的基类，包含 Actor 和非常多其它的东西。它被构造得比Actor低级，但还是有你须要的特性。比方反射和序列化。当我须要定义一个不符合 Actor 的类型时，Object会是我们使用的最基础的类。比如，Actor Component是全部组件的基类。却继承自Object，而不是Actor。

What is this Gameplay Framework thing in UE4? （UE4种的Gameplay Framwork 是什么？）

Okay, so this is where things get a little crazy (in sort of an awesome way.) Unity gives you a clean slate to start designing your game, and Unreal does the same. In Unity you can build everything out of basic GameObjects and components, and in Unreal you can build everything out of Actors and components.
不错。事情開始有点有趣了（通过一个非常棒的方式）。

Unity和Urenal都是给你一张白纸来设计你的游戏。在Unity中，你能够通过GameObject和组件来构建全部东西，而在UE4中你则通过 Actor 和组件来创建事物。

However Unreal has this extra layer on top called the Gameplay Framework. This does not really exist in Unity at all. You do not have to use it in Unreal, but it is actually super cool! Basically, if you make use of some basic primitive classes and follow certain established conventions, your game will acquire some awesome features automatically that would be otherwise very difficult to implement or retrofit (such as full multiplayer support!)
然而，UE4另外另一个叫做 Gameplay Framework的扩展层。

Unity压根就没这货。

你并不一定要在UE4中使用它，但它确实非常酷。基本上。假设你使用了非常基础的原始类并遵循既定惯例，你的游戏将会自己主动获得一下额难以实现或改造的功能（如多人联机）。

Countless awesome games have been designed on top of Unreal's Gameplay Framework, and it is worth taking some time to understand how it works. Yes, you could roll your own version of this. That is totally fine if you want to! But hundreds of awesome Unreal developers have made great use of this framework in UE4 today, so it is worth taking some time to learn.
非常多优秀的游戏都是基于Unreal的Gameplay Framework设计的，而花一点时间理解他的运作是非常有必要的。

嗯。你能够使用你自己的方法。

假设你要的话会非常好。可是，成千上万的Unreal优秀开发人员都非常好地用了这个框架，所以它确实值得花点时间去学一下。

To use the Gameplay Framework, you really just need to learn the customized built-in Actor classes included with Unreal, such as Pawn,Character, and Player Controller, and eventually learn about how Unreal replication and networking features work. For now, let us get back to the basics though.
为了使用Gameplay Framework，你必须学习Unreal所包括的自己定义的内置Actor，比方 Pawn , Character, 和 Player Controller, 甚至须要了解虚幻是怎样工作的（PS：replication在这边怎样翻译？）。

如今，让我们回到基础部分。

How to write code in UE4 （在UE4中怎样写代码）

So, I'm used to programming in MonoDevelop （哥习惯了在Unity的Monodevelop中编程）

For Blueprint scripting, you will only need Unreal Editor -- everything is built in! To write code in C++, download the free version of Visual Studio on Windows, or install Xcode on Mac. When you first create a new project (or add code to an existing project), UE4 will automatically create Visual Studio project files for you. You can open Visual Studio by double-clicking on a C++ class inside Content Browser, or by clicking the "Open Visual Studio" button in the main File menu.
对于蓝图编程。你仅仅须要Unreal编辑器 —— 全部东西已被内置。

对于C++代码。下载free version of Visual Studio 到 Window上，或者安装 install Xcode 到mac上。首次创建新项目（或加入代码到已有项目）。UE4会自己主动为你创建VSproject。

你仅仅须要双击Content Browser中的C++文件就能够打开VS了，后者点击File菜单中的 "Open Visual Studio" 。

image alt text

One important difference in UE4: You will sometimes have to manually refresh your Visual Studio project files (for example, after downloading a new version of UE4, or when manually making changes to source file locations on disk.) You can do this by clicking "Refresh Visual Studio Project" in the main menu, or by right-clicking on the .uproject file in your project's directory and selecting "Generate Visual Studio project files"
在UE4有一点不同的是：有时候你须要手动更新你的VS项目文件（比如，下载了新版本号的UE4，或者手动改变了源文件的路径）。你能够点击主菜单中的"Refresh Visual Studio Project" ，或者右键项目文件夹下的.uproject文件选择"Generate Visual Studio project files"。

image alt text

Writing Event Functions (Start, Update, etc.) （编写事件方法（Start、Update 等等））

If you are used to working with MonoBehaviors you are used to such methods as Start, Update, and OnDestroy. Here is a comparison between a Unity behavior and its counterpart in UE4 Actors and components.
假设你习惯了Monobehaviors。你也就习惯了Start() 、update() 、Ondestroy() 这些方法。以下是 Unity 和Unreal 相应术语的一个比較。

In Unity, we might have a simple component that looks like this:
在Unity中。一个简单的组件看起来会是这种：

public class MyComponent : MonoBehaviour
{
    void Start() {}
    void OnDestroy() {}
    void Update() {}
}

But remember, in UE4 you can write code right on the Actor itself rather than only coding new component types. This is actually very common and useful.
但请记住。在UE4种，你能够直接摘Actor本身上写代码，而不是写新的组件类型。这是非常重要的。

Similar to Unity's Start, OnDestroy, and Update functions, we have a similar set of methods for Actors in UE4:
类似于 Unity 的Start() 、update() 、Ondestroy() 方法，我们在UE4种也有对应的方法。

C++ :

UCLASS()
class AMyActor : public AActor
{
    GENERATED_BODY()

    // Called at start of game.
    void BeginPlay();

    // Called when destroyed.
    void EndPlay(const EEndPlayReason::Type EndPlayReason);

    // Called every frame to update this actor.
    void Tick(float DeltaSeconds);
};

Blueprint :

Components in UE4 contain different functions. Here is a simple example:
UE4种的组件包括了不同的方法。以下是一个简单的样例。

C++ :

UCLASS()
class UMyComponent : public UActorComponent
{
    GENERATED_BODY()

    // Called after the owning Actor was created
    void InitializeComponent();

    // Called when the component or the owning Actor is being destroyed
    void UninitializeComponent();

    // Component version of Tick
    void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction);
};

Blueprint :

Remember, in UE4 it is important to call the parent class' version of method.
记住，在UE4种调用基类的方法是非常重要的。

For example, in Unity C# this would be called base.Update(), but in UE4 C++ we will use Super::TickComponent():
比如，在Unity中的C#会调用 base.Update() 。可是UE4种的C++会使用 Super::TickComponent():

void UMyComponent::TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
{
    // Custom tick stuff here
    Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
}

You may have noticed some things begin with "A" and others with "U" in C++. The prefix "A" indicates an Actor sub-class. Where as the prefix "U" indicates an Object sub-class. There are some other prefixes too, for example "F" is used for most plain data structures or non-UObject classes.
你可能会注意到C++中诸如 “A” 和 “U” 的前缀。前缀 “A” 表示Actor的子类。前缀 “U” 表示 Object的紫了。

这里还有其它前缀。比方 “F” 便是简单的数据结构或者不是 UObject 的其它类。

Writing gameplay code in UE4 （在UE4中编写游戏代码）

Okay, things are going to get a bit deeper from here on out. We will be talking about programming topics that are critical for creating games. Because you know Unity, we will be explaining features with slant toward C# users learning Unreal C++, but you can use Blueprint Scripting for pretty much everything if you want! We have added examples in both C++ and Blueprint where possible.
嗯。从这里開始要更加深入了。

我们将讨论对创建游戏至关重要的编程话题。因为你了解Unity，我们偏向学习 Unreal C++ 的C#同学来解释这些特性。但你能够使用蓝图来创建你想要的一切。可能的话。我们会加入既有C++又有蓝图的样例。

Let us talk about some of the most common gameplay programming patterns and how you would approach them in Unreal. Many functions in Unity have a comparable function in Unreal that should seem familiar. We will go through the most common functions one by one.
让我们来讨论最经常使用的游戏编程模式以及在Unreal中怎样使用它们。很多Unity的方法在Unreal中都能够找相应的方法。

我们会一个个地过一下这些常见方法。

Instantiating GameObject / Spawning Actor （实例化 GameObject / 生成 Actor）

In Unity, we use the Instantiate function to create new instances of objects.
在Unity中，我们使用 Instantiate 方法来实例化对象

This function takes any UnityEngine.Object type (GameObject, MonoBehaviour, etc.), and makes a copy of it.
这种方法适用于全部的 UnityEngine.Object 类型（GameObject, MonoBehaviour,等等），并对事实上现复制功能。

public GameObject EnemyPrefab;
public Vector3 SpawnPosition;
public Quaternion SpawnRotation;

void Start()
{
    GameObject NewGO = (GameObject)Instantiate(EnemyPrefab, SpawnPosition, SpawnRotation);
    NewGO.name = "MyNewGameObject";
}

In UE4, there are a couple different functions to instantiate objects, depending on your needs. NewObject is used for creating new UObject types, and SpawnActor is used for spawning AActor types.
在UE4中，有几个不同的方法能够实例化对象，这取决于你所须要的。

NewObject 用于创建新的 UObject类型， SpawnActor 用于创建类型 AActor 。

First we will briefly talk about UObjects and NewObject. Subclassing UObject in Unreal is much like subclassing ScriptableObject in Unity. They are useful for gameplay classes that do not need to spawn into the world or have attached components like Actors do.
首先，我们须要简单说明下 UObjects 和 NewObjec 。Unreal 子类化 UObject 类似于 Unity 子类化 ScriptableObject。它们对于不须要生成到世界中或者依附类似Actor组件的游戏类非常实用。

In Unity, if you created your own subclass of ScriptableObject, you may instantiate it like this:
在 Unity 中，假设你创建了自己的ScriptableObject子类，你可能须要这样来实例化：

MyScriptableObject NewSO = ScriptableObject.CreateInstance<MyScriptableObject>();

And in Unreal, if you created your own UObject derived type, you may instantiate it like this:
而在UE4种。假设你想要创建自己的 UObject 派生类，你会这样实例化：

UMyObject* NewObj = NewObject<UMyObject>();

So what about Actors? Actors are spawned using the SpawnActor method on a World (UWorld in C++) object. How do you get the World object?

Some UObjects provide a GetWorld method for you, as an example, all Actors do.
那对于 Actor 来说呢？Actor 是使用 SpawnActor 方法生成 World 对象的（C++ 中的 Uworld）。你是怎样获得 World 对象的。一些 UObject 提供了GetWorld 方法，比方全部 Actor 都提供了这种方法。

You will notice instead of passing in another Actor, we pass in the "class" of the Actor we want to spawn. In our example, the class can be any subclass of AMyEnemy.
你会发现我们是通过 Actor 的类而不是还有一个 Actor 来生成的。在我们的样例中。这个类能够是不论什么 AMyEnemy 的子类。

But what if you want to make a "copy" of another object, like what Instantiate allows you to do?

可是假设你想像 Instantiate 那样来获得还有一个对象的复制体呢？

The NewObject and SpawnActor functions can also be given a "template" object to work with. Unreal will make a copy of that object, instead of making one "from scratch". This will copy over all of its UPROPERTYs and components.
NewObject 和 SpawnActor 方法都提供了一个 “模板”。UE4会直接复制对象。而不是从头開始建一个。这样拷贝他全部的 UPROPERTY 和组件。

AMyActor* CreateCloneOfMyActor(AMyActor* ExistingActor, FVector SpawnLocation, FRotator SpawnRotation)
{
    UWorld* World = ExistingActor->GetWorld();
    FActorSpawnParameters SpawnParams;
    SpawnParams.Template = ExistingActor;
    World->SpawnActor<AMyActor>(ExistingActor->GetClass(), SpawnLocation, SpawnRotation, SpawnParams);
}

You might be wondering what "from scratch" means in this context. Each object class you create has a default template that contain default values for its properties and components. If you do not override these properties and do not provide your own template, Unreal will use these default values to construct your object. To help illustrate this, let us first look at a MonoBehaviour for example:
你可能会对文中的 “从头開始” 不是非常理解。你创建的每一个对象类都用一个默认的模板，它包括了物体属性和组件的默认值。假设你不重写这些属性，也不提供你自己的模板，UE4将会使用这些默认值来构建你的对象。为了帮助理解，让我们先看看Monobehavia的样例吧。

public class MyComponent : MonoBehaviour
{
    public int MyIntProp = 42;
    public SphereCollider MyCollisionComp = null;

    void Start()
    {
        // Create the collision component if we don't already have one
        if (MyCollisionComp == null)
        {
            MyCollisionComp = gameObject.AddComponent<SphereCollider>();
            MyCollisionComp.center = Vector3.zero;
            MyCollisionComp.radius = 20.0f;
        }
    }
}

In the above example, we have an int property that defaults to 42, and a SphereCollider component that defaults to a radius of 20.
在上面的样例中，我们有一个默认值为42的整型属性，和一个默认半径为20的 SphereCollider 组件。

We can achieve the same thing in Unreal using the object's constructor.
我们能够在UE4种使用对象的构造函数老实现一样的功能。

UCLASS()
class AMyActor : public AActor
{
    GENERATED_BODY()

    UPROPERTY()
    int32 MyIntProp;

    UPROPERTY()
    USphereComponent* MyCollisionComp;

    AMyActor()
    {
        MyIntProp = 42;

        MyCollisionComp = CreateDefaultSubobject<USphereComponent>(FName(TEXT("CollisionComponent"));
        MyCollisionComp->RelativeLocation = FVector::ZeroVector;
        MyCollisionComp->SphereRadius = 20.0f;
    }
};

In the constructor of AMyActor, we have set the default property values for the class. Note the use of the CreateDefaultSubobject function. We can use it to create components and assign default properties to them. All the subobjects we create using this function act as a default template, so we can modify them in a subclass or Blueprint.
在 AmyActor 的构造函数中，我们为类设置了默认的属性值。注意 CreateDefaultSubobject 方法的使用。

我们能够使用它来创建组件。并为其指定默认属性。我们使用这种方法创建的子对象就是一个默认模板。因此我们能够在子类或蓝图中改动它们。

Casting from one Type to Another （类型转换）

In this case, we get a component we know we have, then cast it to a specific type and conditionally do something.
在这个样例中，我们获取了一个已知的组件。然后将其转换到特定类型去处理一些事情。

Unity C#:

Collider collider = gameObject.GetComponent<Collider>;
SphereCollider sphereCollider = collider as SphereCollider;
if (sphereCollider != null)
{
        // ...
}

UE4 C++:

UPrimitiveComponent* Primitive = MyActor->GetComponentByClass(UPrimitiveComponent::StaticClass());
USphereComponent* SphereCollider = Cast<USphereComponent>(Primitive);
if (SphereCollider != nullptr)
{
        // ...
}

Destroying GameObject / Actor （销毁GameObject / Actor）


Unity	C++	Blueprint
`Destroy(MyGameObject);`	`MyActor->Destroy();`

Destroying GameObject / Actor (With 1 Second Delay) （延时1s销毁GameObject / Actor）


Unity	C++	Blueprint
`Destroy(MyGameObject, 1);`	`MyActor->SetLifeSpan(1);`	Click for full view.

Disabling GameObjects / Actors （禁用 GameObject / Actor）

Unity C++ Blueprint

Unity	C++	Blueprint
`MyGameObject.SetActive(false);`	`// Hides visible components MyActor->SetActorHiddenInGame(true); // Disables collision components MyActor->SetActorEnableCollision(false); // Stops the Actor from ticking MyActor->SetActorTickEnabled(false);`	Click for full view.

MyGameObject.SetActive(false);

// Hides visible components
MyActor->SetActorHiddenInGame(true);

// Disables collision components
MyActor->SetActorEnableCollision(false);

// Stops the Actor from ticking
MyActor->SetActorTickEnabled(false);

Click for full view.

Accessing the GameObject / Actor from Component （通过组件訪问 GameObject / Actor）


Unity	C++	Blueprint
`GameObject ParentGO = MyComponent.gameObject;`	`AActor* ParentActor = MyComponent->GetOwner();`	Click for full view.

Accessing a Component from the GameObject / Actor （通过 GameObject / Actor 訪问组件）

Unity

MyComponent MyComp = gameObject.GetComponent<MyComponent>();

C++

UMyComponent* MyComp = MyActor->FindComponentByClass<UMyComponent>();

Blueprint

Finding GameObjects / Actors （搜索 GameObject / Actors）

//C# 
// Find GameObject by name 通过名字
GameObject MyGO = GameObject.Find("MyNamedGameObject");

// Find Objects by type  通过类型
MyComponent[] Components = Object.FindObjectsOfType(typeof(MyComponent)) as MyComponent[];
foreach (MyComponent Component in Components)
{
        // ...
}

// Find GameObjects by tag 通过标签
GameObject[] GameObjects = GameObject.FindGameObjectsWithTag("MyTag");
foreach (GameObject GO in GameObjects)
{
        // ...
}
-----------------------------------------------------------------------------------------------

//C++
// Find Actor by name (also works on UObjects) 
AActor* MyActor = FindObject<AActor>(nullptr, TEXT("MyNamedActor"));

// Find Actors by type (needs a UWorld object) 
for (TActorIterator<AMyActor> It(GetWorld()); It; ++It)
{
        AMyActor* MyActor = *It;
        // ...
}

image alt text

// Find UObjects by type
for (TObjectIterator<UMyObject> It; It; ++it)
{
    UMyObject* MyObject = *It;
    // ...
}

// Find Actors by tag (also works on ActorComponents, use TObjectIterator instead)
for (TActorIterator<AActor> It(GetWorld()); It; ++It)
{
    AActor* Actor = *It;
    if (Actor->ActorHasTag(FName(TEXT("Mytag"))))
    {
        // ...
    }
}

image alt text

Adding tags to GameObjects / Actors （加入标签给 GameObject / Actors）

MyGameObject.tag = "MyTag";

// Actors can have multiple tags
MyActor.Tags.AddUnique(TEXT("MyTag"));

image alt text

Adding tags to MonoBehaviours / ActorComponents （加入标签给 MonoBehaviours / ActorComponent）

// This changes the tag on the GameObject it is attached to
MyComponent.tag = "MyTag";

// Components have their own array of tags
MyComponent.ComponentTags.AddUnique(TEXT("MyTag"));

Comparing tags on GameObjects / Actors and MonoBehaviours / ActorComponents （GameObjects / Actors 和 MonoBehaviours / ActorComponents 上的标签比較）获取 bool 值

if (MyGameObject.CompareTag("MyTag"))
{
    // ...
}

// Checks the tag on the GameObject it is attached to
if (MyComponent.CompareTag("MyTag"))
{
    // ...
}

// Checks if an Actor has this tag
if (MyActor->ActorHasTag(FName(TEXT("MyTag"))))
{
    // ...
}

image alt text

// Checks if an ActorComponent has this tag
if (MyComponent->ComponentHasTag(FName(TEXT("MyTag"))))
{
    // ...
}

image alt text

Physics: RigidBody vs. Primitive Component （物理：Rigidbody 对照 Primitive组件）

In Unity to give any GameObject physics characteristics, you first give it a RigidBody component. In Unreal, any PrimitiveComponent (UPrimitiveComponent in C++) can be a physical object. Some common Primitive Components are ShapeComponents (Capsule, Sphere, Box), StaticMeshComponent, and SkeletalMeshComponent.
在 Unity 中。你首先须要给 GameObject 加入 Rigidbody 来为其加入物理特性。在UE4种，不论什么 PrimitiveComponent 都是一个物理对象。有些 PrimitiveComponent 是ShapeComponents (胶囊、球体、立方体)，StaticMeshComponent 和 SkeletalMeshComponent。

Unlike Unity which separates the responsibilities of collision and visualizations into separate components. Unreal combines the concepts of the potentially physical and the potentially visible into PrimitiveComponent. Any component that would have any geometry in the world, that could either be rendered or interacted with physically sub-classes from PrimitiveComponent.
不同于 Unity 中将碰撞与可视化调节分开，UE4 把物理概念和可视化概念结合到了 PrimitiveComponent 上。World 中不论什么有几何形状的组件，都能够被渲染或与 PrimitiveComponent 的子类进行交互。

Layers vs Channels Unity 的 Layer 和 UE4 的 Channels

In Unity, they are called "Layers". UE4 uses Collision Channels, and they work in a similar way. You can read up on them here.
在 Unity 中叫做 “Layers”. UE4使用 Collision Channels （碰撞通道）。

它们非常相似。你能够在这里获取很多其它的信息。

RayCast vs RayTrace （射线）

Unity C#:

GameObject FindGOCameraIsLookingAt()
{
    Vector3 Start = Camera.main.transform.position;
    Vector3 Direction = Camera.main.transform.forward;
    float Distance = 100.0f;
    int LayerBitMask = 1 << LayerMask.NameToLayer("Pawn");

    RaycastHit Hit;
    bool bHit = Physics.Raycast(Start, Direction, out Hit, Distance, LayerBitMask);

    if (bHit)
    {
        return Hit.collider.gameObject;
    }

    return null;
}

UE4 C++:

APawn* AMyPlayerController::FindPawnCameraIsLookingAt()
{
    // You can use this to customize various properties about the trace
    FCollisionQueryParams Params;
    // Ignore the player's pawn
    Params.AddIgnoredActor(GetPawn());

    // The hit result gets populated by the line trace
    FHitResult Hit;

    // Raycast out from the camera, only collide with pawns (they are on the ECC_Pawn collision channel)
    FVector Start = PlayerCameraManager->GetCameraLocation();
    FVector End = Start + (PlayerCameraManager->GetCameraRotation().Vector() * 1000.0f);
    bool bHit = GetWorld()->LineTraceSingle(Hit, Start, End, ECC_Pawn, Params);

    if (bHit)
    {
        // Hit.Actor contains a weak pointer to the Actor that the trace hit
        return Cast<APawn>(Hit.Actor.Get());
    }

    return nullptr;
}

UE4 Blueprint:

Click for full view.

Triggers （触发器）

Unity C#:

public class MyComponent : MonoBehaviour
{
    void Start()
    {
        collider.isTrigger = true;
    }
    void OnTriggerEnter(Collider Other)
    {
        // ...
    }
    void OnTriggerExit(Collider Other)
    {
        // ...
    }
}

UE4 C++:

UCLASS()
class AMyActor : public AActor
{
    GENERATED_BODY()

    // My trigger component
    UPROPERTY()
    UPrimitiveComponent* Trigger;

    AMyActor()
    {
        Trigger = CreateDefaultSubobject<USphereComponent>(TEXT("TriggerCollider"));

        // Both colliders need to have this set to true for events to fire
        Trigger.bGenerateOverlapEvents = true;

        // Set the collision mode for the collider
        // This mode will only enable the collider for raycasts, sweeps, and overlaps
        Trigger.SetCollisionEnabled(ECollisionEnabled::QueryOnly);
    }

    void BeginPlay()
    {
        // Register to find out when an overlap occurs
        OnActorBeginOverlap.AddDynamic(this, &AMyActor::OnTriggerEnter);
        OnActorEndOverlap.AddDynamic(this, &AMyActor::OnTriggerExit);

        Super::BeginPlay();
    }

    void EndPlay(const EEndPlayReason::Type EndPlayReason)
    {
        OnActorBeginOverlap.RemoveDynamic(this, &AMyActor::OnTriggerEnter);
        OnActorEndOverlap.RemoveDynamic(this, &AMyActor::OnTriggerExit);

        Super:EndPlay(EndPlayReason);
    }

    UFUNCTION()
    void OnTriggerEnter(AActor* Other);

    UFUNCTION()
    void OnTriggerExit(AActor* Other);
};

UE4 Blueprint:

image alt text

You can read more about setting up collision responses here.
你能够在这里获取很多其它关于碰撞的很多其它内容。

Kinematic Rigidbodies （刚体运动学）

Unity C#:

public class MyComponent : MonoBehaviour
{
    void Start()
    {
        rigidbody.isKinimatic = true;
        rigidbody.velocity = transform.forward * 10.0f;
    }
}

In UE4, The collision component and rigidbody component are one. The base class for this is UPrimitiveComponent, which has many subclasses (USphereComponent, UCapsuleComponent, etc.) to suit your needs.
在UE4中。碰撞组件和刚体组件是同一个组件，它们的基类是 UPrimitiveComponent 。它有非常多子类(USphereComponent, UCapsuleComponent等等) 能够满足你的需求。

UE4 C++:

UCLASS()
class AMyActor : public AActor
{
    GENERATED_BODY()

    UPROPERTY()
    UPrimitiveComponent* PhysicalComp;

    AMyActor()
    {
        PhysicalComp = CreateDefaultSubobject<USphereComponent>(TEXT("CollisionAndPhysics"));
        PhysicalComp->SetSimulatePhysics(false);
        PhysicalComp->SetPhysicsLinearVelocity(GetActorRotation().Vector() * 100.0f);
    }
};

Input events （输入事件）

Unity C#:

public class MyPlayerController : MonoBehaviour
{
    void Update()
    {
        if (Input.GetButtonDown("Fire"))
        {
            // ...
        }
        float Horiz = Input.GetAxis("Horizontal");
        float Vert = Input.GetAxis("Vertical");
        // ...
    }
}

UE4 C++:

UCLASS()
class AMyPlayerController : public APlayerController
{
    GENERATED_BODY()

    void SetupInputComponent()
    {
        Super::SetupInputComponent();

        InputComponent->BindAction("Fire", IE_Pressed, this, &AMyPlayerController::HandleFireInputEvent);
        InputComponent->BindAxis("Horizontal", this, &AMyPlayerController::HandleHorizontalAxisInputEvent);
        InputComponent->BindAxis("Vertical", this, &AMyPlayerController::HandleVerticalAxisInputEvent);
    }

    void HandleFireInputEvent();
    void HandleHorizontalAxisInputEvent(float Value);
    void HandleVerticalAxisInputEvent(float Value);
};

UE4 Blueprint:

image alt text

This is what your input properties in your Project Settings might look like:
你的Project Settings中的输入属性应该是这种：

image alt text

You can read more about how to setup input here.
你能够在这里获得很多其它关于输入设置的信息。

FAQ （常见问题）

How do I load my last project automatically?

怎么自己主动载入我上次的项目？

If you are used to Unity automatically loading the last project you were working on, the same is possible in UE4. To enable, check "Always load last project on Startup" when opening a project. You can also toggle the setting at any time from the main Edit menu under Edit/Editor Preferences/Loading and Saving/Startup.
假设你习惯了 Unity 自己主动载入上次的项目。你能够在UE4打开项目的时候勾选 "Always load last project on Startup" .你也能够在 Edit/Editor Preferences/Loading and Saving/Startup 主菜单下进行设置。

Where do I set Input Bindings for my game?

在哪里为我的游戏设置输入绑定？

In Unity, you are used to using the Input Manager settings for Project to setup default bindings. In UE4 it works similarly. You will open your Project Settings then select the Input category. There, you can add various buttons (actions) and analog controls (axes). Give each control a name and default binding. Then, you can get callbacks to your game's Pawn when the input events are triggered. Check out the Input documentation page for the details.
在Unity 中，你会习惯 Input Manager settings 来设置默认绑定。在 UE4 中。你能够的打开 Project Settings 选中 Input 类别。在这里，你能够加入各种按键（actions）和模拟量控制（Axes）. 设置名称和默认绑定。然后，你能够在输入事件被触发时获取回调函数。具体资料见 Input documentation page 。

How do I change the starting scene of my project? 怎样改变我的启动场景？

You can change the startup map of your project from the project settings tab. From the main menu choose Edit/Project Settings->Maps & Modes to change the starting map.
你能够在 Edit/Project Settings->Maps & Modes 设置启动场景。

How do I run my game? 怎样执行我的游戏？

The easiest way to run your game is to click the "Play" button on the the main editor toolbar, which will run the game right inside the editor's process. If you want to run it as a standalone application, click the dropdown arrow next to "Play" and choose "Standalone Game". Finally, if you want to run on a mobile device or in a web browser, you will use the "Launch" button on the toolbar (after installing any prerequisites that are needed for that platform.)
最简单的方法是点击主编辑器工具栏上的 “Play” 。它会直接在编辑器中执行游戏。

假设你想使它独立的应用执行的话，你能够点击 “Play” 下拉菜单中的 "Standalone Game" 。

最后。假设你想要让它在移动设备或浏览器中执行，你须要使用 “Launch” 按键（在安装个平台所须要的包之后）。

What units are these? 它们使用了什么单位的？

In Unity, the primary unit of measurement is one meter. In UE4, the primary unit of measurement is one centimeter.
Unity 的主要单位是米，UE4 的主要单位是厘米。

So if you move something 1 unit (meter) in unity that is equivalent to moving something 100 units (centimeters) in UE4.
所以在 Unity 中一个单位等效于 UE4 中移动一百个单位。

If you want to move something 2 Feet in Unity that would be 0.61units (meter) and in UE4 is 61 units (centimeters).
假设你想在 Unity 中移动两尺（约0.61个单位（米））。相当于 UE4 中的61个单位。

What is with this coordinate system?

Which way is up? 坐标系是如何的？那个方向朝上？

Both Unity and UE4 use a left-handed coordinate system, but the axes are swapped around. In UE4, positive X is "forward", positive Y is "right" and positive Z is "up". This cannot be changed, so you will have to get used to it.
Unity 和 UE4 都使用了左上坐标系。可是轴向有所不同。在 UE4 中，X：向前 —— Y：向右 —— Z：向上。这无法改变，所以你须要适应它。

How do I see Log Output from my game? 怎么看我的调试日志输出信息？

In the UE4 editor, you can open the "Output Log" from the "Window -> Developer Tools" menu. You can also run your game with the "-log" command-line parameter to summon a dedicated log window alongside your game, which is really useful!
在UE4 编辑器，你能够在 "Window -> Developer Tools" 菜单打开 "Output Log" 。

你也能够通过 “-log” 命令行參数来调出一个单独的日志窗体，它很的实用。

Speaking of Log Output, where is my Debug.Log?

输出信息到 Log Output,我的 Debug.Log() 函数呢？

Logging in UE4 is highly customizable. Read up on how to log messages here.
UE4的记录是能够高度自己定义的。在这里获取很多其它信息。

How do I throw exceptions? 怎样抛出异常？

In Unity, you are used to throwing exceptions when things go wrong. UE4 does not use exception handling. Instead, use the 'check()' function to trigger a critical assertion error. You can pass in an error message. If you want to report an error but not halt the program, use 'ensure()' instead. This will log an error with a full call stack, but program execution will continue. If you had a debugger attached, both functions will break into the debugger.
在 Unity 中。你能够在错误发生的时候抛出异常。 UE4 并不使用异常处理机制。

而是使用 “ check() ” 方法来触发一个关键错误声明。你能够传递一个错误消息。假设你想报告一个错误但不停止程序。能够使用 “ ensure() ” .这将使用完整的调用栈来记录错误。可是程序将继续运行。假设你有一个附加的调试器，这两个方法都会进入调试器中。

Where is the .NET Framework? NEt Framwork 框架在哪里？

Unlike Unity, UE4 does not use the .NET framework. UE4 has its own set of container classes and libraries. Common container comparisons:
不同于 Unity 。UE4 并不使用。

NET Framwork 。UE4 有自己的容器类和库。常见的容器比較：


.Net Framework	UE4
String	FString, FText
List	TArray
Dictionary	TMap
HashSet	TSet

You can learn more about other UE4 containers here.
你能够在这里获取UE4其它容器信息。

Does Unreal automatically reload code changes? UE4会自己主动更新变化的代码吗？

Yes! You can leave the editor open while you write code. Simply kick off a compile from Visual Studio after you have finished editing code, and the editor will "hot reload" your changes automatically. You can also click the Compile button on the editor's main toolbar. That can be useful when you have the Visual Studio debugger attached.
能够。你能够在你写代码的时候让 UE4 编辑器开着。写好代码后。简单地在Visual Studio里编译，编辑器会自己主动“热更新”的已改变的代码。您也能够点击编辑器主工具栏上的 Compile button。

当你有Visual Studio调试器时，这是非常实用的。

Where to go from here 下一步该去哪儿？

Thanks for reading the guide! This was created for the Unreal community with the help of Unreal developers everywhere, and we very much appreciate any feedback and corrections you can offer. We will try to keep improving this document as we learn more about what is most helpful when transitioning to UE4!
感谢阅读本文！

这是在无处不在的虚幻开发人员的帮助下为虚幻社区创建的文档，我们很感激您提供的不论什么反馈和修正。我们会保持文档的改进。

We have many additional UE4 learning resources available!
我们有更多的UE4学习资源可用！