Unreal Engine Developer Course - Section 2 - Bull Cow Game

This is the Unreal Engine Developer course – it started as a runaway success on Kickstarter and has gone on to become one of the bestselling Unreal courses on the internet! Continually updated in response to student suggestions, you will benefit from the fact we have already taught over 360,336 students game development, many shipping commercial games as a result.

You're welcome to download, fork or do whatever else legal with all the files! The real value is in our huge, high-quality online tutorials that accompany this repo. You can check out the course here: Unreal Engine Developer

In This Section

1 Intro, Notes & Section 2 Assets

• Welcome to the first actual coding video.
• Why we’re doing this in the IDE only.
• What you’ll be building, see resources.
• You’ll learn types, loops, routines, classes.
• We’ll follow Unreal’s coding style, and re-use.
• Notes and resources are attached.

2 S02 Game Design Document (GDD)

• How much planning should we do?
• Define the emotional problem the game solves*
• Chose concept, rules & requirements.
• Start to think about the architecture.
• Copy as much as possible into the code!
• Document now what may change later.

Useful Links

• * McConnell, Steve. Code Complete. Microsoft Press 2004. Chapter 3.3

3 How Solutions & Projects Relate

• How projects and solutions relate.
• Setting up a new command line project.
• An overview of the structure of our solution.
• (Adding main.cpp to our project).

4 C++ Function Syntax

• The difference between an engine and a library.
• How this relates to this console application.
• What is building / compiling code?
• How the console knows where to find our code.
• The syntax of a function in C++.
• Write the minimal C++ program to remove error.
• Testing our application runs without error.

5 Using, #include and Namespaces

• # represents a “preprocessor directive”.
• #include copies-and-pastes other code.
• The idea of using library code.
• Use <> for standard libraries.
• Use “ “ for files you have created yourself.
• Notice the namespace icon in autocomplete.
• Import iostream library and use std namespace.

6 Magic Numbers and Constants

• What a “magic number” is.
• Why it’s a good idea to avoid them.
• constexpr means “evaluated at compile time”.
• Introduce coding standards*.
• Use a constant for the word length.

Useful Links

• * Unreal Engine - Coding Standard

7 Variables and cin for Input

• The difference between \n and endl
• Introducing pseudocode programming
• Why we need to #import <string>
• Getting input using cin
• Discovering woes with our input buffer.

8 Using getline()

• Re-cap the problem we have.
• Why getline() is useful here.
• Where to find C++ documentation.
• A word on non-obvious solutions.

9 Simplifying With Functions

• Programming is all about managing complexity.
• We want to think about a few things at a time.
• The idea of abstraction and encapsulation.
• How functions help us simplify.
• Write and call your first functions.
• A warning about “side-effects” of functions.
• Always use return at the end of your functions.

10 Iterating With For & While Loops

• Why we need loops.
• When to use for vs while.
• The syntax of a for loop.
• Think carefully about the first & last loop.
• Write a for loop to repeat the game.

11 Clarity is Worth Fighting For

• More about levels of abstraction.
• A word on being clever.
• Using Visual Studio’s Extract “Extract Function”
• What a header file (.h) is.
• What’s refactoring, and why we do it.
• Removing side-effects.
• Where to find the course code on GitHub.

12 Booleans and comparisons

• What a boolean is, and how to use it.
• Only use when completely clear what you mean.
• Use == for comparison.
• Use && for logical AND.
• Use || for logical OR.
• Use [n] to access a string, starting at n=0.
• Use ‘ ‘ for characters, and “ “ for strings.

13 Using do and while in C++

• What a do while loop is.
• How it executes code one or more times.
• Making our game play multiple times.

14 Introducing Classes

• Lookup the Turing machine.
• A quick overview of the MVC pattern.
• User defined types (classes).
• About working at an interface level (black box).
• An overview of class FBullCowGame

15 Using Header Files as Contracts

• Introducing .h header files in C++.
• Why the added complexity is worth it.
• Defining the interface to our class.
• Writing our first draft of FBullCowGame.h

16 Including Our Own Header File

• NEVER use using namespace in a .h
• In fact, why use it at all?
• Create your .cpp files and #include
• Don’t create chains of includes.

17 Instantiating Your Class

• Relax, they’re just user defined types!
• string FirstName; creates a string object
• FBullCowGame BCGame; works the same way
• These instances are initialised by “constructors”
• Instantiating means “creating an instance of”
• So we’re simply creating a game instance.

18 Writing & Using Getter Methods

• What is a getter method
• Why we never access variables directly
• How to call a method using the dot operator
• Pros and cons of initialising in at compile time
• Using “Rebuild Project” to make VS behave!

19 Introducing the Const Keyword

• const’s meaning depends on context
• Generally means “I promise not to change this”
• What this is depends on exactly where it appears
• At the end of a member function, for example int GetCurrentTry() const; it prevents the function from modifying any member variables
• This is a good safety feature.

20 Constructors For Initialisation

• Default constructor called when object created
• Initialize in constructor when decided at runtime
• Initialize in declaration if known at compile time
• Constructor syntax simply: ClassName();
• Set the member variables in constructor
• Test this has worked.

21 Pseudocode Programming

• More on Pseudocode Programming Practice (PPP)
• Reviewing our code and architecture
• Using // TODO as a comment prefix
• Introducing Visual Studio’s Task List
• Planning our next wave of coding.

22 Using using for Type Aliases

• We’re substituting types to be “Unreal ready”
• The declaration is using <alias> = <type>;
• For example using int32 = int;
• Why Unreal uses int32 rather than int
• FText is for output, FString is “mutable”
• Where to use each type of string
• Map FText and FString to std::string

23 Using struct for Simple Types

• struct is almost identical to class
• It’s member variables (data) is public by default
• Ideal for simple value types like BullCowCount
• Outline BullCowCount SubmitGuess(FString)

24 Using if Statements in C++

• Why we need conditionals (selection)
• Use if when it reads better (e.g. few conditions)
• Use switch for multiple, simple conditions
• (for loads of statements consider a table lookup)
• The syntax of an if statement
• Using if to write count bulls and cows.

25 Debugging 101

• A very brief intro to Visual Studio’s debugger
• Set a break-point by clicking in margin
• Watch values by highlighting in debug mode
• Use “Continue” to cycle back to breakpoint.

26 A Place for Everything

• Centralising the hidden word length
• Making this a property of the game class
• Writing a getter to access this value
• Updating our intro to vary with word length.

27 Introducing enumerations

• An enumerated type consists of named values
• Use instead of coded meaning
• Makes the code more readable and meaningful
• Only defined values can be used - more robust
• A benefit of C++ 11’s strongly typed enums
• Creating an enum class for error checking.

28 Writing Error Checking Code

• Use else if for the first time
• Outline or CheckGuessValidity() method
• Write working code for checking guess length
• Use the debugger to test the return values.

29 Using switch Statements

• Use our error values to communicate with user
• All our user interaction is via GameManager.cpp
• We’ll use FText in this file, as it’s UI text
• We can “switch” what we say based on the error
• The syntax of a switch statement
• Remember your break keywords!

30 Warm Fuzzy Feelings

• Don’t get comfortable with compiler warnings
• Refactor GetValidGuess() to remove warning
• Rename SubmitGuess() to SubmitValidGuess()
• Improve readability of SubmitValidGuess()
• Get a warm fuzzy feeling!

31 Handling Game Win Condition

• Change our PlayGame() loop to a while
• Implement our IsGameWon() function

32 Win or Lose "Screen"

Write a method to print a game summary to the screen once the game is over.

33 Introducing Big O Notation

• Algorithm: the recipe for solving a problem
• or: 45th US Vice President’s dance style
• Introducing the complexity of algorithms
• A quick introduction to “Big O” notation
• Comparing three ways of checking for isograms.

34 TMap and map Data Structures

• The importance of knowing your data types
• Introducing the std::map data type
• #define TMap std::map to keep it ‘Unreal’
• How we’ll be using the map
• TMap<char, bool> LetterSeen; to declare
• Using LetterSeen[Letter] to access
• Wiring-up and pseudocoding IsIsogram()

35 Range-based for Loop

• Introducing containers and iterators
• Using a range-based for loop in Unreal*
• Gently introducing the auto keyword
• Finishing our IsIsogram()

Useful Links

• * Unreal Engine - Ranged Based For Loops

36 Design a Helper Function

• Gain confidence with a multi-stage challenge
• A word on implicit dependencies

37 Playtesting Your Game

• Having someone else play test your game is vital
• Silently take notes, or record screen if possible
• Immediately go away and fix obvious bugs
• For improvements consider 2nd or 3rd opinion
• Repeat until the bug / issue rate plateaus.

38 Difficulty & Play Tuning

• About the flow channel*
• map word length to max tries
• Play test to determine correct difficulty.

Useful Links

• * Read more in Sylvester, T. Designing Games - O’Reilly

39 Polishing & Packaging

• First impressions count (think reviews)
• Don’t ship a half-baked product, even if digital
• Check through your code (polish)
• Ship to your customers (package).

Section 2 Wrap-Up

• HUGE congratulations on your progress
• Over 5 hours of pure C++ learning
• Over 30 challenges you’ve completed
• The journey has only just begun
• Share your source code for others to play
• Here are some suggested improvements
• Next we take the game logic into Unreal :-)