Character_movement_cpp_file

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


#include "Theo_movement.h"
#include "Components/InputComponent.h"
#include "GameFramework/Controller.h"
#include "GameFramework/CharacterMovementComponent.h"
#include "Camera/CameraComponent.h"
#include "GameFramework/Controller.h"
//#include "Components/CapsuleComponent.h"
#include "GameFramework/SpringArmComponent.h"


// Sets default values
ATheo_movement::ATheo_movement()
{

    // set our turn rates for input
    BaseTurnRate = 45.f;
    BaseLookUpRate = 45.f;

    // 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;

    //GetCharacterMovement()->bOrientRotationToMovement = true;
    //not going to let the player rotate the character, going to let the camera rotate which rotates the character. (Otherwise the character would rotate infron of a non-rotating camera. (Pitch is x axis)
    bUseControllerRotationPitch = false;
    //not going to let the player rotate the character, going to let the camera rotate which rotates the character. (Otherwise the character would rotate infron of a non-rotating camera. (Pitch is z axis)
    bUseControllerRotationYaw = false;
    //not going to let the player rotate the character, going to let the camera rotate which rotates the character. (Otherwise the character would rotate infron of a non-rotating camera. (Pitch is x axis)
    bUseControllerRotationRoll = false;

    UCharacterMovementComponent* const MovementComponent = GetCharacterMovement();
    if (MovementComponent)
    {
        MovementComponent->bOrientRotationToMovement = true;
        MovementComponent->bUseControllerDesiredRotation = false;
    }

    //This orients the character in the direction he is moving. b is a boolean.
    GetCharacterMovement()->bOrientRotationToMovement = true;
    //Rotation rate F stands for float
    GetCharacterMovement()->RotationRate = FRotator(0.0f, 540.0f, 0.0f);
    GetCharacterMovement()->JumpZVelocity = 600.0f;
    //Control that we have when character is in air
    GetCharacterMovement()->AirControl = 0.2f;

    //quotes in TEXT is a string
    CameraBoom = CreateDefaultSubobject<USpringArmComponent>(TEXT("CameraBoom"));
    //Rootcomponent is the capsule component in character blueprint - we are attaching the camera boom/camera to it (also can do in character bp)
    CameraBoom->SetupAttachment(RootComponent);
    //How far camera is away from character
    CameraBoom->TargetArmLength = 300.0f;
    //Rotate arm based on the controller -similar to what we disabled above for pitch, yaw and roll.
    CameraBoom->bUsePawnControlRotation = true;

    FollowCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("FollowCamera"));
    //Similar to attaching camera boom to root component. Camera is attached to boom which is what is holding the camera. Lets spring arm component do that for us.
    FollowCamera->SetupAttachment(CameraBoom, USpringArmComponent::SocketName);

    //No control to the follow camera by the pawn b/c we are giving that power to the camera/spring arm/cameraboom.
    FollowCamera->bUsePawnControlRotation = false;



}



// Called when the game starts or when spawned
//void ATheo_movement::SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent)
//void ATheo_movement::BeginPlay()
/**{
    Super::BeginPlay();

}

void ATheo_movement::LookUpAtRate(float Rate)
{
}

// Called every frame
void ATheo_movement::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

}

void ATheo_movement::StartJump()
{
    bPressedJump = true;
}

void ATheo_movement::StopJump()
{
    bPressedJump = false;
}
*/
// Called to bind functionality to input
void ATheo_movement::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    check(PlayerInputComponent);
    //The playerinputcomponenet is from ue4 and is used to perform axis bindings. Player INPUT component. Input is what the user is doing to control the character.
    //Super::SetupPlayerInputComponent(PlayerInputComponent);

    //Referencing player input component and using a 'arrow operator ->) to reference this variable. * is a pointer, which references the actual address in memory of what it is pointing to. -> is more logical to our brains b/c it is like a pointer but points to the variable/value associated
    //with what it is pointing to. Ex inputcomponent->bindaxis(turn), is referencing the value of the turn string inside the parenthesis. If it was a * it would be accessing the address in memory of the actual turn variable, not the variable iteself. No idea how to use *.

    //This is meaning it is going to be used in 'this' class. Meaning the class it is being referenced in (character, pawn actor, whatever it is used in). In this case Theo_movement.

    //Since we have inherited from the Character ACharacter in the public clas (look in header file under UCLASS() where ACharacter is referenced...&APawn:: is used. Not sure how these two things correlate.
    //Yaw input is the rotation on Zaxis. This is what axis the character rotates on if he were to turn. AddControllerYawInput allows him ot be controlled on yaw for the input function turn.
    PlayerInputComponent->BindAxis("Turn", this, &APawn::AddControllerYawInput);
    PlayerInputComponent->BindAxis("LookUp", this, &APawn::AddControllerPitchInput);

    PlayerInputComponent->BindAxis("LookUpRate", this, &ATheo_movement::LookUpAtRate);
    PlayerInputComponent->BindAxis("TurnRate", this, &ATheo_movement::TurnAtRate);

    //Binding Jump
    //IE_Pressed will detect when it is pressed, perhaps this is something that will need done for all action mappings?
    //ACharacter::Jump is something that is already referenced within ue4 for jumping purposes, not yet sure what its deal is
    PlayerInputComponent->BindAction("Jump", IE_Pressed, this, &ACharacter::Jump);
    //Released is how it knows when it the jump button is realesed...I would expect this means when it jumps, he can keep jumping until you release?
    PlayerInputComponent->BindAction("Jump", IE_Released, this, &ACharacter::StopJumping);


    //binding the axis for movement. Referencing the actual Theo_movement class name, curious why this is something we did not referenced for turn/lookup.
    PlayerInputComponent->BindAxis("MoveForward", this, &ATheo_movement::MoveForward);
    PlayerInputComponent->BindAxis("MoveRight", this, &ATheo_movement::MoveRight);

}

void ATheo_movement::TurnAtRate(float Rate)
{
    // calculate delta for this frame from the rate information
    AddControllerYawInput(Rate * BaseTurnRate * GetWorld()->GetDeltaSeconds());
}

void ATheo_movement::LookUpAtRate(float Rate)
{
    // calculate delta for this frame from the rate information
    AddControllerPitchInput(Rate * BaseLookUpRate * GetWorld()->GetDeltaSeconds());
}



void ATheo_movement::MoveForward(float Value)
{
    if ((Controller != NULL) && (Value != 0.0f))
    {
    //Need to calculate where is the forward direction? Getting the rotation from the controller, below this we will specify actual rotation axis that will be contorlled and numbers associated.
    const FRotator Rotation = Controller->GetControlRotation();
    //In the parenthesis, firs is (x, y and z) Below, turn on yaw I thought was Z so that is confusing b/c Y is referenced as yaw when in fact that is Z. Maybe tutorial guy mispoke.
    //I just realized that we are not just stating rotation (x,y,z), we are drilling down to yawrotation itself! This is a rotator function and the paremeters of yaw specifically...interesting.
    const FRotator YawRotation(0.0f, Rotation.Yaw, 0.0f);
    //Yawrotation below is being passed from the above statement. Vector is a variable that has xy and z. Rotation has xy and z as well. Get unit axis is getting the forward. X is forward. this gets us the forward direction of the player. In player blueprint, the forward arrow matches with the
    //green x arrow.
    const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
    //Movement input is self explanitory it passes the direction and passes the axis. Axis perameter- it will be passed depending on which way you go. ex forward is one and backward is negetive one. Whichever is being input it will be passed.
    AddMovementInput(Direction, Value);
    }
}

//Only change from copied above is Y instead of X as the get unit axis.
void ATheo_movement::MoveRight(float Value)
{
    if ((Controller != NULL) && (Value != 0.0f))
    {
        const FRotator Rotation = Controller->GetControlRotation();
        const FRotator YawRotation(0.0f, Rotation.Yaw, 0.0f);

        const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);
        AddMovementInput(Direction, Value);
    }
}