The Ultimate C++ Unreal Engine 5 & AI Game Dev Course

Write your first c++ program by including iostream, defining int main with braces, using std::cout and std::cin for input and output, returning zero with proper semicolon.

Explore how statements in C++ serve as the basic units, end with semicolons, and execute sequentially from main, with statement blocks and nesting inside braces.

Discover the difference between names and keywords in c++, learn rules for valid identifiers, and note that 95 keywords, like int and class, cannot be used as names.

Learn how the C++ build process turns code in cpp and header files into modules, object files, and a final executable, while distinguishing compile-time, linker, and runtime errors.

Identify and fix errors in your C++ programs, from syntax and semantic to linker, runtime, and logic errors, using debugging and recognizing compiler warnings.

Master signed and unsigned integers in C++ with short, int, long, and long long types. Explore memory usage, ranges, and practical examples in Visual Studio Code.

Learn how the const keyword creates unchangeable variables in c++ and why initializing them matters. See practical examples in visual studio code, highlighting safety and potential compiler optimizations.

Learn how unary increment and decrement operators work in C++, including postfix and prefix forms, with ammo examples and loop usage common in games.

Discover how floating point in C++ stores real numbers, enables arithmetic with float, double, and long double, and reveals size, range, rounding, and signedness considerations.

Master implicit and explicit type conversions in C++ using static_cast, understand truncation and data loss when converting between int and double, and apply rounding using the round function.

Learn how to store single characters in c++ with char and wide and unicode types, including wchar_t, char8_t, char16_t, and char32_t, prefixes u and l, and printing considerations.

Explore strings as a std::string class and learn to format and print data with stream manipulators and std::format, covering integers, floating point, hex, binary, and scientific notation.

Explore arithmetic operators in C++, including addition, subtraction, multiplication, division, and modulus for numeric types, and the order of operations (pemdas) with parentheses shaping evaluation.

Explore assignment operators in c++, from the basic equals sign to compound forms. See how plus-equals, minus-equals, multiply-equals, divide-equals, and modulo-equals update left-hand side variables through clear examples.

Explore relational operators in C++ that compare two operands and return a boolean value, including equal, not equal, less than, greater than, and their equal variants for if statements.

Explore how logical operators in C++ control decision making with and, or, and not, using booleans in real-world and game development scenarios such as login, banking, and combat.

Explore the conditional operator as a concise alternative to if-else, using a three-operand ternary expression to choose between two values based on a condition.

Explore boolean values and the bool data type, storing true or false. Use comparison and logical operators to create conditions, and learn about the spaceship operator and its limits.

Explore the if and else constructs, understand true and false conditions, and learn nested ifs, else if chains, and the dangling else problem with practical examples.

Explore else if logic and nested ifs in c++ by implementing a score-based grading system, handling ranges and invalid inputs, and understanding when to skip subsequent conditions.

Explore nested if logic with an age check and driving test status, using if, else, and else-if constructs, validating input as y or n and printing driving eligibility messages.

Master switch statements in C++ by using cases, default, and breaks to replace long if-else chains; explore fall-through behavior and enumerated types with practical examples.

Explore how the while loop runs when the number of iterations is unknown, with the condition evaluated at the start of each iteration and the risk of infinite loops.

Explain how the do-while loop executes its body before checking the condition, guaranteeing at least one iteration, unlike the while loop; illustrate with a menu-driven example in C++ code.

Use range-based for loops to easily iterate over containers like strings, arrays, and vectors, applying operations to every element with auto type deduction.

Learn how to access, initialize, and print array elements in c++ using zero-based indexing, with examples of full, partial, and default initialization, and the risks of out-of-bounds access.

Explore how to use C++ strings with the std::string class, including dynamic resizing, memory management, and a rich set of methods such as length, size, find, append, erase, and getline.

Explore how functions in C++ enable modularity, reusability, and abstraction through return types and parameters. Learn to use libraries, call signatures, and overloading to build and reuse code.

Learn how to call functions in C++, pass parameters, and handle return values inside main, print results, and reuse library functions like sqrt and max to simplify code.

Explore function parameters and return types, including pass by value and how values move from main to a function, with auto return type deduction and add/subtraction examples.

Discover how default arguments make parameters optional in C++ functions, why defaults belong at the end of the parameter list, and how to pass arguments in order with practical examples.

discover how arrays pass to functions by address, access their elements, and handle multi dimensional arrays with const and size information.

Explore function overloading in C++ by defining multiple add functions with different parameter types and counts, and see how the compiler selects the right one.

Explore recursion in programming by learning how functions call themselves, directly or indirectly, and see a factorial example, its memory implications, and when to avoid infinite recursion.

Learn how inline functions copy the function body to the call site at compile time, reducing runtime overhead for small operations like adding two numbers.

Learn how pointers store the address of another variable, use the address-of operator, and access values indirectly, with notes on null pointers and type-specific pointer rules.

Explore array of pointers and pointer to array in C++, showing how to create, dereference, and navigate memory addresses, and how array names act as first-element addresses.

Explore const pointers, pointer to constant variables, and constant pointers to constants in C++, showing how to preserve pointer addresses and/or the values they reference.

Explore pointer arithmetic in C++: navigate memory with addition, subtraction, increment, and comparison on elements, not bytes, and traverse arrays using pointers.

Learn the basics of dynamic memory allocation in C++ with new and delete, allocating heap memory and dynamic arrays, and handling pointers safely to avoid leaks and dangling pointers.

Understand the hazards of dynamic memory allocation in C++ on the heap, including memory leaks, dangling pointers, and fragmentation, and learn to pair new with delete and new[] with delete[].

Explore the hazards of dynamic memory allocation with real-world examples, including memory leaks, dangling pointers, and multiple deallocations, and learn safe cleanup using nullptr checks and proper deletion.

Learn how smart pointers in C++11 manage dynamic memory to prevent memory leaks and dangling pointers, including unique_ptr, shared_ptr, weak_ptr, and techniques like make_unique, use_count, and breaking cyclic references.

Master std::unique_ptr usage with make_unique, print addresses and values, and control ownership using get, reset, and release while avoiding dereferencing null pointers and not using new and delete.

Explore references in C++, learn that a reference is an alias for an existing object, enables pass-by-reference to avoid copying large data, and supports range-based for loops.

Learn how to return a pointer from a function by returning a variable's address, how dereferencing and printing affect values, and why returning a local variable's address is dangerous.

Explore passing by reference and its advantages over pointers, achieving direct access without dereferencing; learn how references share the same variable, use the ampersand, and when to use const.

Learn how to return a reference from a function in C++, observe that the reference shares memory with the original variable, and avoid returning local variables.

Discover input parameters and output parameters in c++: pass by value, const reference, and non-const references to control copying and modify originals, plus pointers and null-pointer considerations.

Create and use enumerated data types to define named constant sets, improving readability, type safety, and maintainability while avoiding magic numbers; explore unscoped and scoped enums and underlying types.

Explore how to create and access member variables and methods in a class using dot and arrow operators, including pointers, unique_ptr, and dereferencing in C++.

Learn how structs in C++ differ from classes with public default members and group related variables using lightweight structures. Define structs, create objects, and see examples in Visual Studio.

Explore declaring member methods inside a class and implementing them outside the class using the scope resolution operator, keeping the class body clean with prototypes and outside definitions.

Explore how constructors initialize class objects, overload them for default and parameterized cases, and how destructors release memory and resources as objects go out of scope or are deleted.

Explore how default constructors coexist with overloaded parameterized constructors in C++, including compiler-generated defaults and using = default for default initialization, with a Visual Studio example of a person.

Explore how a friend class can access private and protected members, explain non-symmetric and non-transitive friendship, and show explicit declarations that limit scope and enhance encapsulation.

Discover how private class members enable data hiding and encapsulation, and how getters and setters (accessors and mutators) control, access, and validate private data using get name and set name.

Discover how namespaces in C++ group related declarations to prevent naming conflicts, use the scope resolution operator, and organize code with custom namespaces like math and science.

Learn how a nested namespace defines a namespace inside another, allowing access via outer then inner namespaces such as science::add and science::math::average, demonstrated with a practical Visual Studio example.

Master inheritance to reuse code with superclass and derived classes, building a hierarchy from object to game entities and shapes. Apply polymorphism and hierarchical design to organize C++ Unreal projects.

Learn how protected class members sit between public and private, how public, protected, and private inheritance affect accessibility in derived classes, and how using can expose base members.

Explore how derived classes override base class methods to customize behavior, using animal, dog, and cat examples to show the overridden makesound and invoking base class methods.

Learn how virtual functions enable dynamic binding in C++ by overriding base class methods in derived classes, using pointers or references, and ensuring correct destruction with virtual destructors.

Understand how default arguments in virtual functions use static binding rather than dynamic binding, causing surprises when derived classes set different defaults; learn to avoid defaults or pass values explicitly.

Explore static_cast, a compile-time, explicit type conversion in C++, and how it enables safe downcasting between base and derived classes via pointers, with notes on data loss and safety.

Learn dynamic_cast for runtime downcasting of polymorphic classes, enabling access to non-virtual functions while safely handling null pointers. Explore base and derived relationships through practical account examples.

Learn the fundamentals of C++ from building your first program to variables, arrays, expressions, control flow, loops, functions, and pointers.

Learn to read user input in C++ with input streams, declare variables, and use cin and cout, while mastering extraction and insertion operators for a simple age program.

Learn how to insert new lines in a C++ program using endl and \n, control spacing with output and input, and resolve iostream namespace details in Visual Studio Code.

Explain how to document code for future programmers using single-line and multi-line comments in C++. Show how these comments prevent execution and how to finish multi-line comments correctly.

Learn how the C++ compiler translates code into binary and diagnose syntax, semantic, linker, runtime, and logical errors with practical examples and fixes.

Declare variables before use and assign values to memory locations, using an int variable storing 16, later updating to 25, then print with cout.

Learn about C++ variable types such as int, double, char, string, and boolean, with examples of storing integers, decimals, characters, words, and true/false values.

Master c++ variable naming rules by using letters, digits, and underscores; start with a letter or underscore; observe case sensitivity; avoid whitespace and reserved keywords in Visual Studio Code demonstrations.

Accessing the elements of an array in c++ using index brackets, initializing a char vowel array, and printing each element to demonstrate easy value retrieval.

Explore if-else statements in c++ unreal engine 5, using conditions, true or false branches, and else if to control program flow with examples like health checks.

Explore looping in C++, repeating code while a condition stays true, using while, do-while, and for loops for known and variable repetition.

Explains how the while loop in C++ executes a block while a condition is true, including decrementing a, printing values, and handling infinite loops and not-equal comparisons with user input.

Explore what a function is in programming, covering input, process, and output, and learn how reusable code simplifies tasks with C++ examples.

Acquire practical skills to write a function in C++, choose a return type, name the function, pass parameters, and build the function body, including return statements and void cases.

Explore pointers and const in C++, distinguishing a constant pointer from a pointer to a constant, and how each enforces immutability of either the pointer or the pointed value.

Understand references as aliases for existing objects, enabling pass-by-reference to avoid copying, with use in functions and range-based for loops, initialization, and const semantics, contrasted with pointers.

Master passing by reference in C++ using the ampersand, avoiding dereference, and seeing that references share the same memory location as the original; consider const to prevent changes.

Cover the basics of C++ syntax including the compiler and errors, variables (char, float, double), constants, arrays, expressions and statements, operators and operands, conditionals, loops, functions, parameters, and pointers.

Explore practical C++ fundamentals in a real program, declaring and modifying variables, handling string input for sentences and paragraphs, and applying flow control and for loops to enable function communication.

Describe how to define and organize functions in C++, implement a menu-driven program to convert messages to and from secret letters, and pass data via pointers and references.

Explore Unreal Engine 5 as the world's open, real-time 3D creation platform, showcasing photoreal visuals, immersive experiences, and open source access with C++ and Blueprint scripting options.

Create your first Unreal Engine 5 project using blueprint workflow with starter contents on desktop, learn naming rules (no spaces) and explore the interface.

Navigate Unreal Engine 5 with wsad for movement and e/q for up and down, rotate by holding right mouse button, focus objects, and adjust camera speed with the scroll wheel.

Explore Unreal Engine 5 viewport settings, including frame rate display, bookmarks, perspective and orthographic views, wireframe mode, and show flags to optimize world editing and gameplay visualization.

Explore post process volume in Unreal Engine 5 and how it controls scene effects such as auto exposure, bloom, and color grading in your game.

Explore the lighting system in Unreal Engine 5, including directional, point, spotlight, and skylights, and compare static, stationary, and movable lights with lumen and global illumination.

Create and shape landscapes in Unreal Engine 5 by sculpting terrain, forming mountains and caves, painting textures, and managing landscape components with versatile tools.

Paint foliage and rocks in the foliage mode of Unreal Engine 5, drag and drop assets into the ground, adjust density and scale, and manage library assets.

Discover how to place a C++ class in the Unreal Engine 5 world, convert it to a blueprint, and attach a static mesh component to the road component.

Configure Visual Studio Code for Unreal Engine projects, then open the pawn class header and source files. See public and protected sections, begin play, tick, and setup player input component.

Create a capsule component as a default sub object with a template function, compile to enable collision, and treat it as the road component to move all attached actors.

Master the UPROPERTY macro to expose C++ variables to Unreal Engine editor and memory management, using specifiers such as visible anywhere and edit anywhere to control visibility and editability.

Attach a camera to the car in Unreal Engine using a spring arm component in C++, adjust its length, and rely on collision handling to keep the camera in view.

Select player zero and possess the car as the default pawn, spawn the pawn at game start, and play from that pawn during gameplay.

Implement enhanced input in Unreal Engine 5 by creating an input mapping context and input action, then bind W and S to move the helicopter using a float value.

Integrate the input mapping context into the enhanced input local player subsystem during begin play. Obtain the local player, cast to a player controller, and add the mapping context.

Control car movement in Unreal Engine 5 by using add actor local offset, binding axis input, and distinguishing local offset from global offset to move with w and s.

Control car speed consistently across devices by using delta time instead of frame rate, multiplying speed by delta time with get world delta seconds in Unreal Engine.

Configure collision in Unreal Engine using ball sweep, overlap, and block all on capsules to prevent cars from passing through each other and walls.

Use a boolean isCarMoving to gate rotation: set true when move value is nonzero, false when zero, and rotate the car only while isCarMoving is true.

Explore Unreal Engine 5 basics by creating a class, distinguishing actor and components, configuring the camera and spring arm, handling input and logging, and using delta time, rotator, and vector.

Create a new empty level, add directional light, skylight, sky atmosphere, and test cubes to observe shadows before building lighting with volumetric clouds and exponential height fog, night mode.

Create a detailed map by assembling town assets from the Epic Games marketplace, snapping to a grid, and arranging roads, buildings, and foliage in Unreal Engine 5.

Develop a shooter character in Unreal Engine 5 with C++, covering character class, actor class, movement, animation, blueprint, blend space, shooting, muzzle and impact particles, line tracing, health, and damage.

Set up a third-person character in Unreal Engine 5 using a spring arm and camera, adjust the capsule and skeletal mesh, and position the camera for smooth movement and jumping.

Explore how to implement an animation blueprint in Unreal Engine five, linking skeletal meshes to walk, run, and idle states, and import or retarget animations for shooter characters.

Create a gun actor class with a skeletal mesh, then spawn it in the world from the shooter character using a tSubclassOf blueprint class and spawn actor, with compilation steps.

Attach the spawned gun to the character’s mesh using the gun socket on the right hand with relative transform rules, and set the owner in begin play.

Implement shooting in an Unreal Engine 5 game by wiring a gun actor to the shooter, binding a shoot action, and handling calls.

Learn to add muzzle flash particle effects to a weapon in Unreal Engine using spawn emitter attached, attaching to a socket, and selecting a particle system asset.

Execute a line trace by channel to determine the bullet impact point from the player's viewpoint, configure a trace channel, and visualize the impact with debug helpers in Unreal Engine.

Spawn an impact effect at the hit location using a spawn emitter at location with world context and a particle system template. Drive long-distance effects with hit location and rotator.

Learn to send and receive damage in Unreal Engine 5 using a point damage event, hit results, and a shooter override of take damage to update current health.

Build a basic ai shooter controller in unreal engine 5, make enemies focus on the player at begin play, and use gameplay statics to reference the player pawn.

Discover how to implement move to actor in unreal engine 5 using nav mesh, setting a goal and acceptance radius so AI follows player. Adjust movement speed and test pathfinding.

Learn to use LineOfSightTo function to detect if an actor can see another, then move toward that actor, set focus when visible, or stop movement and clear focus when not.

Learn to implement an AI control system with behavior trees and blackboard keys in Unreal Engine, wiring visual scripts and C++ to move agents and manage decisions.

Create a custom behavior tree shoot task in Unreal Engine five to add enemy shooting, wiring a custom task, execute task, and shooter character.

Configure FCollisionQueryParams to ignore the enemy's gun and owner, then perform a line trace by channel with a proper collision channel to prevent self-shooting in Unreal Engine 5.

Demonstrates a controller class with focus, move to actor, line of sight, eye movement, blackboard components, and a behavior three task enabling shooting with collision query params to avoid self-shooting.

Add and manage sound effects in Unreal Engine 5 using C++ and gameplay statics, attaching muzzle sounds and spawning impact sounds at a location to create immersive gunfire audio.

Learn to set up a game mode in Unreal Engine 5, implement kill logic in C++ and blueprints, and safely access game mode from world with a null pointer check.

Create a loser screen widget blueprint and display it on game end. Show a red 'you lost the game' message and add it to the viewport.

Add a health bar with a progress bar and text, bind it to a get health percentage function that returns current health over max health and changes color under 40%.

Learn to implement camera zoom with right-click by binding actions, adjusting the camera's field of view from 90 to 45 (and back), using blueprint and C++ in Unreal Engine.

Learn animation state machines for locomotion in Unreal Engine, enabling walk and run with shift, adjusting max walk speed from 300 to 600, and adding jumping via Blueprint and C++.

Create a police health bar using a user widget in Unreal Engine 5, bind the progress bar to health percentage, and color it red below 0.4 and green otherwise.

Connect widgets to c++ classes to read health, expose camera to blueprint, and implement color rules (green above 40, red below 30) and animation state machine (walk, run, jump, kill).