Movement & Rotation in Unreal Engine

Movement in Unreal Engine

Movement is usually processed in each frame, and as the frame time is not constant over time, movement is being used together with float DeltaTime value in Unreal Engine.

DeltaTime or also referred to as elapsed time is the time difference between the previous frame that was drawn and the current frame. Why is it so important? Shortly, by multiplying by DeltaTime we remove the dependence of the number of FPS (frames per second) on the speed of movement.

In Unreal Engine, DeltaTime is in seconds, then fps (frames per second) is calculate as fps = 1 / DeltaTime.

Deltatime value can be obtained by:

• It's a parameter of Tick function
• By asking UGameplayStatics::GetWorldDeltaSeconds(this);

Movement initializators

• Movement based on user's axes and actions input

  SetupPlayerInputComponent function is defined in APawn class (and so it's available in all classes inherited from APawn.

• AI Movement

  Functions MoveToLocation() and SimpleMoveToLocation() processes AI Movement using a NavMesh from current Location to a defined location.

• Movement with predefined trajectory and timing

  Trajectory can be processed through AI MoveToLocation movement between points from the trajectory table or by converting the defined trajectory into inputs.

Actors Movement

Following examples presents a movement processed through functions defined in AActor class. As so, they are available in all classes inherited from AActor.

Take into notice, e.g. a Character animation is not processed automatically based on the movement processed through the function.

• Example 1 - AActor::AddActorLocalOffset()

  AExample::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
  {
      Super::SetupPlayerInputComponent(PlayerInputComponent);
      PlayerInputComponent->BindAxis(TEXT("MoveForward"), this, &AExample::MoveForward);
      PlayerInputComponent->BindAxis(TEXT("TurnToSides"), this, &AExample::TurnRight);
  }
  void AExample::MoveForward(float value)
  {
      FVector DeltaLocation = FVector::ZeroVector;
      DeltaLocation.X = value * UGameplayStatics::GetWorldDeltaSeconds(this) * optionalSpeedCoefficient;
      bool bSweep = true;
      AddActorLocalOffset(DeltaLocation, bSweep);
      // If we work with a world space:
      //AddActorWorldOffset(DeltaLocation, bSweep);
  }
  void AExample::TurnRight(float value)
  {
      FRotator DeltaRotation = FRotator::ZeroRotator;
      DeltaRotation.Yaw = value * UGameplayStatics::GetWorldDeltaSeconds(this) * optionalTurnRateCoefficient;
      bool bSweep = true;
      AddActorLocalRotation(DeltaRotation, bSweep);
  }

• Example 2 - AActor::SetActorLocation()

  void AExampleClass::Tick(float DeltaTime)
  {
      FVector NewLocation = FMath::Lerp(StartLocation, TargetLocation, CurrentTime / MovementTime); 
      SetActorLocation(NewLocation, bSweep);
  }

Pawn Movement

• Example 1 - APawn::AddMovementInput()

  ASimulationCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
  {
      // proces parents' classes functionality
      Super::SetupPlayerInputComponent(PlayerInputComponent);
      // keyboard - axis - deltaTime included automatically by the class function
      PlayerInputComponent->BindAxis(TEXT("MoveForward"), this, &AExample::MoveForward);
      PlayerInputComponent->BindAxis(TEXT("MoveRight"), this, &AExample::MoveRight);
      // keyboard - actions
      PlayerInputComponent->BindAction(TEXT("Jump"), EInputEvent::IE_Pressed, this, &Character::Jump)
      // mouse
      PlayerInputComponent->BindAxis(TEXT("LookUp"), this, &APawn::AddControllerPitchInput);
      PlayerInputComponent->BindAxis(TEXT("LookRight"), this, &APawn::AddControllerYawInput);
      // controller
      PlayerInputComponent->BindAxis(TEXT("LookUpRate"), this, &ASimulationCharacter::LookUpRate);
  }                       
  void ASimulationCharacter::MoveForward(float AxisValue)
  {
      AddMovementInput(GetActorForwardVector() * AxisValue);
  }
  void ASimulationCharacter::MoveRight(float AxisValue)
  {
      AddMovementInput(GetActorRightVector() * AxisValue);
  }
  void ASimulationCharacter::LookUpRate(float AxisValue)
  {
      AddControllerPitchInput(AxisValue * RotationRate * GetWorld()->GetDeltaSeconds());
  }

  You may notice in the example above, that in a case of Jump we refer to ACharacter instead of to APawn as we do in a case of the looking based on mouse input. That's because Jump function is defined by AController and thus it is not available for APawn characters in default.

• Example 2 - UPawnMovementComponent::AddInputVector()

  Following example is used in the default Third Person Project Template in Unreal Engine. The pack features a playable character controlled by keyboard and mouse. Characters animations are included, processed through Mopvement Component that is native part of ACharacter.

  .h

  #pragma once
  #include "CoreMinimal.h"
  #include "GameFramework/Character.h"
  #include "InputActionValue.h"
  #include "MyProjectTmpCharacter.generated.h"
  
  UCLASS(config=Game)
  class AMyProjectTmpCharacter : public ACharacter
  {
  	GENERATED_BODY()
  
  	/** MappingContext */
  	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Input, meta = (AllowPrivateAccess = "true"))
  	class UInputMappingContext* DefaultMappingContext;
  
  	/** Jump Input Action */
  	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Input, meta = (AllowPrivateAccess = "true"))
  	class UInputAction* JumpAction;
  
  	/** Move Input Action */
  	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Input, meta = (AllowPrivateAccess = "true"))
  	class UInputAction* MoveAction;
  
  	/** Look Input Action */
  	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Input, meta = (AllowPrivateAccess = "true"))
  	class UInputAction* LookAction;
  
  public:
  	AMyProjectTmpCharacter();
  
  protected:
  
  	/** Called for movement input */
  	void Move(const FInputActionValue& Value);
  
  	/** Called for looking input */
  	void Look(const FInputActionValue& Value);	
  
  protected:
  	// APawn interface
  	virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
  	
  	// To add mapping context
  	virtual void BeginPlay();
  };

  .cpp constructor

  #include "MyProjectTmpCharacter.h"
  #include "Components/CapsuleComponent.h"
  #include "Components/InputComponent.h"
  #include "GameFramework/CharacterMovementComponent.h"
  #include "GameFramework/Controller.h"
  #include "EnhancedInputComponent.h"
  AMyProjectTmpCharacter::AMyProjectTmpCharacter()
  {
  	// Set size for collision capsule
  	GetCapsuleComponent()->InitCapsuleSize(42.f, 96.0f);
  		
  	// Don't rotate when the controller rotates. Let that just affect the camera.
  	bUseControllerRotationPitch = false;
  	bUseControllerRotationYaw = false;
  	bUseControllerRotationRoll = false;
  
  	// Configure character movement
  	GetCharacterMovement()->bOrientRotationToMovement = true; // Character moves in the direction of input...	
  	GetCharacterMovement()->RotationRate = FRotator(0.0f, 500.0f, 0.0f); // ...at this rotation rate
  
  	// Note: For faster iteration times these variables, and many more, can be tweaked in the Character Blueprint
  	// instead of recompiling to adjust them
  	GetCharacterMovement()->JumpZVelocity = 700.f;
  	GetCharacterMovement()->AirControl = 0.35f;
  	GetCharacterMovement()->MaxWalkSpeed = 500.f;
  	GetCharacterMovement()->MinAnalogWalkSpeed = 20.f;
  	GetCharacterMovement()->BrakingDecelerationWalking = 2000.f;
  
  	// Note: The skeletal mesh and anim blueprint references on the Mesh component (inherited from Character) 
  	// are set in the derived blueprint asset named ThirdPersonCharacter (to avoid direct content references in C++)
  }

  .cpp Movement

  void AMyProjectTmpCharacter::SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent)
  {
  	// Set up action bindings
  	if (UEnhancedInputComponent* EnhancedInputComponent = CastChecked<UEnhancedInputComponent>(PlayerInputComponent)) {
  		
  		//Jumping
  		EnhancedInputComponent->BindAction(JumpAction, ETriggerEvent::Triggered, this, &ACharacter::Jump);
  		EnhancedInputComponent->BindAction(JumpAction, ETriggerEvent::Completed, this, &ACharacter::StopJumping);
  
  		//Moving
  		EnhancedInputComponent->BindAction(MoveAction, ETriggerEvent::Triggered, this, &AMyProjectTmpCharacter::Move);
  
  		//Looking
  		EnhancedInputComponent->BindAction(LookAction, ETriggerEvent::Triggered, this, &AMyProjectTmpCharacter::Look);
  
  	}
  }
  
  void AMyProjectTmpCharacter::Move(const FInputActionValue& Value)
  {
  	// input is a Vector2D
  	FVector2D MovementVector = Value.Get<FVector2D>();
  
  	if (Controller != nullptr)
  	{
  		// find out which way is forward
  		const FRotator Rotation = Controller->GetControlRotation();
  		const FRotator YawRotation(0, Rotation.Yaw, 0);
  
  		// get forward vector
  		const FVector ForwardDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
  	
  		// get right vector 
  		const FVector RightDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);
  
  		// add movement 
  		//AddMovementInput(ForwardDirection, MovementVector.Y);
  		AddMovementInput(RightDirection, MovementVector.X);
  
  		UPawnMovementComponent* MovementComponent = GetMovementComponent();
  		MovementComponent->AddInputVector(ForwardDirection * MovementVector.Y);
  		//AIController* ai = Cast<AIController>(GetController());
  		
  		//GetController()->MoveToLocation
  		//AddActorLocalOffset(FVector(1.f, 0.f, 0.f), false);
  	}
  }
  
  void AMyProjectTmpCharacter::Look(const FInputActionValue& Value)
  {
  	// input is a Vector2D
  	FVector2D LookAxisVector = Value.Get<FVector2D>();
  
  	if (Controller != nullptr)
  	{
  		// add yaw and pitch input to controller
  		AddControllerYawInput(LookAxisVector.X);
  		AddControllerPitchInput(LookAxisVector.Y);
  	}
  }