Unreal Engine 5 :Create game in C++ and blueprint (Beginner)

Create a blank blueprint project in Unreal Engine using the Epic Game Launcher and Visual Studio, desktop quality, no ray tracing, named jumpy bp, to compare blueprint with C++.

Open Unreal Engine, create a new blank C++ project named jumpy (with blueprint version jumpy bp), save in the default one document Unreal Engine project, and Visual Studio opens.

Import static meshes, effects, and a character into your Unreal Engine 5 project, extract the zip file, and paste the folders into the content directory for blueprint and C++ projects.

Create a playable character class in Unreal Engine 5 with blueprint, then implement in C++. Align a skeletal mesh with the forward vector and capsule, add spring arm and camera.

Create a blueprint game mode from game mode base, set the BP jumpy character as the default pawn, then override the default game mode in settings and save the level.

Control a character in Unreal Engine 5 with enhanced input, moving via w a s d and looking with the mouse, using an input mapping context and move action.

Explore how to use modifiers in Unreal Engine 5's input system to map D, A, W, S keys to X and Y axes using negate and swizzle input axis value.

Learn to read enhanced input in Unreal Engine 5, break the vector 2D into x and y, and use branches to print right or left movement.

Use a sequence node and branches to evaluate the Y value and determine movement direction. Print strings indicate 'going forward' or 'going backward' for beginner-level Unreal Engine scripting.

Learn to move a character in unreal engine 5 using the character movement component, add movement input with -1 to 1 scale, mapping W/S for forward/backward and D/A for right/left.

Teach how to map player input to character movement using get control rotation, forward and right vectors, converting rotation to direction, and wiring left-right (a/d) and forward-backward controls.

Create a 2d input action for mouse look and map it to the enhanced input. Use mouse x to drive yaw and test with a print for left-right rotation.

Add controller pitch input to look up and down by rotating on the Y axis, using a spring arm with pawn control rotation, and negate the Y input.

Improve movement in Unreal Engine 5 by using yaw only for forward and right vectors, ensuring consistent speed when looking up or down.

Create a jump input action in Unreal Engine 5 using blueprint, map the spacebar in the input mapping context, and enable jumping in character movement, with a C++ section.

Review blueprint recap: initialize beginplay and input mapping, add movement and mouse-look inputs, implement jumping, add camera and spring arm, and set game mode to bp jumpy character for c++.

Create a c++ character class in Unreal using the c++ class tool, inheriting from character, naming it jumpy character, with h and cpp files in public and private source folders.

Learn how to build C++ codes in Unreal Engine using Visual Studio, including build solution, rebuild solution, clean solution, and live recompile options for faster on-the-fly coding.

Explore using c++ comments to simplify code and document ideas, using // for single-line notes and /* multi-line blocks */ for block comments, which the compiler ignores.

Explore blueprint and C++ workflows for adding components like the spring arm and camera, noting blueprint auto-creates component variables while C++ requires manual header and construction script setup.

Create a USpringArmComponent* variable in a private section, include its header, annotate with UPROPERTY visible anywhere, then build and add the spring arm to the hierarchy.

Initialize the spring arm in the character construction script using createDefaultSubobject, name it my spring arm, and attach it to the root component via setupAttachment, then compile to apply changes.

Visualize our c++ code by creating bp jumpy game mode and bp jump character, test the spring arm, and combine c++ with blueprint for faster, optimized development.

Include the camera component header, declare a UCameraComponent* variable, and annotate with UPROPERTY. Create a default subobject, name it, and attach it to the spring arm with setup attachment.

Save and organize levels, set the main level in maps and modes, and configure editor preferences to open in the main window for a smoother Unreal Engine 5 workflow.

Discover how to attach a camera to a spring arm in Unreal Engine 5 using the attach to component approach, with FAttachmentTransformRules preserving the relative transform in C++ and Blueprint.

Modify component properties in blueprint, such as spring arm length, end offset, and character movement speed. Then learn to mirror these changes in C++ code.

Change spring arm length to 500 in C++, set socket offset to (0,0,120), and enable use pawn control rotation; then build and run to see the character on the ground.

Change default c++ settings by turning off use controller rotation for pitch, yaw, and roll; build and verify the jumpy character and spring arm, with max walk speed 500 cm/s.

Change character movement settings in Unreal Engine 5 using C++ to set max walk speed and orient rotation to movement while blueprint may overwrite C++ changes.

Define an enhanced input mapping context and move input action, mapping WASD to a vector 2D via axis 2D with negate and swizzle modifiers in C++ and blueprint.

Acquire and cast the player controller in C++ during begin play and set up the enhanced input local player subsystem mapping context, mirroring the blueprint approach.

Learn how to access the enhanced input subsystem from the player controller, cast and validate the controller, then retrieve the enhanced input local player subsystem to add the mapping context.

Add an input mapping context (IMC) in c++, expose it to blueprints, and pass its address from blueprint to c++. Ensure the subsystem is valid and IMC is editable anywhere.

Learn how to use UPROPERTY macros like visible anywhere and edit anywhere to expose and edit variables in Unreal Engine, and assign custom categories for clearer in-editor organization.

Debug Unreal Engine 5 games by printing begin play to the log with UI log in C++, using text macros and warning level, then build and check the output log.

Learn to log values in Unreal Engine 5 using UE_LOG with verbosity levels and format specifiers for float, integer, and vector values, and reuse snippets for quick debugging.

master creating and implementing c++ functions in unreal engine 5 with header prototypes and cpp definitions, then enable w a s d keyboard movement using these functions.

Pass an enhanced input action to C++ by exposing a UInputAction with UPROPERTY, then map movement keys like W A S D to move a character in Unreal Engine 5.

Bind the W, A, S, D input actions to a move function using enhanced input component in Unreal Engine, showing 'move triggered' when the action fires.

Capture input as a 2d vector with f vector 2d, store it in receive value, and display the x and y components when pressing w, a, s, d.

Master FVector and vector 2D in Unreal Engine 5, including initializing x, y, z with a temp variable. Verify changes by building and running the project.

Derive the forward and right vectors from the control rotation using F rotator, F rotation matrix, and get unit axis, then drive movement with add movement input using WASD.

Learn to derive the forward vector in Unreal Engine 5 using blueprint by using control rotation yaw with pitch and roll zero, and simplify code for forward and backward movement.

Explore implementing the right vector in Unreal Engine 5 with C++, deriving it from the forward and right vectors and adjusting the control rotation for yaw and roll.

Implement a look action with enhanced input, using a vector 2D mapped to the mouse X and Y, and bind it in blueprint and C++ for camera control.

Learn to implement look around in Unreal Engine 5 using C++ and blueprint. Map vertical input to pitch and horizontal input to yaw with enhanced input vector 2D, then test.

Create a jump action in Unreal Engine by wiring an input action in C++ and Blueprint, then bind it to a jump function triggered by the space key.

Import and organize FBX animations in Unreal Engine 5 using blueprint (then in C++), create an animation folder, and apply idle, run, jump, fall, land, and lean motions.

Learn unreal engine 5 character animation with an animation blueprint and a state machine to loop idle and switch to run based on velocity.

Create a run state in the animation blueprint's state machine, swap idle to run within ground locomotion based on ground speed, and derive speed from velocity via rules.

Build a blend space with horizontal lean amount (-1 to 1) and vertical ground speed (0 to 500); apply it in the animation blueprint's run state.

Calculate the lean amount from the delta rotation between frames using last and current rotations with a delta rotator. Implement a calc lean amount function and apply it to locomotion.

Use the finterp to node to smoothly change the line amount from current to target with delta time. Adjust lean left and lean right connections to choose the direction.

Create an air locomotion state machine in Unreal Engine 5 to drive the jump animation and use saved cached poses for ground locomotion.

Add a jump state from ground locomotion using is falling to trigger jump on space or while airborne, then return when not in air; combine idle and run jump animations.

Create a blend space using ground speed to switch between idle jump and run jump, then wire it into the animation blueprint and disable looping for a single jump.

Create a full state in the animation blueprint and loop its animation. Enable transitions: jump to fall when the jump finishes, and fall to ground locomotion when not on air.

Create two animation states, land idle and land run, and return to ground locomotion after landing. Use movement input length to decide idle or run based on player input.

determine land idle or land run states by checking whether the character is on air and if there is movement input, using not and and booleans, then implement in c++.

Master animation in Unreal Engine 5 by implementing an anim instance in C++ and linking an animation blueprint, state machines, sequence players, and blend spaces to drive looping character animations.

Build a ground locomotion state machine to drive idle and run animations in Unreal Engine 5, with looped animations and speed-based transitions to output pose.

Override the native update animation in c++ by declaring virtual void native update animation(float delta seconds) override in the header and implementing it in cpp, then test with a log.

Override native initialize animation in Unreal Engine 5 using c++ to cache the pawn owner and access the character movement component for efficient updates (blueprint initialization noted).

learn to get the pawn owner, cast it to the jumpy character, and expose it as a blueprint read-only pointer for the movement component.

Learn to access the character movement component in Unreal Engine 5 using C++, expose it as a blueprint read-only property, and test movement speed with UI logs in gameplay.

learn to get velocity, speed, and ground speed in unreal engine 5 using blueprint and c++, by reading velocity from the movement component and displaying its length as speed.

Compute velocity length in Unreal Engine with C++ and the Kismet Math Library, exposing ground speed via UPROPERTY for blueprint access and testing to drive animations.

Calculate ground speed in C++, expose it as blueprint read-only, and drive the idle-to-run transitions in the animation graph, with a tolerance near zero for returning to idle.

Explain lean animation by calculating lean amount from the rotation delta around the z axis, smoothing with interpolation, and driving a blend space with -1 to 1.

Create a lean blend space using horizontal lean amount (-1 to 1) and vertical ground speed (0 to 500) to drive run and lean in the ABP jumpy run state.

Learn to compute lean by comparing last and current frame rotations in blueprint and C++, save the lean amount, and use yaw from the actor rotation to drive the lean.

Calculate lean amount by comparing last frame rotation with current frame rotation using delta rotator from Kismet Math Library, then apply yaw-based lean with smoothing via interpolation.

Learn to smoothly interpolate a character's lean using the Kismet Math Library's FInterpTo in both blueprint and C++, updating lean amount each frame with delta time and a set speed.

Implement jumping in C++ alongside blueprint by creating an air locomotion state machine. Use a cached pose from ground locomotion to drive the jump and keep the project organized.

Add a jump state to the ground locomotion system in Unreal Engine 5, use is_falling to set an in_air boolean, and implement two transitions: ground to jump and back.

Create and configure a blend space in Unreal Engine 5 to smoothly blend idle jump and run jump by ground speed, and disable looping to reduce jerkiness.

Create a fall state to loop the fall animation after jumping, enabling transition from fall to ground locomotion when not in air, and test with a cliff using surface snapping.

Learn to implement two land states, idle land and land run, in unreal engine 5 using blueprint and c++, with transition to ground locomotion after landing and input-driven state changes.

Use land state rules in Unreal Engine 5: not on air with no movement input moves to land idle; not on air with movement input moves to land run.

Create a blueprint actor for a moving platform in Unreal Engine 5 using a spline path and an interp to movement component to move a static mesh along defined points.

Move a platform along a spline by adding points, retrieving local spline locations, and visualizing them with draw debug spheres, using blueprint loops to handle any point count.

Add spline-based control points to a moving platform via interpreter movement in Unreal Engine, using local space locations, 7 points, duration, and ping-pong behavior to travel along a static mesh.

Explore controlling moving platforms with duration in blueprint by creating a duration variable, exposing it on spawn, and applying it to movement, then implement in C++.

Create a moving platform in Unreal Engine 5 using C++ by making an actor, adding a static mesh and a spline to mark start and end points, and implement movement.

Add a static mesh component in C++ by including UStaticMeshComponent, creating it with CreateDefaultSubobject, and attaching it to the root to enable blueprint visibility and local-space movement.

Create a default scene root as a scene component in C++, attach a static mesh to the root, and expose it to blueprint for spline and movement setup.

Learn to add a spline component and an interp movement component in Unreal Engine 5, attach them to a route, create spline points, and drive a platform along the path.

learn to get spline point locations and feed them to the interpreter movement component using blueprint and cpp, looping over points and obtaining local-space positions.

Set up movement interpolation by adding spline point locations to the movement component, enable ticking, and finalize control points; then adjust duration and set behavior to ping pong.

Expose a duration parameter in Unreal Engine 5 by adding a float duration in the header, with UPROPERTY(EditAnywhere, Category=Settings) and a default of 1 to control timing.