Blueprints — очень популярный способ создания геймплея в Unreal Engine 4. Однако если вы уже давно программируете и предпочитаете код, то вам идеально подойдёт C++. С помощью C++ можно даже вносить изменения в движок и создавать собственные плагины.

В этом туториале вы научитесь следующему:

• Создавать классы C++
• Добавлять компоненты и делать их видимыми для Blueprints
• Создавать класс Blueprint на основе класса C++
• Добавлять переменные и делать их изменяемыми из Blueprints
• Связывать привязки осей и действий с функциями
• Переопределять функции C++ в Blueprints
• Связывать событие коллизии с функцией

Стоит учесть, что это не туториал по изучению C++. Мы сосредоточимся на работе с C++ в контексте Unreal Engine.

Примечание: в этом туториале подразумевается, что вы уже знакомы с основами Unreal Engine. Если вы новичок в Unreal Engine, то сначала изучите состоящий из десяти частей туториал по Unreal Engine для начинающих.

Приступаем к работе

Если вы ещё этого не сделали, то вам понадобится установить Visual Studio. Выполните инструкции из официального руководства Epic по настройке Visual Studio для Unreal Engine 4. (Вы можете использовать альтернативные IDE, но в этом туториале применяется Visual Studio, потому что Unreal рассчитан на работу с ним.)

Затем скачайте заготовку проекта и распакуйте её. Перейдите в папку проекта и откройте CoinCollector.uproject. Если приложение попросить пересобрать модули, то нажмите Yes.


Закончив с этим, вы увидите следующую сцену:


В этом туториале мы создадим шар, который будет перемещать игрок, чтобы собрать монеты. В предыдущих туториалах мы использовали управляемых игроком персонажей с помощью Blueprints. В этом туториале мы создадим его с помощью C++.

Создание класса C++

Для создания класса C++ перейдите в Content Browser и выберите Add New\New C++ Class.


После этого откроется C++ Class Wizard. Во-первых, нужно будет выбрать, от какого класса мы будем наследовать. Поскольку класс должен быть управляемым игроком, нам понадобится Pawn. Выберите Pawn и нажмите Next.


На следующем экране можно указать имя и путь к файлам .h и .cpp. Замените Name на BasePlayer и нажмите на Create Class.


При этом будут созданы файлы и скомпилирован проект. После компиляции Unreal откроет Visual Studio. Если BasePlayer.cpp и BasePlayer.h не будут открыты, то перейдите в Solution Explorer и откройте их. Они находятся в папке Games\CoinCollector\Source\CoinCollector.


Прежде чем двигаться дальше, вам нужно узнать о системе рефлексии Unreal. Эта система управляет различными частями движка, такими как панель Details и сборка мусора. При создании класса с помощью C++ Class Wizard движок Unreal добавляет в заголовок три строки:

1. #include "TypeName.generated.h"
2. UCLASS()
3. GENERATED_BODY()

Движку Unreal нужны эти строки, чтобы класс был видим системе рефлексии. Если вам это не понятно, то не волнуйтесь. Вам достаточно только знать, что системе рефлексии позволяет делать такие вещи, как раскрытие функций и переменных Blueprints и редактору.

Вы можете также заметить, что класс называется ABasePlayer, а не BasePlayer. При создании класса типа actor Unreal ставит перед названием класса префикс A (от слова actor). Чтобы система рефлексии могла работать, ей нужно, чтобы классы имели соответствующие префиксы. Подробнее прочитать о префиксах можно в Стандарте оформления кода Epic.

Примечание: префиксы не отображаются в редакторе. Например, если вам нужно создать переменную типа ABasePlayer, то нужно искать BasePlayer.

Это всё, что вам пока нужно знать о системе рефлексии. Теперь нам нужно добавить модель игрока и камеру. Для этого нужно использовать компоненты.

Добавление компонентов

Для Pawn игрока нам нужно добавить три компонента:

1. Static Mesh: он позволит выбрать меш, являющийся моделью игрока
2. Spring Arm: этот компонент используется в качестве штатива камеры. Один конец будет прикреплён к мешу, а к другому будет прикреплена камера.
3. Camera: Unreal показывает игроку всё, что видит камера.

Во-первых, нам нужно добавить заголовки для каждого типа компонента. Откройте BasePlayer.h и добавьте над #include "BasePlayer.generated.h" следующие строки:

#include "Components/StaticMeshComponent.h"
#include "GameFramework/SpringArmComponent.h"
#include "Camera/CameraComponent.h"

Примечание: Важно добавлять файл .generated.h последним. В нашем случае директивы include должны выглядеть следующим образом:

#include "CoreMinimal.h"
#include "GameFramework/Pawn.h"
#include "Components/StaticMeshComponent.h"
#include "GameFramework/SpringArmComponent.h"
#include "Camera/CameraComponent.h"
#include "BasePlayer.generated.h"

Если он будет не последним include, то при компиляции мы получим ошибку.

Теперь нам нужно объявить переменные для каждого компонента. Добавьте после SetupPlayerInputComponent() следующие строки:

UStaticMeshComponent* Mesh;
USpringArmComponent* SpringArm;
UCameraComponent* Camera;

Использованное здесь имя будет именем компонента в редакторе. В нашем случае компоненты будут отображаться как Mesh, SpringArm и Camera.

Далее нам нужно сделать каждую переменную видимой для системы рефлексии. Для этого добавим над каждой переменной UPROPERTY(). Теперь код должен выглядеть вот так:

UPROPERTY()
UStaticMeshComponent* Mesh;

UPROPERTY()
USpringArmComponent* SpringArm;

UPROPERTY()
UCameraComponent* Camera;

Также можно добавить к UPROPERTY() описатели (specifiers). Они будут управлять поведением переменной в различных аспектах движка.

Добавьте VisibleAnywhere и BlueprintReadOnly внутри скобок каждого UPROPERTY(). Отделите каждый описатель запятой.

UPROPERTY(VisibleAnywhere, BlueprintReadOnly)

VisibleAnywhere позволит каждому компоненту быть видимым в редакторе (в том числе и в Blueprints).

BlueprintReadOnly позволит получать ссылку на компонент с помощью нодов Blueprint. Однако он не позволит нам задавать компонент. Для компонентов важно быть read-only, потому что их переменные являются указателями. Мы не хотим, чтобы пользователи задавали их, иначе они могут указать на случайное место в памяти. Стоит заметить, что BlueprintReadOnly всё-таки позволяет задавать переменные внутри компонента, и именно к такому поведению мы стремимся.

Примечание: Для переменных, не являющихся указателями (int, float, boolean и т.д.) используйте EditAnywhere и BlueprintReadWrite.

Теперь, когда у нас есть переменные для каждого компонента, нам нужно их инициализировать. Для этого необходимо создать их внутри конструктора.

Инициализация компонентов

Для создания компонентов можно использовать CreateDefaultSubobject<Type>("InternalName"). Откройте BasePlayer.cpp и добавьте в ABasePlayer() следующие строки:

Mesh = CreateDefaultSubobject<UStaticMeshComponent>("Mesh");
SpringArm = CreateDefaultSubobject<USpringArmComponent>("SpringArm");
Camera = CreateDefaultSubobject<UCameraComponent>("Camera");

Это создаст компонент каждого типа, а затем назначит их адрес в памяти переданной переменной. Аргумент-строка будет внутренним именем компонента, используемым движком (а не отображаемым именем, несмотря на то, что в нашем случае они одинаковы).

Затем нам нужно настроить иерархию (выбрать корневой компонент и так далее). Добавьте после предыдущего кода следующее:

RootComponent = Mesh;
SpringArm->SetupAttachment(Mesh);
Camera->SetupAttachment(SpringArm);

Первая строка сделает Mesh корневым компонентом. Вторая строка прикрепит SpringArm к Mesh. Наконец, третья строка прикрепит Camera к SpringArm.

После завершения кода компонентов нам нужно выполнить компиляцию. Выберите один из следующих способов компиляции:

1. В Visual Studio выберите Build\Build Solution
2. В Unreal Engine нажмите на Compile в Toolbar

Затем нам нужно указать, какой меш использовать и поворот пружинного рычага. Рекомендуется делать это в Blueprints, потому что нежелательно жёстко указывать пути к ресурсам в C++. Например, в C++ для задания статичного меша нужно сделать нечто подобное:

static ConstructorHelpers::FObjectFinder<UStaticMesh> MeshToUse(TEXT("StaticMesh'/Game/MyMesh.MyMesh");
MeshComponent->SetStaticMesh(MeshToUse.Object);

Однако в Blueprints достаточно будет просто выбрать меш из раскрывающегося списка.


Если вы переместите ресурс в другую папку, в Blueprints ничего не испортится. Однако в C++ придётся менять каждую ссылку на этот ресурс.

Чтобы задать поворот меша и пружинного рычага в Blueprints, нужно будет создать Blueprint на основании BasePlayer.

Примечание: Обычно практикуется создание базовых классов в C++ с последующим созданием подкласса Blueprint. Это упрощает изменение классов для художников и дизайнеров.

Выделение подклассов классов C++

В Unreal Engine перейдите в папку Blueprints и создайте Blueprint Class. Разверните раздел All Classes и найдите BasePlayer. Выберите BasePlayer, а затем нажмите на Select.


Переименуйте его в BP_Player, а затем откройте.

Сначала мы зададим меш. Выберите компонент Mesh и задайте для его Static Mesh значение SM_Sphere.


Затем нам нужно задать поворот и длину пружинного рычага. Наша игра будет с видом сверху, поэтому камера должна быть над игроком.

Выберите компонент SpringArm и задайте для Rotation значение (0, -50, 0). Это повернёт пружинный рычаг так, что камера будет смотреть на меш сверху вниз.


Поскольку пружинный рычаг является дочерним элементом меша, он начинает вращаться, когда начинает вращаться шар.


Чтобы исправить это, нам нужно сделать так, чтобы поворот рычага был абсолютным. Нажмите на стрелку рядом с Rotation и выберите World.


Затем задайте для Target Arm Length значение 1000. Так мы отдалим камеру на 1000 единиц от меша.


Затем нужно задать Default Pawn Class, чтобы использовать наш Pawn. Нажмите на Compile и вернитесь в редактор. Откройте World Settings и задайте для Default Pawn значение BP_Player.


Нажмите на Play, чтобы увидеть Pawn в игре.


Следующим шагом будет добавление функций игроку, чтобы он мог перемещаться.

Реализация движения

Вместо того, чтобы добавлять для движения смещение, мы будем двигаться с помощью физики! Сначала нам нужна переменная, указывающая величину прикладываемой к шару силы.

Вернитесь в Visual Studio и откройте BasePlayer.h. Добавьте после переменных компонентов следующее:

UPROPERTY(EditAnywhere, BlueprintReadWrite)
float MovementForce;

EditAnywhere позволяет изменять MovementForce в панели Details. BlueprintReadWrite позволит задавать и считывать MovementForce с помощью нодов Blueprint.

Далее нам нужно создать две функции. Одну для движения вверх-вниз, другую — для движения влево-вправо.

Создание функций движения

Добавьте под MovementForce следующие объявления функций:

void MoveUp(float Value);
void MoveRight(float Value);

Позже мы свяжем с этими функциями привязки осей. Благодаря этому привязки осей смогут передавать свой scale (поэтому функциям нужен параметр float Value).

Примечание: Если вы незнакомы с привязками осей и scale, изучите туториал про Blueprints.

Теперь нам нужно создать реализацию для каждой функции. Откройте BasePlayer.cpp добавьте в конец файла следующее:

void ABasePlayer::MoveUp(float Value)
{
	FVector ForceToAdd = FVector(1, 0, 0) * MovementForce * Value;
	Mesh->AddForce(ForceToAdd);
}

void ABasePlayer::MoveRight(float Value)
{
	FVector ForceToAdd = FVector(0, 1, 0) * MovementForce * Value;
	Mesh->AddForce(ForceToAdd);
}

MoveUp() добавляет физическую силу для Mesh по оси X. Величина силы задаётся MovementForce. Благодаря умножению результата на Value (масштаб привязки оси), меш может перемещаться в положительном или отрицательном направлениях.

MoveRight() делает то же самое, что и MoveUp(), но по оси Y.

Закончив создание функций движения, мы должны связать с ними привязки осей.

Связывание привязок осей с функциями

Ради упрощения я уже заранее создал привязки осей. Они находятся в Project Settings, в разделе Input.

Примечание: Привязки осей не обязаны иметь то же название, что и функции, с которыми мы их связываем.

Добавьте внутрь SetupPlayerInputComponent() следующий код:

InputComponent->BindAxis("MoveUp", this, &ABasePlayer::MoveUp);
InputComponent->BindAxis("MoveRight", this, &ABasePlayer::MoveRight);

Так мы свяжем привязки осей MoveUp и MoveRight с MoveUp() и MoveRight().

На этом мы закончили с функциями движения. Теперь нам нужно включить физику для компонента Mesh.

Включение физики

Добавьте внутрь ABasePlayer() следующие строки:

Mesh->SetSimulatePhysics(true);
MovementForce = 100000;

Первая строка позволит воздействовать на Mesh физическим силам. Вторая строка присваивает MovementForce значение 100000. Это значит, что при движении шару будет прибавлено 100 000 силы. По умолчанию физические объекты весят примерно 110 килограмм, так что для их перемещения потребуется много силы!

Если мы создали подкласс, некоторые свойства не изменятся, даже если мы изменим их в базовом классе. В нашем случае у BP_Player не будет включено Simulate Physics. Однако теперь во всех создаваемых подклассах оно будет включено по умолчанию.

Выполните компиляцию и вернитесь в Unreal Engine. Откройте BP_Player и выберите компонент Mesh. Затем включите Simulate Physics.


Нажмите Compile, а затем на Play. Нажимайте W, A, S и D, чтобы передвигать шар.


Далее мы объявим функцию C++, которую можно реализовать с помощью Blueprints. Это позволит дизайнерам создавать функционал без использования C++. Чтобы научиться этому, мы создадим функцию прыжка.

Создание функции прыжка

Сначала нам нужно связать привязку прыжка к функции. В этом туториале мы назначим прыжок на клавишу пробела.


Вернитесь в Visual Studio и откройте BasePlayer.h. Добавьте под MoveRight() следующие строки:

UPROPERTY(EditAnywhere, BlueprintReadWrite)
float JumpImpulse;

UFUNCTION(BlueprintImplementableEvent)
void Jump();

Первое — это переменная float с именем JumpImpulse. Мы можем использовать её при реализации прыжка. Она использует EditAnywhere, чтобы её можно было изменять в редакторе. Также в ней используется BlueprintReadWrite, чтобы мы могли считывать и записывать её с помощью нодов Blueprint.

Далее идёт функция прыжка. UFUNCTION() делает Jump() видимой для системы рефлексии. BlueprintImplementableEvent позволяет Blueprints реализовать Jump(). Если реализация отсутствует, то вызовы Jump() ни к чему не приведут.

Примечание: Если вы хотите создать в C++ реализацию по умолчанию, то используйте BlueprintNativeEvent. Ниже мы расскажем о том, как это сделать.

Так как Jump — это привязка действия, способ связывания немного отличается. Закройте BasePlayer.h и откройте BasePlayer.cpp. Добавьте внутрь SetupPlayerInputComponent() следующее:

InputComponent->BindAction("Jump", IE_Pressed, this, &ABasePlayer::Jump);

Так мы свяжем привязку Jump с Jump(). Она будет выполняться только при нажатии клавиши прыжка. Если вы хотите выполнять её при отпускании клавиши, то используйте IE_Released.

Дальше мы переопределим Jump() в Blueprints.

Переопределение функций в Blueprints

Выполните компиляцию и закройте BasePlayer.cpp. Затем вернитесь к Unreal Engine и откройте BP_Player. Перейдите в панель My Blueprints и наведите мышь на Functions, чтобы появился раскрывающийся список Override. Нажмите на него и выберите Jump. Так мы создадим Event Jump.

Примечание: Переопределение будет событием, если отсутствует возвращаемый тип. Если возвращаемый тип существует, то это будет функция.

Далее мы создадим следующую схему:


Так мы добавим Mesh импульс (JumpImpulse) по оси Z. Учтите, что в этой реализации игрок может прыгать бесконечно.

Далее нам нужно задать значение JumpImpulse. Нажмите на Class Defaults в Toolbar, а затем перейдите к панели Details. Задайте JumpImpulse значение 100000.


Нажмите на Compile, а затем закройте BP_Player. Нажмите на Play и попробуйте попрыгать с помощью клавиши пробела.


В следующем разделе мы заставим монеты исчезать при контакте с игроком.

Собирание монет

Для обработки коллизий нам нужно связать функцию с событием наложения. Для этого функция должна удовлетворять двум требованиям. Первое — функция должна иметь макрос UFUNCTION(). Второе требование — функция должна иметь правильную сигнатуру. В этом туториале мы будем использовать событие OnActorBeginOverlap. Это событие требует, чтобы у функции была следующая сигнатура:

FunctionName(AActor* OverlappedActor, AActor* OtherActor)

Вернитесь в Visual Studio и откройте BaseCoin.h. Добавьте под PlayCustomDeath() следующие строки:

UFUNCTION()
void OnOverlap(AActor* OverlappedActor, AActor* OtherActor);

После связывания OnOverlap() будет исполнятся при наложении монеты и другого актора. OverlappedActor будет монетой, а OtherActor — другой актор.

Далее нам нужно реализовать OnOverlap().

Реализация наложений

Откройте BaseCoin.cpp и добавьте в конец файла следующее:

void ABaseCoin::OnOverlap(AActor* OverlappedActor, AActor* OtherActor)
{
}

Так как мы хотим распознавать только наложения игрока, то нужно привести OtherActor к ABasePlayer. Прежде чем выполнить приведение, нам нужно добавить заголовок для ABasePlayer. Добавьте под #include "BaseCoin.h" следующее:

#include "BasePlayer.h"

Теперь нам нужно выполнить приведение. В Unreal Engine приведение можно выполнить так:

Cast<TypeToCastTo>(ObjectToCast);

Если приведение выполнено успешно, то оно вернёт указатель на ObjectToCast. Если неудачно, то оно вернёт nullptr. Проверяя результат на nullptr, мы можем определить, имел ли объект нужный тип.

Добавьте внутрь OnOverlap() следующее:

if (Cast<ABasePlayer>(OtherActor) != nullptr)
{
	Destroy();
}

Теперь, когда OnOverlap() выполняется, она будет проверять, имеет ли OtherActor тип ABasePlayer. Если это так, то она будет уничтожать монету.

Далее нам нужно привязать OnOverlap().

Связывание функции наложения

Чтобы связать функцию с событием наложения, нам нужно использовать с событием AddDynamic(). Добавьте внутрь ABaseCoin() следующее:

OnActorBeginOverlap.AddDynamic(this, &ABaseCoin::OnOverlap);

Так мы свяжем OnOverlap() с событием OnActorBeginOverlap. Это событие происходит всегда, когда актор накладывается на другого актора.

Выполните компиляцию и вернитесь в Unreal Engine. Нажмите Play и начните собирать монеты. При контакте с монетой она будет уничтожаться, что приводит к её исчезновению.

Примечание: Если монеты не исчезают, попробуйте перезапустить редактор, чтобы выполнить полную рекомпиляцию. Для работы некоторых изменений требуется перезапуск.

В следующем разделе мы создадим ещё одну переопределяемую функцию C++. Однако на этот раз мы также создадим реализацию по умолчанию. Для демонстрации этого мы воспользуемся OnOverlap().

Создание реализации функции по умолчанию

Чтобы создать функцию с реализацией по умолчанию, нужно использовать описатель BlueprintNativeEvent. Вернитесь в Visual Studio и откройте BaseCoin.h. Добавьте для OnOverlap()
в UFUNCTION() BlueprintNativeEvent:

UFUNCTION(BlueprintNativeEvent)
void OnOverlap(AActor* OverlappedActor, AActor* OtherActor);

Чтобы сделать функцию реализацией по умолчанию, нам нужно добавить суффикс _Implementation. Откройте BaseCoin.cpp и замените OnOverlap на OnOverlap_Implementation:

void ABaseCoin::OnOverlap_Implementation(AActor* OverlappedActor, AActor* OtherActor)

Теперь если дочерний Blueprint не реализует OnOverlap(), то будет использована эта реализация.

Следующим этапом будет реализация OnOverlap() в BP_Coin.

Создание реализации в Blueprint

Для реализации в Blueprint мы будем вызывать PlayCustomDeath(). Эта функция C++ увеличит скорость вращения монеты. Через 0,5 секунды монета будет себя уничтожать.

Для вызова функции C++ из Blueprints нам нужно использовать описатель BlueprintCallable. Закройте BaseCoin.cpp и откройте BaseCoin.h. Добавьте над PlayCustomDeath() следующее:

UFUNCTION(BlueprintCallable)

Выполните компиляцию и закройте Visual Studio. Вернитесь к Unreal Engine и откройте BP_Coin. Переопределите On Overlap и создайте следующую схему:


Теперь при наложении игрока на монету будет выполняться Play Custom Death.

Нажмите на Compile и закройте BP_Coin. Нажмите Play и соберите несколько монет, чтобы протестировать новую реализацию.

Куда двигаться дальше?

Вы можете скачать готовый проект отсюда.

Как вы видите, работать с C++ в Unreal Engine довольно просто. Хотя мы уже добились кое-чего в C++, вам ещё нужно многому научиться! Я рекомендую изучить серию туториалов Epic по созданию с помощью C++ шутера с видом сверху.

Если вы новичок в Unreal Engine, то изучите нашу серию туториалов для начинающих из десяти частей. В этой серии вы познакомитесь с различными системами, такими как Blueprints, материалы и системы частиц.