Complete Gaming Masterclass: Learn Unreal and GameMaker

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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 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.

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.

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.

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.

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.

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.