Complete Gaming Masterclass: Learn Unreal and GameMaker

Start a focused, interactive crash course to build a space shooter in the real engine, highlighting C++ for beginners to intermediates and setting up your project via Epic Games Launcher.

Set up Unreal projects, choose blank template, focus on code over blueprints, and learn editor basics—viewport, modes, content browser, world outline, details, and transform tools to build the space shooter.

Create a camera actor, set its position and rotation, and fix it by binding it in the level blueprint with begin play and view target with blend.

Design a simple player by creating a ship controller C++ class, adding a cube, and coloring it with a blue material to define the ship in the world, including collision.

Configure project input mappings for ship movement, adding move x and move y with keyboard keys and binding them to the ship controller, save the project and level.

Create a bullet by adding a C++ bullet controller class, a sphere with a yellow material, and set it to propel upward; plan to implement movement and shooting next.

Implement a bullet controller in Unreal that moves bullets forward each tick using speed and delta time, updates their location, and destroys them when they go out of the region.

Turn the bullet actor into a reusable blueprint, compile it, and create an instance that moves upward, then learn how to spawn bullets with space input in Unreal.

Enable space bar input to spawn bullets from the ship by wiring a shooting action to the ship controller, spawning bullet blueprints at the ship's location.

Create an enemy controller in C++ as an actor, give it a route box for collisions, and program movement and destruction when touching the player or bullets.

Master player-enemy collision in Unreal by wiring a ship controller overlap handler, detecting enemy actors, triggering death, hiding the player, and pausing the game for restart.

Implement bullet-enemy collision by wiring an overlap event in the bullet controller, destroy the bullet and the enemy on overlap, and prepare for spawning multiple enemies and the user interface.

Create a space shooter game mode in Unreal by converting enemies to blueprints, tracking elapsed time, and spawning enemies at timed intervals while increasing difficulty.

Demonstrates how to spawn enemies by creating a space shooter game mode blueprint, wiring a tick-based timer in C++, and configuring the world to spawn enemies using an enemy blueprint.

Spawn enemies at a rate of one every two seconds, shoot to destroy them, and prepare to add restart on collision in the next video.

Assign a restart key via settings and action mappings, then implement an on restart method in the ship controller to reload the current level when the player dies.

Build a game widget interface in Unreal Engine using C++ by adding a text block for score and status, game over with restart prompt, and spawning it via game mode.

Create a game widget blueprint by extending the user widget, add a text block, and adjust font size, color, and shadows to prepare for spawning in game mode.

Learn how to spawn a UMG widget in a space shooter game mode by declaring a widget class, creating or updating the current widget, and adding it to the viewport.

Spawn a widget on screen, manage score increments, and display a game over message when the game ends.

Implement interface wiring in the space shooter by binding increment score and on game over across the game mode, bullet, and ship controllers, then test and fix compilation.

Explore a beginner-friendly crash course that teaches layer switching, timing jumps to avoid red blocks, and reaching a powerful arm to win, while getting started with Unreal and GameMaker.

Set up an Unreal Engine project with the Epic Games launcher, start a side scroller template for a platform switcher, and explore basic editor concepts like actors and pawns.

Design a two-layer level by duplicating ledges, separating them into folders, and applying blue and orange materials to guide player movement between layers.

Create a dedicated game mode by writing a new C++ class, then build a main game mode blueprint, assign it in world settings, and prepare for subsequent coding.

Implement a switch mechanic in unreal using C++: declare begin play and tick, bind the switch action to Q, and move the player between two locations with set actor location.

Create an orb actor with a collision box in Unreal using C++, trigger game over on player overlap, and style with a purple material.

Create and integrate obstacle actors using C++ in Unreal, handle player overlap to trigger game over in the game mode, and implement an interface for win/lose messages with restart prompts.

Design and implement a game widget using Unreal’s UMG by creating a C++ widget class, building a blueprint, and dynamically instantiating it to display and update a text field.

Learn to spawn and swap on-screen widgets in Unreal Engine by implementing a blueprint-callable function, creating and casting widgets, and adding them to the viewport with proper error handling.

Wire the UMG game widget to trigger game over messages, update the text block for win or loss, and enable restart or timer-based challenges.

Implement a restart feature by mapping a restart key and wiring it in the main game mode to call on restart and reload the current level.

Learn to set up a new Unreal Engine project using the first-person shooter template, arrange a dedicated project folder, and explore the editor interface for coding in C++ and blueprints.

Create a shooter game mode that spawns enemies over time with a timer and variable intervals, using the player location and a circular spawn pattern that adjusts with game time.

Create and assign a blueprint-based game mode, link the enemy blueprint, and enable dynamic spawning in the world settings, then prepare to make enemies move and chase.

Spawn enemies that chase the player with a direction vector, speed, and delta time, and handle bullet collisions, memory-friendly destruction, scoring, and game over.

You set up overlap-based collisions for bullets against enemies, implement score increment hooks, and show the score along with game over and restart UI within Unreal's game mode.

Learn to implement a game interface in code using a C++ user widget, exposing a score text block, and adding load, set score, and game over with restart functionality.

Integrate the interface with the game mode by creating a blueprint-callable change widget function, managing the current widget, spawning new widgets, and updating loading and game over transitions.

Instantiate the game widget within the starting widget blueprint and launch the interface; shoot enemies to gain 100 points, with a 500-point game over and upcoming restart.

Configure a restart input in the project settings, map the restart action to a function, and reload the current level when the game is paused in Unreal.

Explore a beginner-friendly crash course that teaches you to survive waves of enemies by turning and shooting while guiding you through setting up the project with the Epic Games launcher.

Constrain the player in a turret shooter by disabling movement and jumping through Unreal's character movement settings, using the mouse to look and shoot, with blueprints to implement enemy interactions.

Design and implement an enemy with a collision box, move toward the player at a set speed, and handle projectile and player overlaps via an overlap function.

Learn to create a custom Unreal game mode in C++, implement a dynamic enemy spawn system around the player, adjust difficulty over time, and manage game over and restart.

Wire up health loss on player collisions, award score on projectile hits, and trigger game over when health reaches zero, while preparing a score and health display for a widget.

Create a game interface by building a user widget in C++, expose text block, bind it with blueprints, and implement set text and game over to show score and health.

Learn to dynamically spawn and manage game widgets using Unreal blueprints, including creating, loading, and updating a starting widget, and updating score and health text in a UMG interface.

Develop and wire a game interface widget, implement a restart function that reloads the current level, and trigger game over with input-based restart, while testing the full gameplay loop.

Join a beginner to intermediate crash course on game development, learn gravity to dodge enemies, survive, and set up your project with Epic Games editor and C++ code.

Set up Unreal Engine and project from the Epic Games launcher, choose a blank starter, code in C++ with Xcode, and explore the editor to place cubes and pawns.

Create a runner controller in Unreal Engine with a C++ class, define speed and gravity, implement begin play and tick, bind input, and add a collision box for future overlaps.

Design the runner with a collision box, blue material, and camera at -100, 270, 40 to view the player. Plan blocks and a game mode to track rules and score.

Create a main game mode with a C++ class defining begin play, tick, and game over, then blueprint it and set as the game mode override in world settings.

Master endless runner logic by creating a block controller that spawns ground and hazard blocks using Unreal C++ and blueprints, positioning blocks based on the player location and block distance.

Create three blueprints using the game block controller to build ground and hazard blocks. Set ground block size to 500, position a cube at z=12, scale to 0.15, and save.

Wire a game mode script with blueprints for ground and hazard blocks, set up the spawning field, adjust player speed, and build a moving level with hazards that end game.

Create a simple enemy in unreal by adding a C++ actor with a collision box, handling overlap to pause the game, and applying a red cube material.

Learn how to implement overlap collision between the runner and enemy by declaring an overlap method, using a collision box to emit events, and pausing the game on collision.

Transform the enemy into a blueprint, then add a child actor component to two hazard boxes with z positions of 70 and 120, and compile to test the enemy spawn.

Wire the enemy controller, adjust collision, keep the runner between 70 and 420, and call game over from the main game mode to pause the game.

Create a game widget by adding a user widget blueprint, placing a text block for the score, and wiring score updates using blueprints and game logic.

Implement a game widget by editing the header file, wiring a text block through the widget tree, and adding load, set score, and game over logic with restart.

Implement a change widget system in the game mode to spawn and swap widgets using blueprints, widget class references, and the load function, updating the score from player location.

Learn to implement a restart in Unreal by wiring a restart input to a controller function that opens the current level, handling pause states and testing the game over sequence.

Learn the basics of game maker, download and activate a free license, and start a project while exploring exporting to Android and iOS across platforms.

Organize each game in its own project folder, then create and manage sprites, objects, and rooms using the GameMaker interface, saving, running, and testing across platforms.

Create and configure an object by assigning a sprite, then wire events and actions to drive movement, growth, and interactions using keyboard and mouse inputs, without writing code.

Learn how games organize menus and gameplay into rooms in game maker, from splash screens to the main game. Create rooms, set size and speed, and add backgrounds and sprites.

Learn how to rotate a sprite in a game using create and step events. Use variables like rotating_speed and image_angle, plus equals assignments, and write comments for clarity.

Set an object's speed and direction to move it across the space, using x and y coordinates and image angle, with looping to keep it on screen.

Learn how to create and destroy object instances by cloning a smiley with instance_create, using x and y coordinates, and triggering clones with the space key.

Kick off a crash course on the Unreal Engine by building a simple game where a blue cube collects coins, learning collision, player input, and basic interface.

Learn the essentials of game maker studio through events and actions. Master basic movement and jumping, text on screen, bullets, and destroying targets in a beginner-friendly crash course.

Set up a game project with a dedicated folder and an events subfolder. Create a sprite and an object, place them in a room, and run to see the ghost.

Learn to use create and step events and actions in GameMaker to move a ghost with keyboard input, setting direction and speed, and test wrap-around behavior.

Apply friction to slow the ghost smoothly and implement a wrap screen action so the ghost reappears on the opposite edge, in both horizontal and vertical directions.

Explore jumping and stepping in game maker by using teleport to positions, jump start, and step toward with the space key to control the ghost.

Add an outside room event to the bullet object and use destroy instance to remove bullets when they leave the screen, testing with enter key to verify life cycle.

Demonstrate sprite transformations by changing sprites mid-game with enter, scaling objects on both axes, applying color tints, and warn about zero and default scales.

Explore how alarms work in game maker by creating a game controller, assigning alarms, and triggering events after a set step delay for doors, enemies, or spawns.

Learn to build an in-game interface that shows score, health, and time left by creating and applying a font, then drawing text at 20,20 on the GUI.

Learn coding basics in game maker by building a moving, rotating tank that collides with walls and shoots targets. Set up the project and obtain a free YoYo Games license.

Set up a new game maker project, organize a dedicated project folder, and create a tank sprite, object, and room to test a basic run of the game.

Learn to rotate a tank in GameMaker using left and right keys by adjusting the direction and image_angle in degrees, understanding 0–360 degrees and centering the sprite origin.

Learn to spawn bullets from a moving tank by creating a bullet object, instantiating it with the tank's position, setting speed and direction, and destroying it when outside the room.

Learn to add walls and targets, create wall and target objects, and implement collisions to stop the tank at walls and destroy bullets on hit, and destroy targets on impact.

Learn how to destroy bullets on wall collision and destroy both the bullet and the target on impact, using GameMaker collision events, instance_destroy, and scope changes to control targets.