Book Image

Unreal Engine 4 Scripting with C++ Cookbook

By : William Sherif, Stephen Whittle
Book Image

Unreal Engine 4 Scripting with C++ Cookbook

By: William Sherif, Stephen Whittle

Overview of this book

Unreal Engine 4 (UE4) is a complete suite of game development tools made by game developers, for game developers. With more than 100 practical recipes, this book is a guide showcasing techniques to use the power of C++ scripting while developing games with UE4. It will start with adding and editing C++ classes from within the Unreal Editor. It will delve into one of Unreal's primary strengths, the ability for designers to customize programmer-developed actors and components. It will help you understand the benefits of when and how to use C++ as the scripting tool. With a blend of task-oriented recipes, this book will provide actionable information about scripting games with UE4, and manipulating the game and the development environment using C++. Towards the end of the book, you will be empowered to become a top-notch developer with Unreal Engine 4 using C++ as the scripting language.

Related Content you might be interested in

Current Title:

Small book image
Unreal Engine 4 Scripting with C++ Cookbook
William Sherif | Stephen Whittle
Oct, 2016 | 452 pages
No titles found
Table of Contents (19 chapters)
Unreal Engine 4 Scripting with C++ Cookbook
Unreal Engine 4 Scripting with C++ Cookbook
Credits
Credits
About the Authors
About the Authors
About the Reviewer
About the Reviewer
www.PacktPub.com
www.PacktPub.com
Preface
Preface
Free Chapter
1
UE4 Development Tools
UE4 Development Tools
Introduction
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
UE4 – installation
UE4 – first project
UE4 – creating your first level
UE4 – logging with UE_LOG
UE4 – making an FString from FStrings and other variables
Project management on GitHub – getting your Source Control
Project management on GitHub – using the Issue Tracker
Project management on VisualStudio.com – managing the tasks in your project
Project management on VisualStudio.com – constructing user stories and tasks
2
Creating Classes
Creating Classes
Introduction
Making a UCLASS – deriving from UObject
Creating a user-editable UPROPERTY
Accessing a UPROPERTY from Blueprints
Specifying a UCLASS as the type of a UPROPERTY
Creating a Blueprint from your custom UCLASS
Instantiating UObject-derived classes (ConstructObject < > and NewObject < >)
Destroying UObject-derived classes
Creating a USTRUCT
Creating a UENUM( )
Creating a UFUNCTION
3
Memory Management and Smart Pointers
Memory Management and Smart Pointers
Introduction
Unmanaged memory – using malloc( )/free( )
Unmanaged memory – using new/delete
Managed memory – using NewObject< > and ConstructObject< >
Managed memory – deallocating 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
4
Actors and Components
Actors and Components
Introduction
Creating a custom Actor in C++
Instantiating an Actor using SpawnActor
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 a custom Primitive Component
Creating an InventoryComponent for an RPG
Creating an OrbitingMovement Component
Creating a building that spawns units
5
Handling Events and Delegates
Handling Events and Delegates
Handling events 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 an First Person Shooter
6
Input and Collision
Input and Collision
Introduction
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
7
Communication between Classes and Interfaces
Communication between Classes and Interfaces
Introduction
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 UInterface from one another
Overriding UInterface functions in C++
Exposing UInterface methods to Blueprint from a native base class
Implementing UInterface functions in Blueprint
Creating C++ UInterface function implementations that can be overridden in Blueprint
Calling Blueprint-defined interface functions from C++
Implementing a simple interaction system with UInterfaces
8
Integrating C++ and the Unreal Editor
Integrating C++ and the Unreal Editor
Introduction
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 Blueprint
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
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
9
User Interfaces – UI and UMG
User Interfaces – UI and UMG
Introduction
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
Use Data Binding with Unreal Motion Graphics
Controlling widget appearance with Styles
Create a custom SWidget/UWidget
10
AI for Controlling NPCs
AI for Controlling NPCs
Introduction
Laying down a Navigation Mesh
Following behavior
Connecting a Behavior Tree to a Character
Constructing Task nodes
Using Decorators for conditions
Using periodic services
Using Composite nodes – Selectors, Sequences, and Simple Parallel
AI for a Melee Attacker
11
Custom Materials and Shaders
Custom Materials and Shaders
Introduction
Modifying color using a basic Material
Modifying position using a Material
Shader code via Custom node
The Material function
Shader parameters and Material instances
Glimmer
Leaves and Wind
Reflectance dependent on the viewing angle
Randomness – Perlin noise
Shading a Landscape
12
Working with UE4 APIs
Working with UE4 APIs
Introduction
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
Core/Math API – Rotation using FRotationMatrix to have one object face another
Landscape API – Landscape generation with Perlin noise
Foliage API – Adding trees procedurally to your level
Landscape and Foliage API – Map generation using Landscape and Foliage APIs
GameplayAbilities API – Triggering an actor's gameplay abilities with game controls
GameplayAbilities API – Implementing stats with UAttributeSet
GameplayAbilities API – Implementing buffs with GameplayEffect
GameplayTags API – Attaching GameplayTags to an Actor
GameplayTasks API – Making things happen with GameplayTasks
HTTP API – Web request
HTTP API – Progress bars
Index
Index

Project management on VisualStudio.com – constructing user stories and tasks

From the Scrum point of view, a User Story is grouping of tasks that need to be done. A group of user stories can be collected into a Feature, and a group of Features can be gathered together into what is called an Epic . VisualStudio.com organizes User Story creation very well so that it's easy to construct and plan the completion of any particular task (user story). In this recipe, we'll describe how to assemble and put together user stories.

Getting ready

Every item entered into VisualStudio.com's project management suite should always be a feature that somebody wants to be in the software. User story creation is a fun, easy, and exciting way to group together and mete out bunches of tasks to your programmers as work to be done. Log in to your VisualStudio.com account now, edit one of your projects, and begin using this feature.

How to do it…

  1. From the VisualStudio.com Team Services landing page, navigate to the project into which you want to enter some new work to be done. All of your Projects can be found if you click on Browse under the Recent projects & teams heading.

  2. Select the project that you want to work with and hit Navigate.

  3. Tasks inside Visualstudio.com take place inside of one of the three categories of super task:

    • User Story

    • Features

    • Epics

      Tip

      User Stories, Features, and Epics are just organizational units for work. An Epic contains many Features. A Feature contains many User Stories, and a User Story contains many Tasks.

      By default, Epics are not shown. You can display Epics by going to Settings (the gear icon on the right side of the screen). Then navigate to General | Backlogs. Under the section that says See only the backlogs your team manages, select to display all three flavors of Backlog: Epics, Features, and Stories.

  4. There are now four navigation steps to perform before you can enter your first task (User Story) into the Backlog:

    1. From the menu bar at the top, select WORK.

    2. Then, in the submenu that appears on the WORK page, select Backlogs.

    3. On the sidebar that appears, click on Stories.

    4. From the panel on the right-hand side, select Board.

      Tip

      Backlog is the set of User Stories and Tasks that we have yet to complete. You might think, "Are brand new tasks really entered into a Backlog?" That's right! You're already behind! The implications of Scrum's terminology seem to imply "overflowing with work".

  5. From the panel on the right-hand side, hit New item, and fill in the text for your new User Story item.

  6. Click on the text of the User Story card, and fill in the fields for Assignee, the Iteration that it's a part of, Description, tags, and any other fields of the Details tab that you want to explore.

  7. Next we break down the overall User Story into a series of achievable tasks. Hover over your new User Story item until the ellipsis (three dots…) appears. Click on the ellipsis, and select + Add Task.

  8. List the details of completing the User Story in the series of Tasks.

  9. Assign each Task to:

    • An Assignee

    • An Iteration

      Tip

      Simply put, an Iteration is really just a time period. At the end of each iteration, you should have a deliverable, testable piece of software completed. Iteration is a time period that refers to producing yet another version of your amazing software (for testing and possible release).

  10. Continue adding Tasks to the project as the project develops features to complete and bugs to fix.

How it works…

Epics contain a number of Features. Features contain a number of User Stories, and User Stories contain a number of Tasks and Tests.

All of these items are assignable to a User (an actual human), and to an Iteration (time period), for both assigning responsibility and scheduling a task. Once these are assigned, the task should appear in the Queries tab.

Tip

Detailed steps to download the code bundle are mentioned in the Preface of this book. Please have a look.

The code bundle for the book is also hosted on GitHub at https://github.com/PacktPublishing/Unreal-Engine-4-Scripting-with-CPlusPlus-Cookbook. We also have other code bundles from our rich catalog of books and videos available at https://github.com/PacktPublishing/. Check them out!

Previous Section
End of Chapter 1
Next Chapter