The Complete 2020 Unreal Masterclass: Build 2D and 3D Games

Create a space shooter in unreal engine by setting up a blank project, coding a ship controller in C++, and modeling a colored cube ship with a fixed camera.

Configure input mappings for move X and move Y, implement ship movement with speed and velocity, then create a yellow sphere bullet as a blueprint and spawn it with space.

Create an enemy controller in Unreal using C++ with movement and collision handling, destroying bullets on contact and triggering game over when the player is hit.

Develop a space shooter game mode with blueprints and c++ that spawns enemies at timed intervals, and integrate a game widget to display score and restart the level.

Learn to build a space shooter UI in Unreal Engine by creating a game widget from a user widget, spawning it, and updating the score with game over handling.

Learn to build a two-layer platform switcher in Unreal Engine for beginners. Switch layers with a key to reach the purple orb while avoiding red blocks.

Learn to implement a platform switcher in Unreal Engine with header and C++ code, input binding, and player relocation, plus collision-based game over via an orb.

Create and wire an obstacle controller in C++, handle overlap to trigger game over, and build a widget-based interface using UMG to display messages.

Implement a runtime menu widget switcher in Unreal Engine by creating a change menu widget method, spawning and displaying new user widgets, and updating the current widget.

Learn to build a simple first-person shooter in Unreal Engine using C++ rather than blueprints, featuring spawning orange cubes that grant 100 points each and end the game on contact.

Build an FPS shooter game mode in Unreal Engine with C++ and blueprints. Spawn enemies on a dynamic timer, implement enemy chase, scoring, and game over logic.

Configure overlap bullet collisions to defeat enemies, increment score (100 points per hit), trigger game over, and implement a widget-based interface with restart via input mapping.

Launch the Epic Games launcher, create a new Unreal Engine project from the first-person shooter template, and set up a turret survival game with enemy spawns and shooting.

Builds a turret enemy that aims at the player and collides with projectiles, using a C++ header and cpp implementation, an overlap function, and blueprint spawning.

Build a turret game mode in Unreal with C++: implement begin play and tick, spawn enemies over time, manage score and health, and handle game over, restart, and blueprints.

Develop a turret UI in Unreal by creating a game widget, binding a score/health text block, updating it during play, and enabling restart via blueprint scripts and input bindings.

Learn to build an infinite runner in Unreal Engine by inverting gravity with a blue block, dodging red cubes, and implementing a runner controller in C++.

Create and integrate a main game mode with C++ and blueprints in Unreal, and implement dynamic block spawning, ground and hazard blocks, and loading for an infinite level.

Design and implement an enemy hazard in the runner switcher using a collision box, overlap events, and blueprints; pause the game on collision and prepare a game over interface.

Implement and bind a game widget in Unreal to display and update the score, show game over, and manage widget switching and restart via input.

Begin your Unreal Engine journey by creating a blank blueprint project with non-starter content and a first-person template, then explore world settings and run a playable demo with WASD.

Learn to move around the Unreal Engine using left, right, and middle mouse actions, hotkeys, and viewport options like top and perspective views, zoom, and toggle wireframe and lighting.

Move, rotate, and scale objects using transform handles, adjusting location and rotation along x, y, and z axes, with world versus object-relative rotation and the origin 0,0,0.

learn to add geometry to a scene in unreal, apply transforms and simulate physics, use box and sphere triggers, and prototype with 3D and 2D objects alongside a first-person camera.

Master unreal lighting by adding point lights, skylights, and spotlights; adjust intensity, color, and attenuation radius, explore inner and outer cones, reflections, and building lighting for accurate rendering.

Learn how to attach lights to objects in Unreal, add a point light or spotlight via the add component option, adjust color, intensity, attenuation, and see real-time results.

Learn to save your work frequently when building levels and maps in Unreal. Use save current and save current as to guard against power outages and data loss.

Explore blueprints, unreal's visual scripting, and how to set up an event begin play. Drop nodes, reference objects like a sphere, and experiment with destroying actors to see gameplay changes.

Learn how level blueprints and object blueprints manage level-wide versus object-specific functionality, including begin play, actor overlap, every tick, and self-reference to the object.

Modify components in the object tree by adjusting a point light's color with RGB, HSV, or hex values, and add or attach components to objects.

Introduce basics of variables in a visual scripting level blueprint, covering boolean, integer, float, string, and vector types. Apply concepts like is shooting, is dead, and lives for game logic.

Master variables in Unreal: set default values, compile blueprints, and use vectors, booleans, integers, floats, and strings, while understanding global versus local scope and naming conventions.

Learn to use Unreal variables with get and set to read or change is shooting, character name, and spawn coordinates, understand conversions between integers and floats, and booleans and integers.

Learn to print to the screen and to logs using variables, including promoting to variables, setting a log screen duration, and customizing the log color for debugging.

learn to rapid prototype games by building a quick first person level, testing ideas fast, iterating a maze layout, and saving multiple prototypes (p0 1) to refine the design.

Organize your Unreal project by moving maps into a prototypes folder, then prototype a maze-based lights-out game using cubes with point lights and rapid testing.

Learn to implement hit logic in Unreal Engine using on actor hit events and casting to first person projectile. Prototype by testing, wiring, and debugging to keep gameplay playable.

Implement a cube destruction counter by incrementing an integer and printing its value, wiring the destroyed cubes variable to the counter, then test and iterate with more cubes and obstacles.

Add a timer to track time elapsed by introducing a float time elapsed, incrementing it with a defined time interval, and printing updates to the log during rapid prototyping.

Round a timer in Unreal blueprints to two decimal places, using a two text float, print string, and various rounding modes to convert to the desired decimal place.

Add a point light to the first-person projectile, adjust intensity and attenuation, experiment with blue, yellow, and green colors, and prototype a blue spotlight via blueprints for a neon effect.

Vary a point light color in Unreal blueprints by using random float values for RGB channels and random float in range, demonstrating real-time color changes.

In this Unreal masterclass segment, learn to locate all spotlight actors, cast them, and set their color to turn off lights for rapid prototyping and testing in a dark room.

Wraps up rapid prototyping by showing how to build levels with light as a resource, shoot to navigate, and iterate to evaluate fun, refine level size, and explore neon aesthetics.

Create a shooting gallery prototype by setting up a new level, adjusting scale, placing the player start, adding geometry and lights, aligning walls, and prepping for the next material.

Set up a shooting gallery scene by duplicating walls to form a bench backdrop, adjust scale, and test blocking or jump disabling, then explore rapid prototyping for fun.

Learn to add and adjust blocking volumes for player collision, rapid prototype multiple shooting gallery layouts, switch perspectives, and iterate with lighting builds to refine level flow.

Prototype a small level and drop balls to test ball physics, gravity, and blueprint-based behavior. Build multiple spheres and refine their placement to explore rapid prototyping of a game mechanic.

Create a spawner that uses event begin play to spawn ball blueprints from a cube, with a timer and ignore collisions, while managing actor count for performance.

Learn to control collisions, spawn behaviors, and apply random impulses to game objects in Unreal blueprints, using variables for rapid prototyping.

Trigger a collision event (event hit) in a ball blueprint to destroy the ball with destroy actor on hit, keeping the projectile intact except in the first person projectile blueprint.

Add explosion effects to balls when they are destroyed by spawning an explosion actor from a blueprint, using the hit location vector and convert transform to place it at destruction.

Explore spawning objects in blueprints by spawning actors from a class on begin play using get actor transform, and chain multiple particle effects, smoke, steam, and fire.

Create a heads up display, bind a text widget to the first person character's balls destroyed variable, and update it as balls are destroyed.

Refactor unreal blueprints by moving logic into a dedicated ad impulse function and adding a count balls destroyed workflow with a transform input for spawn explosion.

Learn to add a timer to a first-person Unreal project by creating a timer variable, displaying it in the heads-up display, and binding it through the level blueprint.

Fix the prototype by adjusting the timer interval, choosing appropriate data types, and refining the heads-up display to create a functional shooting gallery game prototype running for 20 seconds.

Refine the prototype by adjusting layout and blue lighting, test variables like projectile speed, and embrace rapid prototyping to iterate, save, and name your levels for future projects.

Prototype the level by creating a shooting down scenario, adjust lighting, and fix blocking volumes to enable rapid iteration between shooting down and shooting up.

Learn how to disable collisions between the blocking volume and the first person projectile by configuring custom collision presets and object types in Unreal, then rapid prototype a shooting target.

Learn to disable collisions between the blocking volume and the first person projectile in Unreal by using custom collision presets and ignore-only object types for rapid prototyping.

Design a shooting gallery in Unreal Engine with a movable sphere target, and implement a ball blueprint with hit and destroy logic that spawns explosions.

Learn to implement a ball health system in Unreal, compare health to zero, destroy the actor when defeated, and use loops and transforms to spawn explosions and particles.

Learn to create a spawner blueprint that spawns ball actors from a class on begin play, using transform, world location, and an offset to control spawn positions.

Position a spawn point above the spawner using a reference scene and the event graph to spawn items at that point.

Learn to implement a scoring system in Unreal by tracking total points, ball hit points, and ball destruction points, updating the score when balls are hit or destroyed.

Refactor your Unreal project by factoring logic into functions like add two points ball hit and add two points ball destroyed, improving blueprint readability and reuse.

Learn to build a kill all balls blueprint that destroys all ball actors when hit, using get all actors of class and a for each loop to process the array.

Troubleshoot and fix explosion spawning in Unreal blueprints by wiring event destroyed to spawn explosions, resolve duplicate spawns, and reset the ball transform for accurate explosion effects.

Optimize explosions by enlarging a single explosion instead of spawning multiple ones, reducing lag on mobile; discuss particles, loops, and avoiding overuse of explosions for better performance.

Create a blue bouncing ball blueprint with gravity and a blue sphere, destroy on hit, spawn an explosion, and award total points to the first-person player.

Experiment with no gravity by simulating physics with gravity disabled for objects, and explore rapid prototyping, material organization, and gravity-based level design ideas.

Create a blue ball spawner in Unreal using blueprints, spawn a bouncing ball with impulse on start, adjust spawn locations, and manage collisions in the event graph.

Explore adding impulse to spawn points by using a scene component, configuring velocity changes, and applying random impulse values to spawn a ball with varied arc.

Implement a timer by adding a spawn time min and max range to delay blue ball spawns, configure begin play, and observe the timed shoot fest.

Demonstrate two methods to destroy balls in Unreal: destroy white balls and blue balls via get all actors of class, or create a dedicated destroy all balls function and test.

Figure out a purple ball spawning system in Unreal using a spawn point, blueprint logic, and delayed spawn to shoot down targets while adjusting physics and collisions.

Wrap up this tutorial by prototyping the second shooter, add a timer and a heads up display, and organize and save prototypes to reinforce iterative development.