How to make Character movement more adequate

Ok so basically, I’m working on the FPS tutorial that exists on UE4 programming tutorials. Besides all the hardships that I’ve gone through because of the tutorial being outdated, I noticed that the character movement is neat, but something bothered me a bit. In the tutorial, the forward movement of the character is based on getting the controller rotation, and then getting its X scaled axis.

FVector Direction = FRotationMatrix(Controller->GetControlRotation()).GetScaledAxis(EAxis::X);

and then the tutorial gives AddMovementInput the Direction and that’s basically it.

AddMovementInput(Direction, Value);

Now the thing that bothers me is that the movement speed changes by which angle I look at horizontally, so for example, if I look straight down or up, I won’t be able to move forward or backwards, and the more I look straight forward, the faster I move.
I’ve managed to come up with a pretty primitive solution, and that is by getting FPSMesh's* direction and adding it to the current Direction, all that while multiplying Direction by 2.

AddMovementInput(Direction*2+NewDirection, Value);

*FPSMesh is the Skeleton of the character

I first tried adding only the direction of the Skeleton, and that would’ve solved my problem, since when I look down or up my movement speed doesn’t change, but for some odd reason, when I try to move forward I move backwards and vice versa.(Note : Moving forward/Backwards using this method is also slower than usual.)

Now this almost solves my problem, but it just doesn’t seem right to me, and I was hoping that maybe one of you guys could offer me a more appropriate solution to this problem. Thanks.

Inserting the entirety of CPP file and H for anyone who wants to dig deeper:

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "Camera/CameraComponent.h"
#include "FPSCharacter.generated.h"

class FPSPROJECT_API AFPSCharacter : public ACharacter

	// Sets default values for this character's properties

	// Called when the game starts or when spawned
	virtual void BeginPlay() override;

	// Called every frame
	virtual void Tick(float DeltaSeconds) override;

	// Called to bind functionality to input
	virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
	//Adds Camera to edit
	    UCameraComponent* FPSCameraComponent;
	//Adds Body component
	UPROPERTY(VisibleAnywhere, Category = "Mesh")
		USkeletalMeshComponent* FPSMesh;
	// Handles input for moving forward and backward.
		void MoveForward(float Value);

	// Handles input for moving right and left.
		void MoveRight(float Value);

	// Sets jump flag when key is pressed.
		void StartJump();

	// Clears jump flag when key is released.
		void StopJump();
	//Shoots out FPSProjectile.
		void Fire();
	// Gun muzzle's offset from the camera location.
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Gameplay)
		FVector MuzzleOffset;
	// Projectile class to spawn.
	UPROPERTY(EditDefaultsOnly, Category = Projectile)
		TSubclassOf<class AFPSProjectile> ProjectileClass;


// Fill out your copyright notice in the Description page of Project Settings.

#include "FPSCharacter.h"
#include "FPSProjectile.h"
#include "Engine.h"
// Sets default values
 	// Set this character to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = true;
	// Create a first person camera component.
	FPSCameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("FirstPersonCamera"));
	// Attach the camera component to our capsule component.
	// Position the camera slightly above the eyes.
	FPSCameraComponent->SetRelativeLocation(FVector(0.0f, 0.0f, 50.0f + BaseEyeHeight));
	// Allow the pawn to control camera rotation.
	FPSCameraComponent->bUsePawnControlRotation = true;
	//Create a default mesh for our body
	FPSMesh = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("FirstPersonMesh"));
	//Attaching the camera to the body

// Called when the game starts or when spawned
void AFPSCharacter::BeginPlay()
	//Disabling some enviromental effects to preserve the illusion of having a singular mesh; NOTE::ENVIROMENTAL CHANGES CAN ONLY BE APPLIED IN THE BEGINNING OF THE SCENE, AND NOT IN THE CONFIGURATION.
	// The owning player doesn't see the regular (third-person) body mesh.
	if (GEngine) 
		// Put up a debug message for five seconds. The -1 "Key" value (first argument) indicates that we will never need to update or refresh this message.
		GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Yellow, TEXT("We are using FPSCharacter."));

// Called every frame
void AFPSCharacter::Tick(float DeltaTime)


// Called to bind functionality to input
void AFPSCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)

	// Set up "movement" bindings.
	PlayerInputComponent->BindAxis("MoveForward", this, &AFPSCharacter::MoveForward);
	PlayerInputComponent->BindAxis("MoveRight", this, &AFPSCharacter::MoveRight);
	// Set up "look" bindings.
	PlayerInputComponent->BindAxis("Turn", this, &AFPSCharacter::AddControllerYawInput);
	PlayerInputComponent->BindAxis("LookUp", this, &AFPSCharacter::AddControllerPitchInput);
	//Set up jumping
	PlayerInputComponent->BindAction("Jump", IE_Pressed, this, &AFPSCharacter::StartJump);
	PlayerInputComponent->BindAction("Jump", IE_Released, this, &AFPSCharacter::StopJump);
	//Set up Firing
	PlayerInputComponent->BindAction("Fire", IE_Pressed, this, &AFPSCharacter::Fire);
void AFPSCharacter::MoveForward(float Value) 
	// Find out which way is "forward" and record that the player wants to move that way.
	FVector Direction = FRotationMatrix(Controller->GetControlRotation()).GetScaledAxis(EAxis::X);
	FVector NewDirection = FRotationMatrix(FPSMesh->GetComponentRotation()).GetScaledAxis(EAxis::X);
	AddMovementInput(Direction*2+NewDirection, Value); //Works better than Direction/NewDirection alone.
	//AddMovementInput(CameraDirection, Value); //Same result as Direction.
void AFPSCharacter::MoveRight(float Value)
	// Find out which way is "right" and record that the player wants to move that way.
	FVector Direction = FRotationMatrix(Controller->GetControlRotation()).GetScaledAxis(EAxis::Y);
	AddMovementInput(Direction, Value);
void AFPSCharacter::StartJump()
	bPressedJump = true;
void AFPSCharacter::StopJump()
	bPressedJump = false;
void AFPSCharacter::Fire()
	// Attempt to fire a projectile.
	if (ProjectileClass)
		// Get the camera transform.
		FVector CameraLocation;
		FRotator CameraRotation;
		GetActorEyesViewPoint(CameraLocation, CameraRotation);

		// Transform MuzzleOffset from camera space to world space.
		FVector MuzzleLocation = CameraLocation + FTransform(CameraRotation).TransformVector(MuzzleOffset);
		FRotator MuzzleRotation = CameraRotation;
		// Skew the aim to be slightly upwards.
		MuzzleRotation.Pitch += 10.0f;
		UWorld* World = GetWorld();
		if (World)
			FActorSpawnParameters SpawnParams;
			SpawnParams.Owner = this;
			SpawnParams.Instigator = Instigator;
			// Spawn the projectile at the muzzle.
			AFPSProjectile* Projectile = World->SpawnActor<AFPSProjectile>(ProjectileClass, MuzzleLocation, MuzzleRotation, SpawnParams);
			if (Projectile)
				// Set the projectile's initial trajectory.
				FVector LaunchDirection = MuzzleRotation.Vector();