Book Image

Unreal Engine 4.x Scripting with C++ Cookbook - Second Edition

By : John P. Doran, William Sherif, Stephen Whittle

Book Image

Unreal Engine 4.x Scripting with C++ Cookbook - Second Edition

By: John P. Doran, William Sherif, Stephen Whittle

Overview of this book

Unreal Engine 4 (UE4) is a popular and award-winning game engine that powers some of the most popular games. A truly powerful tool for game development, there has never been a better time to use it for both commercial and independent projects. With more than 100 recipes, this book shows how to unleash the power of C++ while developing games with Unreal Engine. This book takes you on a journey to jumpstart your C++ and UE4 development skills. You will start off by setting up UE4 for C++ development and learn how to work with Visual Studio, a popular code editor. You will learn how to create C++ classes and structs the Unreal way. This will be followed by exploring memory management, smart pointers, and debugging your code. You will then learn how to make your own Actors and Components through code and how to handle input and collision events. You will also get exposure to many elements of game development including creating user interfaces, artificial intelligence, and writing code with networked play in mind. You will also learn how to add on to the Unreal Editor itself. With a range of task-oriented recipes, this book provides actionable information about writing code for games with UE4 using C++. By the end of the book, you will be empowered to become a top-notch developer with UE4 using C++ as your scripting language!

Preface

Who this book is for

What this book covers

To get the most out of this book

Free Chapter

UE4 Development Tools

UE4 Development Tools

Technical requirements

Installing Visual Studio

Creating and building your first C++ project in Visual Studio

Changing the code font and color in Visual Studio

Extension – changing the color theme in Visual Studio

Formatting your code (Autocomplete settings) in Visual Studio

Shortcut keys in Visual Studio

Extended mouse usage in Visual Studio

Installing Unreal Engine 4 (UE4)

Creating your first project in UE4

Creating your first level in UE4

UE4 – hot reloading

UE4 – logging with UE_LOG

UE4 – making an FString from FStrings and other variables

Creating Classes

Creating Classes

Technical requirements

Making a UCLASS – deriving from UObject

Creating a blueprint from your custom UCLASS

Creating a user-editable UPROPERTY

Accessing a UPROPERTY from blueprints

Specifying a UCLASS as the type of a UPROPERTY

Instantiating UObject-derived classes (ConstructObject< > and NewObject< >)

Destroying UObject-derived classes

Creating a USTRUCT

Creating a UENUM( )

Memory Management, Smart Pointers, and Debugging

Memory Management, Smart Pointers, and Debugging

Technical requirements

Unmanaged memory – using malloc( ) / free( )

Unmanaged memory – using new/delete

Managed memory – using NewObject< > and ConstructObject< >

Managed memory – de-allocating memory

Managed memory – smart pointers (TSharedPtr, TWeakPtr, TAutoPtr) to track an object

Using TScopedPointer to track an object

Unreal's garbage collection system and UPROPERTY( )

Forcing garbage collection

Breakpoints and stepping through code

Finding bugs and using call stacks

Using the profiler to identify hot spots

Actors and Components

Actors and Components

Technical requirements

Creating a custom Actor in C++

Instantiating an Actor using SpawnActor

Creating a UFUNCTION

Destroying an Actor using Destroy and a Timer

Destroying an Actor after a delay using SetLifeSpan

Implementing the Actor functionality by composition

Loading assets into components using FObjectFinder

Implementing the Actor functionality by inheritance

Attaching components to create a hierarchy

Creating a custom Actor Component

Creating a custom Scene Component

Creating an InventoryComponent for an RPG

Creating an OrbitingMovement Component

Creating a building that spawns units

Handling Events and Delegates

Handling Events and Delegates

Technical requirements

Handling events that have been implemented via virtual functions

Creating a delegate that is bound to a UFUNCTION

Unregistering a delegate

Creating a delegate that takes input parameters

Passing payload data with a delegate binding

Creating a multicast delegate

Creating a custom Event

Creating a Time of Day handler

Creating a respawning pickup for a First Person Shooter

Input and Collision

Input and Collision

Technical requirements

Axis Mappings – keyboard, mouse, and gamepad directional input for an FPS character

Axis Mappings – normalized input

Action Mappings – one-button responses for an FPS character

Adding Axis and Action Mappings from C++

Mouse UI input handling

UMG keyboard UI shortcut keys

Collision – letting objects pass through one another using Ignore

Collision – picking up objects using Overlap

Collision – preventing interpenetration using Block

Communication Between Classes and Interfaces: Part I

Communication Between Classes and Interfaces: Part I

Technical requirements

Creating a UInterface

Implementing a UInterface on an object

Checking if a class implements a UInterface

Casting to a UInterface implemented in native code

Calling native UInterface functions from C++

Inheriting UInterfaces from one another

Overriding UInterface functions in C++

Implementing a simple interaction system with UInterfaces

Communication Between Classes and Interfaces: Part II

Communication Between Classes and Interfaces: Part II

Technical requirements

Exposing UInterface methods to Blueprint from a native base class

Implementing UInterface functions in Blueprint

Overriding C++ UInterface functions through Blueprints

Calling Blueprint-defined interface functions from C++

Integrating C++ and the Unreal Editor: Part I

Integrating C++ and the Unreal Editor: Part I

Technical requirements

Using a class or struct as a blueprint variable

Creating classes or structs that can be subclassed in Blueprint

Creating functions that can be called in Blueprint

Creating events that can be implemented in Blueprints

Exposing multi-cast delegates to Blueprint

Creating C++ enums that can be used in Blueprint

Editing class properties in different places in the editor

Making properties accessible in the Blueprint editor graph

Responding to property changed events from the editor

Implementing a native code Construction Script

Integrating C++ and the Unreal Editor: Part II

Integrating C++ and the Unreal Editor: Part II

Creating a new editor module

Creating new toolbar buttons

Creating new menu entries

Creating a new editor window

Creating a new Asset type

Creating custom context menu entries for Assets

Creating new console commands

Creating a new graph pin visualizer for Blueprint

Inspecting types with custom Details panels

Working with UE4 APIs

Working with UE4 APIs

Technical requirements

Core/Logging API – defining a custom log category

Core/Logging API – FMessageLog to write messages to the Message Log

Core/Math API – rotation using FRotator

Core/Math API – rotation using FQuat

API – rotation using FRotationMatrix to have one object face another

GameplayAbilities API – triggering an actor's gameplay abilities with game controls

GameplayAbilities API - Implementing stats with UAttributeSet

GameplayAbilities API – implementing buffs with GameplayEffect

GameplayTasks API – making things happen with GameplayTasks

HTTP API – downloading webpages using web requests

HTTP API – displaying downloaded progress

Multiplayer Networking in UE4

Multiplayer Networking in UE4

Technical requirements

Testing your game as a client and a server simultaneously

Replicating properties over the network

Replicating functions over the network

Handling UI network events

AI for Controlling NPCs

AI for Controlling NPCs

Technical requirements

Implementing a simple following behavior

Laying down a Navigation Mesh

Creating a Blackboard

Creating a Behavior Tree

Connecting a Behavior Tree to a Character

Creating a BTService

Creating a BTTask

User Interfaces - UI and UMG

User Interfaces - UI and UMG

Technical requirements

Drawing using Canvas

Adding Slate Widgets to the screen

Creating screen size-aware scaling for the UI

Displaying and hiding a sheet of UMG elements in-game

Attaching function calls to Slate events

Using Data Binding with Unreal Motion Graphics

Controlling widget appearance with Styles

Creating a custom SWidget/UWidget

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Introduction

Memory management is always one of the most important things to get right in your computer program to ensure stability and good, bug-free operation of your code. A dangling pointer (pointer referring to something that has been removed from memory) is an example of a bug that is hard to track if it occurs.

In any computer program, memory management is extremely important. UE4's UObject reference-counting system is the default way that memory is managed for actors and classes derived from the UObject class. This is the default way that your memory will be managed within your UE4 program.

If you write custom C++ classes of your own, which do not derive from UObject, you may find the TSharedPtr / TWeakPtr reference-counted classes useful to use. These classes provide reference counting and automatic deletion for objects when they have no more references.

This chapter...