Index

A

• actors
  • about / Actors versus pawns
  • versus pawns / Actors versus pawns
  • adding, to scene / Adding an actor to the scene
• AMyHUD**MouseRightClicked()
  • creating / Writing AMyHUD::MouseRightClicked()
• And (&&) operator
  • about / The And (
• APickupItem class
  • FString variable / Base class PickupItem
  • int32 variable / Base class PickupItem
  • USphereComponent variable / Base class PickupItem
  • UStaticMeshComponent variable / Base class PickupItem
  • UTexture2D variable / Base class PickupItem
• APuzzleBlock class / Our first example with Unreal Engine
• arrays
  • about / Regular arrays
  • array syntax / The array syntax
  • exercise / Exercise
  • solutions, of exercise / Solutions
• array syntax
  • about / The array syntax
• Artificial Intelligence (AI) / Actors versus pawns
• attack animation, triggering
  • about / Triggering the attack animation
  • blueprint basics / Blueprint basics
  • animation blueprint, modifying for Mixamo Adam / Modifying the animation blueprint for Mixamo Adam
  • code, for swinging sword / Code to swing the sword

B

• basic monster intelligence
  • about / Basic monster intelligence
  • monster, moving / Moving the monster – steering behavior
  • discrete nature, of monster motion / The discrete nature of monster motion
  • Monster SightSphere / Monster SightSphere
• blizzard spell
  • settings / Settings for the blizzard spell
• BlockClicked function / Our first example with Unreal Engine
• branching
  • about / Branching
• bullet physics
  • about / Bullet physics
• bullets
  • adding, to Monster class / Adding bullets to the monster class

C

• .cpp file
  • about / .h and .cpp files
• .cpp files
  • about / .h and .cpp
• <cmath> library function
  • sqrt() function / An example of a <cmath> library function – sqrt()
• C++
  • math / Math in C++
• C++ code, for controlling game character
  • writing / Writing C++ code that controls the game's character
  • player, making instance of Avatar class / Making the player an instance of the Avatar class
  • controller inputs, setting up / Setting up controller inputs
  • yaw and pitch, setting / Yaw and pitch
• C++ primitive type
  • int / Dynamic C-style arrays
  • float / Dynamic C-style arrays
  • double / Dynamic C-style arrays
  • long long / Dynamic C-style arrays
• C++ program
  • setting up / Setting up our project
  • Microsoft Visual C++, using on Windows / Using Microsoft Visual C++ on Windows
  • XCode, using on Mac / Using XCode on a Mac
  • creating / Creating your first C++ program
  • semicolons / Semicolons
  • errors, handling / Handling errors
  • warnings / Warnings
  • compiling / What is building and compiling?
  • source code, building / What is building and compiling?
  • scripting / Scripting
  • ASCII art maze example / Exercise – ASCII art
  • variables / Variables
  • flow, controlling / Controlling the flow of your program
• C++ STL map
  • about / C++ STL map
  • element, finding / Finding an element in a <map>
  • exercise / Exercise
  • solution, of exercise / Solution
• C++ STL set
  • about / C++ STL set
  • element, finding / Finding an element in a <set>
  • exercise / Exercise
  • solution, of exercise / Solution
• C++ STL versions
  • about / C++ STL versions of commonly used containers
  • C++ STL set / C++ STL set
  • C++ STL map / C++ STL map
• C-style arrays
  • about / C++ style dynamic size arrays (new[] and delete[]), Dynamic C-style arrays
• cast spell
  • right mouse click, attaching to / Attaching right mouse click to cast spell
• CastSpell function
  • writing / Writing the avatar's CastSpell function
• cin
  • about / cin
• cin command
  • using / C++ style dynamic size arrays (new[] and delete[])
• class
  • versus struct / class versus struct
  • about / class versus struct
• classes
  • putting into headers / Putting your classes into headers
• class inheritance
  • about / Class inheritance, What does inheritance do?
  • derived classes / Derived classes
  • syntax / Syntax of inheritance
  • is-a relationship / is-a relationship
  • protected variables / protected variables
  • virtual function / Virtual functions
  • purely virtual function / Purely virtual functions (and abstract classes)
• comparison operators
  • used, for testing inequalities / Testing for inequalities using other comparison operators (>, >=, <, <=, and !=)
• compiling
  • about / What is building and compiling?
• constructor
  • about / Constructors and destructors
• constructors
  • about / Constructors and destructors
• const variables
  • about / Const variables
• control flow statements
  • about / Controlling the flow of your program
• controller inputs
  • setting up / Setting up controller inputs
  • exercise / Exercise
  • solution, of exercise / Solution

D

• delete[] array
  • about / C++ style dynamic size arrays (new[] and delete[])
• destructors
  • about / Constructors and destructors
• do/while loop
  • about / The do/while loop
• dynamic memory allocations
  • about / Dynamic memory allocation
  • delete keyword / The delete keyword
  • memory leaks / Memory leaks

E

• EASTL
  • URL / C++ STL versions of commonly used containers
• else statements
  • coding / Coding else statements
• encapsulation
  • about / Privates and encapsulation
  • reasons / Privates and encapsulation
• event, triggering
  • exercises / Exercises
  • solutions, of exercises / Solutions
• extern variables
  • about / Extern variables

F

• fire spell / The fire spell
• flowchart
  • about / Branching
• for loop
  • about / The for loop
  • exercises / Exercises
  • solutions, of exercises / Solutions
• forward declaration, players backpack
  • about / Forward declaration
• funcs.cpp file
  • about / prototypes.h contains
• function prototypes
  • about / Function prototypes
• functions
  • about / Functions
  • <cmath> library function / An example of a <cmath> library function – sqrt()
  • advantages / An example of a <cmath> library function – sqrt()
  • custom function, writing / Writing our own functions
  • printRoad() function / Writing our own functions
  • sample program trace / A sample program trace
  • main() function / A sample program trace
  • exercise / Exercise
  • solution / Solution
  • with arguments / Functions with arguments
  • values, returning / Functions that return values
• functions, returning values
  • exercises / Exercises
  • solutions, of exercises / Solutions

G

• GENERATED_UCLASS_BODY() macro
  • about / Inheriting from UE4 GameFramework classes
• get() operation
  • about / But what's the point of get/set operations?
• getters
  • about / Getters and setters, Getters
• GetWorld()->SpawnActor()
  • instantiating / Instantiating the spell – GetWorld()->SpawnActor()
• Git
  • about / Using XCode on a Mac
• global variables
  • about / Global variables
• GNU Compiler Collection (GCC)
  • about / What is building and compiling?

H

• .h file
  • about / .h and .cpp files
• .h files
  • about / .h and .cpp
• hardcoding
  • about / Loading the mesh
• HUD
  • about / Displaying a quote from each NPC dialog box
• HUD**DrawTexture()
  • using / Using HUD::DrawTexture()
  • exercise / Exercise

I

• if(spell) function / if(spell)
• if statements
  • coding / Coding if statements
• Integrated Development Environment (IDE) project
  • about / main.cpp contains
• inventory item clicks
  • detecting / Detecting inventory item clicks
  • elements, dragging / Dragging elements
  • exercises / Exercises
• is-a relationship
  • about / is-a relationship
• iterating ways, TArray
  • about / Iterating a TArray
  • vanilla for loop and square brackets notation / The vanilla for loop and square brackets notation
  • iterators / Iterators
• iterators
  • about / Iterators

K

• knockback
  • adding, to player / Player knockback

L

• landscape
  • about / Landscape
  • creating / Landscape
  • sculpting / Sculpting the landscape
• level
  • creating / Starting from scratch
  • light sources, adding / Adding light sources
  • collision volumes / Collision volumes
  • collision detection, adding for objects editor / Adding collision detection for the objects editor
• local variables
  • about / Local variables
• logical operators
  • about / Using logical operators
  • using / Using logical operators
  • Not (!) operator / The Not (!) operator
  • And (&&) operator / The And (
  • Or (||) operator / The Or (||) operator

M

• macros
  • about / Macros
  • const variables, using / Advice – try to use const variables where possible
• macros, with arguments
  • about / Macros with arguments
  • inline functions, using / Advice – use inline functions instead of macros with arguments
• main.cpp file
  • about / main.cpp contains
• malloc() function
  • using / Dynamic C-style arrays
• math, in C++
  • about / Math in C++
  • exercises / Exercises
• Melee attacks
  • about / Melee attacks
  • melee weapon, defining / Defining a melee weapon
• member functions
  • about / Member functions
  • this keyword / The this keyword
  • strings, using as objects / Strings are objects?
  • invoking / Invoking a member function
  • exercises / Exercises
  • solutions, of exercises / Solutions
  • encapsulation / Privates and encapsulation
  • public data members / Some people like it public
• memory
  • numbers / Numbers are everything
• memory access violation / The array syntax
• memory leak / Memory leaks
• Microsoft Visual C++
  • using, on Windows / Using Microsoft Visual C++ on Windows
• monster attacks, on player
  • about / Monster attacks on the player
  • Melee attacks / Melee attacks
  • sockets / Sockets
  • projectile attack / Projectile or ranged attacks
  • ranged attack / Projectile or ranged attacks
  • knockback, adding to player / Player knockback
• Monster class
  • bullets, adding to / Adding bullets to the monster class
• monsters
  • programming / Monsters
• Monster SightSphere
  • about / Monster SightSphere
• multiple inheritance
  • about / Multiple inheritance
  • private inheritance / private inheritance

N

• new[] array
  • about / C++ style dynamic size arrays (new[] and delete[])
• non-player character entities
  • creating / Creating non-player character entities
• Non-player Characters (NPCs) / Actors versus pawns
• Not (!) operator
  • about / The Not (!) operator
• NPCs (non-playable characters) / Creating non-player character entities
• null pointer
  • about / The Null pointers

O

• & operator
  • about / Address of operator
• == operator
  • about / The == operator
• object types
  • about / Object types
  • Player object exercise / Exercise – Player, Solution
• Or (||) operator
  • about / The Or (||) operator

P

• particle properties
  • modifying / Changing particle properties
• particle systems
  • about / The particle systems
• pawns
  • about / Actors versus pawns
• PickupItem.h / Base class PickupItem
• PickupItem base class
  • about / Base class PickupItem
  • root component / The root component
• PickupItem blueprint
  • creating / Creating blueprints for PickupItems that cast spells
• player
  • knockback, adding to / Player knockback
• player entity
  • creating / Creating a player entity
  • inheriting, from UE4 GameFramework classes / Inheriting from UE4 GameFramework classes
  • model, associating with Avatar class / Associating a model with the Avatar class
  • free models, downloading / Downloading free models
  • mesh, loading / Loading the mesh
  • blueprint, creating from C++ class / Creating a blueprint from our C++ class
• player inventory
  • drawing / Drawing the player inventory
  • HUD**DrawTexture(), using / Using HUD::DrawTexture()
  • inventory item clicks, detecting / Detecting inventory item clicks
• players backpack declaration
  • about / Declaring the backpack
  • forward declaration / Forward declaration
  • assets, importing / Importing assets
  • action mapping, attaching to key / Attaching an action mapping to a key
• pointers
  • about / Pointers
  • uses / What can pointers do?
• primitive types
  • about / Primitive types
• printf()
  • about / printf()
• program flow, C++
  • controlling / Controlling the flow of your program
  • == operator / The == operator
  • if statements, coding / Coding if statements
  • else statements, coding / Coding else statements
  • inequalities, testing with comparison operators / Testing for inequalities using other comparison operators (>, >=, <, <=, and !=)
• projectile attacks
  • about / Projectile or ranged attacks
• prototypes.h file
  • about / prototypes.h contains

Q

• quote, displaying from NPC dialog box
  • about / Displaying a quote from each NPC dialog box
  • messages, displaying on HUD / Displaying messages on the HUD
  • TArray<Message>, using / Using TArray<Message>
  • event, triggering near NPC / Triggering an event when it is near an NPC
  • NPC, making display to HUD / Make the NPC display something to the HUD when something is nearby

R

• ranged attacks
  • about / Projectile or ranged attacks
• Rigging 101 class
  • URL / Creating a blueprint from our C++ class
• right mouse button clicks
  • activating / Activating right mouse button clicks
• right mouse click
  • attaching, to cast spell / Attaching right mouse click to cast spell
• root component, PickupItem base class
  • about / The root component
  • avatar, obtaining / Getting the avatar
  • player controller, obtaining / Getting the player controller
  • HUD, obtaining / Getting the HUD
• RootComponent property / The root component

S

• s.c_str() function
  • about / printf()
• scene
  • actor, adding / Adding an actor to the scene
• scope of variable
  • about / The scope of a variable
  • g_int / The scope of a variable
  • arg() / The scope of a variable
  • fx / The scope of a variable
  • main() / The scope of a variable
• scripting languages
  • about / Scripting
• set() operation
  • about / But what's the point of get/set operations?
• setters
  • about / Setters
• sockets
  • about / Sockets
  • skeletal mesh socket, creating in monster's hand / Creating a skeletal mesh socket in the monster's hand
  • sword, attaching to model / Attaching the sword to the model
  • player, equipping with sword / Code to equip the player with a sword
  • attack animation, triggering / Triggering the attack animation
• source control management tools (scm)
  • about / Using XCode on a Mac
• spell->SetCaster(this)
  • calling / spell->SetCaster(this)
• Spell class actor
  • about / Spell class actor
• spells
  • blueprinting / Blueprinting our spells
  • picking up / Picking up spells
  • instantiating / Instantiating the spell – GetWorld()->SpawnActor()
  • creating / Creating other spells
• sqrt() function
  • about / An example of a <cmath> library function – sqrt(), Functions that return values
• static local variables
  • about / Static local variables
• struct
  • about / class versus struct
• struct make objects
  • about / struct objects

T

• TArray<int> variable
  • about / UE4's TArray<T>, An example that uses TArray<T>
• TArray<Message>
  • using / Using TArray<Message>
  • exercise / Exercise
  • solution, of exercise / Solution
• TArray<T>
  • about / UE4's TArray<T>
  • uses / An example that uses TArray<T>
  • iterating / Iterating a TArray
• TMap<T, S>
  • about / TMap<T, S>
  • items list / A list of items for the player's inventory
  • iterating / Iterating a TMap
• TSet<T>
  • about / TSet<T>
  • interating / Iterating a TSet
  • intersecting / Intersecting TSet
  • unioning / Unioning TSet
  • finding / Finding TSet

U

• UCLASS() macro
  • about / Inheriting from UE4 GameFramework classes
• UE4 blueprint / Blueprint basics
• UE4 editor
  • URL / Creating a world to put your actors in
  • about / The UE4 editor
  • editor controls / Editor controls
  • play mode controls / Play mode controls
  • objects, adding to scene / Adding objects to the scene
• UE4 project
  • world, creating / Creating a world to put your actors in
  • output, debugging / Debugging the output in UE4
  • TArray<T> / UE4's TArray<T>
  • TSet<T> / TSet<T>
  • TMap<T, S> / TMap<T, S>
• UE4 property specifiers
  • URL / Creating non-player character entities
• Unreal Engine example
  • about / Our first example with Unreal Engine
  • exercise / Exercise
  • code, branching / Branching code in more than two ways
  • else if statement / The else if statement
  • exercise, else if statement / Exercise, Solution
  • switch statement / The switch statement
  • switch, versus if / Switch versus if
  • exercise, switch statement / Exercise
  • looping with / Looping with Unreal Engine
• unreal particle emitters
  • URL, for video / The particle systems

V

• variables
  • about / Variables, Variables, revisited
  • declaring / Declaring variables – touching the silicon
  • reading / Reading and writing to your reserved spot in memory
  • writing / Reading and writing to your reserved spot in memory
  • using / More on variables
  • generalized variable syntax / Generalized variable syntax
  • primitive types / Primitive types
  • object types / Object types
  • pointers / Pointers
  • & operator / Address of operator
  • null pointer / The Null pointers
  • cin / cin
  • printf() / printf()
  • global variables / Global variables
  • local variables / Local variables
  • scope of variable / The scope of a variable
  • static local variables / Static local variables
  • const variables / Const variables
  • function prototypes / Function prototypes
  • .h file / .h and .cpp files
  • .cpp file / .h and .cpp files
  • prototypes.h files / prototypes.h contains
  • funcs.cpp file / prototypes.h contains
  • main.cpp file / main.cpp contains
  • extern variables / Extern variables
• Version control system
  • about / Using XCode on a Mac
• Visual Studio
  • URL / Using Microsoft Visual C++ on Windows

W

• weapon, Melee attacks
  • defining / Defining a melee weapon
  • coding, in C++ / Coding for a melee weapon in C++
  • sword, downloading / Downloading a sword
  • blueprint, creating / Creating a blueprint for your melee weapon
• while loop
  • about / The while loop
  • infinite loops / Infinite loops
  • exercises / Exercises
  • solutions, of exercises / Solutions

X

• XCode
  • about / Using XCode on a Mac
  • using, on Mac / Using XCode on a Mac

Y

• yaw and pitch
  • setting / Yaw and pitch