Написание игровой логики, триггеры, ввод, рейкастинг и другое.

Специально для тех, кто ищет альтернативу Unreal Engine или Unity, мы продолжаем цикл статей про безболезненный переход на UNIGINE с зарубежных движков. В третьем выпуске рассмотрим миграцию с Unreal Engine 4 с точки зрения программиста.

Общая информация

Игровая логика в проекте на Unreal Engine 4 реализуется с помощью классов C++ или Blueprint Visual Scripting — встроенной системы визуального нодового программирования. Редактор Unreal Engine 4 позволяет создавать классы при помощи встроенного мастера классов (Class Wizard), выбрав нужный базовый тип.

В UNIGINE вы можете создавать проекты, используя C++ и C# API. При создании проекта просто выберите желаемое API и систему сборки:

В данной статье в основном затронем программирование на C++, т.к. полноценное программирование в Unreal Engine 4 возможно именно на этом языке.

Для C++ на выбор представлены готовые шаблоны проектов для следующих систем сборки:

• Windows:

  • Visual Studio 2015+;

  • CMake;

  • Qt-based: Qt Creator, QMake или CMake (доступно для Engineering и Sim редакций SDK);

• Linux:

  • GNU Make.

Далее просто выберите Open Code IDE, чтобы перейти к разработке логики в выбранной IDE для C++ проектов:

В Unreal Engine 4 достаточно унаследовать класс от базовых типов Game Framework, таких как AActor, APawn, ACharacter и т.п., чтобы переопределить их поведение в стандартных методах BeginPlay(), Tick() и EndPlay() и получить пользовательский actor.

Компонентный подход подразумевает, что логика реализуется в пользовательских компонентах, назначаемых на actor’ы — классах, унаследованных от UActorComponent и других компонентов, расширяющих стандартное поведение, определенное в методах InitializeComponent() и TickComponent().

В UNIGINE стандартный подход подразумевает, что логика приложения состоит из трех основных компонентов с разным циклом жизни:

• Системная логика (исходный файл AppSystemLogic.cpp) существует в течение жизненного цикла приложения.

• Логика мира (исходный файл AppWorldLogic.cpp) выполняется только когда мир загружен.

• Логика редактора (исходный файл AppEditorLogic.cpp) выполняется только во время работы  пользовательского редактора.

У каждой логики есть стандартные методы, вызываемые в основном цикле движка. К примеру, можно использовать следующие методы логики мира:

• init() - для инициализации ресурсов при загрузке мира;

• update() - для обновления каждый кадр;

• shutdown() - для уничтожения использованных ресурсов при закрытии мира;

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

Компонентный подход также доступен в UNIGINE при помощи встроенной компонентной системы. Логика компонента определяется в классе, производном от ComponentBase, на основе которого движок сгенерирует набор параметров компонента — Property, которые можно назначить любой ноде в редакторе. Каждый компонент также имеет набор методов, которые вызываются соответствующими функциями основного цикла движка.

Для примера создания простой игры с использованием компонентной системы, обратитесь к серии статей «Краткое руководство по программированию».

Сравним, как создаются простые компоненты в обоих движках. Заголовочный файл компонента в Unreal Engine 4 будет выглядеть примерно так:

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

public:
    UPROPERTY(EditAnywhere)
    int32 TotalDamage;


    // 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);
};

И в UNIGINE. Компонентную систему сперва необходимо инициализировать в системной логике (AppSystemLogic.cpp):

/* .. */
#include <UnigineComponentSystem.h>

/* .. */

int AppSystemLogic::init()
{
    Unigine::ComponentSystem::get()->initialize();
    return 1;
}

И тогда можно написать новый компонент:

MyComponent.h:

#pragma once
#include <Unigine.h>
#include <UnigineComponentSystem.h>

using namespace Unigine;
class MyComponent : public ComponentBase
{
public:
    // объявление компонента MyComponent
    COMPONENT(MyComponent, ComponentBase);

    // объявление методов, вызываемых на определенных этапах цикла жизни компонента
    COMPONENT_INIT(init);
    COMPONENT_UPDATE(update);
    COMPONENT_SHUTDOWN(shutdown);

    // объявление параметра компонента, который будет доступен в редакторе
    PROP_PARAM(Float, speed, 30.0f);

    // определение имени Property, которое будет сгенерировано и ассоциировано с компонентом
    PROP_NAME("my_component");
protected:
    void init();
    void update();
    void shutdown();
};

MyComponent.cpp:

#include "MyComponent.h"

// регистрация компонента MyComponent
REGISTER_COMPONENT(MyComponent);

// вызов будет произведен при инициализации компонента
void MyComponent::init(){}

// будет вызван каждый кадр
void MyComponent::update(){}

// будет вызван при уничтожении компонента или ноды, которой он назначен
void MyComponent::shutdown(){}

Теперь необходимо сгенерировать property для нашего компонента. Для этого:

1. Соберите приложение с помощью IDE.

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

3. Перейдите в редактор и назначьте сгенерированное property ноде.

4. Наконец, работу логики компонента можно проверить, запустив приложение.

Чтобы узнать больше о последовательности выполнения и о том, как создавать компоненты, перейдите по ссылкам ниже:

• Последовательность выполнения.

• Использование C++ Component System.

Немного про API

Все объекты в Unreal Engine 4 наследуются от UObject, доступ к ним возможен при помощи стандартных C++ указателей или умных указателей Unreal Smart Pointer Library.

В UNIGINE API есть система умных указателей, управляющих существованием нод и других объектов в памяти:

// создать ноду типа NodeType
<NodeType>Ptr nodename = <NodeType>::create(<construction_parameters>);
// удалить ноду из мира
nodename.deleteLater();

К примеру, вот как выглядит создание меша из ассета, редактирование, присвоение новой ноде типа ObjectMeshStatic и удаление:

    MeshPtr mesh = Mesh::create();
    mesh->load("fbx/model.fbx/model.mesh");
    mesh->addBoxSurface("box_surface", Math::vec3(0.5f, 0.5f, 0.5f));
    ObjectMeshStaticPtr my_object = ObjectMeshStatic::create(mesh);
    my_object.deleteLater();
    mesh.clear();

Экземпляры пользовательских компонентов, как и любых других классов, хранятся при помощи стандартных указателей:

MyComponent *my_component = getComponent<MyComponent>(node);

Типы данных

UNIGINE поддерживает как одинарную точность (Float), так и двойную точность координат (Double), доступную в зависимости от редакции SDK. Почитайте про использование универсальных типов данных, подходящих под любой проект.

Основные примеры кода

Вывод в консоль

См. также:

• Дополнительные типы сообщений в API класса Log.

Загрузка сцены

Доступ к Actor / Node из компонента

См. также:

• Видеоруководство, демонстрирующее, как получить доступ к нодам из компонентов с помощью C++ Component System.

Доступ к компоненту из Actor / Node

Unreal Engine 4:

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

UNIGINE:

MyComponent *my_component = getComponent<MyComponent>(node);

Работа с направлениями

В Unreal Engine 4 компонент USceneComponent (или производный) отвечает за действия с трансформацией actor’а. Чтобы получить вектор направления по одной из осей с учетом ориентации в мировых координатах, можно использовать соответствующие методы USceneComponent (GetForwardVector()) или AActor (GetActorForwardVector()).

В UNIGINE трансформация ноды в пространстве представлена ее матрицей трансформации (mat4), а все основные операции с трансформацией или иерархией нод доступны при помощи методов класса Node. Такой же вектор направления в UNIGINE получается с помощью метода Node::getWorldDirection():

См. также:

• Система координат в UNIGINE.

Более плавный игровой процесс с DeltaTime / IFps

В Unreal Engine 4, чтобы гарантировать, что определенные действия выполняются за одно и то же время независимо от частоты кадров (например, изменение положения один раз в секунду и т. д.), используется множитель deltaTime (время в секундах, которое потребовалось для завершения последнего кадра), передаваемый методу Tick(float deltaTime). То же самое в UNIGINE называется Game::getIFps():

Рисование отладочных данных

Unreal Engine 4:

DrawDebugLine(GetWorld(), traceStart, traceEnd, FColor::Green, true, 1.0f);

В UNIGINE за вспомогательную отрисовку отвечает синглтон Visualizer:

// включаем вспомогательную визуализацию
Visualizer::setEnabled(true);

/*..*/

Visualizer::renderLine3D(vec3_zero, vec3(5, 0, 0), vec4_one);
Visualizer::renderVector(node->getPosition(), node->getDirection(Math::AXIS_Y) * 10, vec4(1, 0, 0, 1));

Примечание. Visualizer также можно включить с помощью консольной команды show_visualizer 1.

См. также:

• Все типы визуализаций в API класса Visualizer.

Поиск Actor / Node

Unreal Engine 4:

// поиск Actor или UObject по имени
AActor* MyActor = FindObject<AActor>(nullptr, TEXT("MyNamedActor"));

// Поиск Actor по типу
for (TActorIterator<AMyActor> It(GetWorld()); It; ++It)
{
    AMyActor* MyActor = *It;
    // ...
}

UNIGINE:

// поиск Node по имени
NodePtr my_node = World::getNodeByName("my_node");

// поиск всех нод с данным именем
Vector<NodePtr> nodes;
World::getNodesByName("test", nodes);

// получение прямого потомка ноды
int index = node->findChild("child_node");
NodePtr direct_child = node->getChild(index);

// Рекурсивный поиск ноды по имени среди всех потомков в иерархии
NodePtr child = node->findNode("child_node", 1);

Приведение от типа к типу

Классы всех типов нод являются производными от Node в UNIGINE, поэтому чтобы получить доступ к функциональности ноды определенного типа (например, ObjectMeshStatic), необходимо провести понижающее приведение типа — Downcasting (приведение от базового типа к производному), которое выполняется с использованием специальных конструкций. Чтобы выполнить Upcasting (приведение от производного типа к базовому), можно как обычно просто использовать сам экземпляр:

Уничтожение Actor / Node

Для выполнения отложенного удаления ноды в UNIGINE можно создать компонент, который будет отвечать за таймер и удаление.

Создание экземпляра Actor / Node Reference

За создание нового экземпляра actor (Spawning) отвечает метод UWorld::SpawnActor():

AKAsset* SpawnedActor1 = (AKAsset*)
GetWorld()->SpawnActor(AKAsset::StaticClass(), NAME_None, &Location);

В Unreal Engine 4 клонировать существующий actor можно следующим образом:

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);
}

В UNIGINE используйте Node::clone() для клонирования ноды, существующей в мире, и World::loadNode для загрузки иерархии нод из ассета .node. В этом случае на сцену будет добавлена ​​вся иерархия нод, которая была сохранена как Node Reference. Вы можете обратиться к ассету либо через параметр компонента, либо вручную, указав виртуальный путь к нему:

// MyComponent.h
PROP_PARAM(File, node_to_spawn);

// MyComponent.cpp
/* .. */
void MyComponent::init()
{
// создание новой ноды Dummy
NodeDummyPtr dummy = NodeDummy::create();

// клонирование существующей ноды
NodePtr cloned = dummy->clone();

// загрузка иерархии нод из ассета
NodePtr spawned = World::loadNode(node_to_spawn.get());
spawned->setWorldPosition(node->getWorldPosition());

// загрузка с указанием пути в файловой системе
NodePtr spawned_manually = World::loadNode("nodes/node_reference.node");
}

Для параметра компонента также необходимо указать ассет .node в редакторе:

 

Еще один способ загрузить содержимое ассета *.node — создать NodeReference и работать с иерархией нод как с одним объектом. Тип Node Reference имеет ряд внутренних оптимизаций и тонких моментов (кэширование нод, распаковка иерархии и т.д.), поэтому важно учитывать специфику работы с этими объектами.

void MyComponent::update()
{
NodeReferencePtr nodeRef = NodeReference::create("nodes/node_reference_0.node");
}

Запуск скриптов в редакторе

Unreal Engine 4 позволяет расширять функциональность редактора с помощью Blueprint/Python скриптов.

UNIGINE не поддерживает выполнение логики приложения на C++ внутри редактора. Основной способ расширить функциональность редактора — плагины, написанные на C++.

Для быстрого тестирования или автоматизации разработки можно написать логику на UnigineScript. UnigineScript API обладает только базовой функциональностью и ограниченной сферой применения, но доступен для любого проекта на UNIGINE, включая проекты на C++.

Есть два способа добавить скриптовую логику в проект:

• Создав скрипт мира:

1. Создайте ассет скрипта .usc.

2. Определите в нем логику. При необходимости добавьте проверку, загружен ли редактор:

//Исходный код (UnigineScript)
#include <core/unigine.h>
vec3 lookAtPoint = vec3_zero;
Node node;
int init() {
    node = engine.world.getNodeByName("material_ball");
    return 1;
}
int update() {
if(engine.editor.isLoaded())
        node.worldLookAt(lookAtPoint);
    return 1;
}

3. Выделите текущий мир и укажите для него сценарий мира. Нажмите Apply и перезагрузите мир.
   

4. Проверьте окно консоли на наличие ошибок.

После этого логика скрипта будет выполняться как в редакторе, так и в приложении.

• Используя WorldExpression. С той же целью можно использовать ноду WorldExpression, выполняющую логику при добавлении в мир:

1. Нажмите Create -> Logic -> Expression и поместите новую ноду WorldExpression в мир.

2. Напишите логику на UnigineScript в поле Source:

//Исходный код (UnigineScript)
{
vec3 lookAtPoint = vec3_zero;
Node node = engine.world.getNodeByName("my_node");
node.worldLookAt(lookAtPoint);
}

3. Проверьте окно Console на наличие ошибок.

4. Логика будет выполнена немедленно.

Триггеры

Unreal Engine 4:

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

// компонент триггера
UPROPERTY()
UPrimitiveComponent* Trigger;

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

    Trigger.bGenerateOverlapEvents = true;
    Trigger.SetCollisionEnabled(ECollisionEnabled::QueryOnly);
}

virtual void NotifyActorBeginOverlap(AActor* Other) override;

virtual void NotifyActorEndOverlap(AActor* Other) override;
};

В UNIGINE Trigger — это специальный тип нод, вызывающих события в определенных ситуациях:

• NodeTrigger вызывает коллбэк при изменении состояния включен/выключен и позиции самой ноды.

• WorldTrigger вызывает коллбэк, когда какая-либо нода (независимо от типа) попадает внутрь или за его пределы.

• PhysicalTrigger вызывает коллбэк, когда физические объекты попадают внутрь или за его пределы.

Важно! PhysicalTrigger не обрабатывает события столкновения, для этого тела и сочленения предоставляют свои собственные события.

WorldTriger — наиболее распространенный тип триггера, который можно использовать в игровой логике:

WorldTriggerPtr trigger;
int enter_callback_id;
                
// коллбэк при попадании внутрь объема триггера
void AppWorldLogic::enter_callback(NodePtr node){
    Log::message("\nA node named %s has entered the trigger\n", node->getName());
}
                
// implement the leave callback
void AppWorldLogic::leave_callback(NodePtr node){
    Log::message("\nA node named %s has left the trigger\n", node->getName());
}
                
int AppWorldLogic::init() {
    // создание WorldTrigger ноды
    trigger = WorldTrigger::create(Math::vec3(3.0f));
                
    // подписка на событие попадания ноды внутрь объема триггера
    // и сохранение id коллбэка для будущего удаления
    enter_callback_id = trigger->addEnterCallback(MakeCallback(this, &AppWorldLogic::enter_callback));
    // подписка на событие покидания нодой объема триггера
    trigger->addLeaveCallback(MakeCallback(this, &AppWorldLogic::leave_callback));

    return 1;
}

Обработка ввода

Unreal Engine 4:

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);
};

UNIGINE:

/* .. */

#include <UnigineApp.h>
#include <UnigineConsole.h>
#include <UnigineInput.h>

/* .. */

void MyInputController::update() 
{
    // при нажатии правой кнопки мыши
    if (Input::isMouseButtonDown(Input::MOUSE_BUTTON_RIGHT))
    {
        Math::ivec2 mouse = Input::getMouseCoord();
        // сообщить координаты курсора мыши в консоль
        Log::message("Right mouse button was clicked at (%d, %d)\n", mouse.x, mouse.y);
    }
    
    // закрыть приложение при нажатии клавиши 'Q' с учетом того, открыта ли консоль
    if (Input::isKeyDown(Input::KEY_Q) && !Console::isActive())
    {
        App::exit();
    }
}

/* .. */

Также можно использовать синглтон ControlsApp для обработки привязок элементов управления к набору предустановленных состояний ввода. Чтобы настроить привязки, откройте настройки Controls в редакторе:

#include <Unigine.h>

/* .. */

void MyInputController::init() 
{
    // переназначение состояний клавишам и кнопкам вручную
    ControlsApp::setStateKey(Controls::STATE_FORWARD, App::KEY_PGUP);
    ControlsApp::setStateKey(Controls::STATE_BACKWARD, App::KEY_PGDOWN);
    ControlsApp::setStateKey(Controls::STATE_MOVE_LEFT, 'l');
    ControlsApp::setStateKey(Controls::STATE_MOVE_RIGHT, 'r');
    ControlsApp::setStateButton(Controls::STATE_JUMP, App::BUTTON_LEFT);
}

void MyInputController::update() 
{
    if (ControlsApp::clearState(Controls::STATE_FORWARD))
    {
        Log::message("FORWARD key pressed\n");
    }
    else if (ControlsApp::clearState(Controls::STATE_BACKWARD))
    {
        Log::message("BACKWARD key pressed\n");
    }
    else if (ControlsApp::clearState(Controls::STATE_MOVE_LEFT))
    {
        Log::message("MOVE_LEFT key pressed\n");
    }
    else if (ControlsApp::clearState(Controls::STATE_MOVE_RIGHT))
    {
        Log::message("MOVE_RIGHT key pressed\n");
    }
    else if (ControlsApp::clearState(Controls::STATE_JUMP))
    {
        Log::message("JUMP button pressed\n");
    }
}

/* .. */

Проверка пересечения луча с геометрией (Raycast) 

Unreal Engine 4:

APawn* AMyPlayerController::FindPawnCameraIsLookingAt()
{
FCollisionQueryParams Params;
Params.AddIgnoredActor(GetPawn());

FHitResult Hit;

FVector Start = PlayerCameraManager->GetCameraLocation();
FVector End = Start + (PlayerCameraManager->GetCameraRotation().Vector() * 1000.0f);
bool bHit = GetWorld()->LineTraceSingle(Hit, Start, End, ECC_Pawn, Params);

if (bHit)
{
    return Cast<APawn>(Hit.Actor.Get());
}

return nullptr;
}

В UNIGINE то же самое достигается с помощью Intersections:

#include "MyComponent.h"
#include <UnigineWorld.h>
#include <UnigineVisualizer.h>
#include <UnigineGame.h>
#include <UnigineInput.h>

using namespace Unigine;
using namespace Math;

REGISTER_COMPONENT(MyComponent);

void MyComponent::init()
{
    Visualizer::setEnabled(true);
}

void MyComponent::update()
{
    // получим координаты начальной и конечной точек луча
    ivec2 mouse = Input::getMouseCoord();
    float length = 100.0f;
    vec3 start = Game::getPlayer()->getWorldPosition();
    vec3 end = start + vec3(Game::getPlayer()->getDirectionFromScreen(mouse.x, mouse.y)) * length;

    // игнорируем поверхности мешей с включенными битами маски Intersection
    int mask = ~(1 << 2 | 1 << 4);

    WorldIntersectionNormalPtr intersection = WorldIntersectionNormal::create();

    ObjectPtr obj = World::getIntersection(start, end, mask, intersection);

    if (obj)
    {
        vec3 point = intersection->getPoint();
        vec3 normal = intersection->getNormal();
        Visualizer::renderVector(point, point + normal, vec4_one);
        Log::message("Hit %s at (%f,%f,%f)\n", obj->getName(), point.x, point.y, point.z);
    }
}

---

Напоминаем, что получить доступ к бесплатной версии UNIGINE 2 Community можно, заполнив форму на нашем сайте.

Все комплектации UNIGINE:

• Community — базовая версия для любителей и независимых разработчиков. Достаточна для разработки видеоигр большинства популярных жанров (включая VR).

• Engineering — расширенная, специализированная версия. Включает множество заготовок для инженерных задач.

• Sim — максимальная версия платформы под масштабные проекты (размеров планеты и даже больше) с готовыми механизмами симуляции.

Подробнее о комплектациях и ценах