View difference between Paste ID: M8JSqrE2 and cC6S6X0u

 // Copyright 1998-2014 Epic Games, Inc. All Rights Reserved.
 
 #include "InvSystem.h"
 #include "InvSystemCharacter.h"
 #include "InvSystemProjectile.h"
 
 //////////////////////////////////////////////////////////////////////////
 // AInvSystemCharacter
 
 AInvSystemCharacter::AInvSystemCharacter(const class FPostConstructInitializeProperties& PCIP)
 	: Super(PCIP)
 {
 	// Set size for collision capsule
 	CapsuleComponent->InitCapsuleSize(42.f, 96.0f);
 
 	// set our turn rates for input
 	BaseTurnRate = 45.f;
 	BaseLookUpRate = 45.f;
 
 	// Create a CameraComponent
 	FirstPersonCameraComponent = PCIP.CreateDefaultSubobject<UCameraComponent>(this, TEXT("FirstPersonCamera"));
 	FirstPersonCameraComponent->AttachParent = CapsuleComponent;
 	FirstPersonCameraComponent->RelativeLocation = FVector(0, 0, 64.f); // Position the camera
 
 	// Default offset from the character location for projectiles to spawn
 	GunOffset = FVector(100.0f, 30.0f, 10.0f);
 
 	// Create a mesh component that will be used when being viewed from a '1st person' view (when controlling this pawn)
 	Mesh1P = PCIP.CreateDefaultSubobject<USkeletalMeshComponent>(this, TEXT("CharacterMesh1P"));
 	Mesh1P->SetOnlyOwnerSee(true);			// only the owning player will see this mesh
 	Mesh1P->AttachParent = FirstPersonCameraComponent;
 	Mesh1P->RelativeLocation = FVector(0.f, 0.f, -150.f);
 	Mesh1P->bCastDynamicShadow = false;
 	Mesh1P->CastShadow = false;
 
 	// Note: The ProjectileClass and the skeletal mesh/anim blueprints for Mesh1P are set in the
 	// derived blueprint asset named MyCharacter (to avoid direct content references in C++)
 
 	MaxUseDistance = 800;
 	bHasNewFocus = true;
 }
 
 /*
 Performs raytrace to find closest looked-at UsableActor.
 */
 AUsableActor* AInvSystemCharacter::GetUsableInView()
 {
 	FVector camLoc;
 	FRotator camRot;
 
 	if (Controller == NULL)
 		return NULL;
 
 	Controller->GetPlayerViewPoint(camLoc, camRot);
 	const FVector start_trace = camLoc;
 	const FVector direction = camRot.Vector();
 	const FVector end_trace = start_trace + (direction * MaxUseDistance);
 
 	FCollisionQueryParams TraceParams(FName(TEXT("")), true, this);
 	TraceParams.bTraceAsyncScene = true;
 	TraceParams.bReturnPhysicalMaterial = false;
 	TraceParams.bTraceComplex = true;
 
 	FHitResult Hit(ForceInit);
 	GetWorld()->LineTraceSingle(Hit, start_trace, end_trace, COLLISION_PROJECTILE, TraceParams);
 
 	return Cast<AUsableActor>(Hit.GetActor());
 }
 
 /*
 Update actor currently being looked at by player.
 */
 void AInvSystemCharacter::Tick(float DeltaSeconds)
 {
 	Super::Tick(DeltaSeconds);
 
 	if (Controller && Controller->IsLocalController())
 	{
 		AUsableActor* usable = GetUsableInView();
 
 		// End Focus
 		if (FocusedUsableActor != usable)
 		{
 			if (FocusedUsableActor)
 			{
 				FocusedUsableActor->EndFocusItem();
 			}
 
 			bHasNewFocus = true;
 		}
 
 		// Assign new Focus
 		FocusedUsableActor = usable;
 
 		// Start Focus.
 		if (usable)
 		{
 			if (bHasNewFocus)
 			{
 				usable->StartFocusItem();
 				bHasNewFocus = false;
 			}
 		}
 	}
 }
 
 /*
 Runs on Server. Perform "OnUsed" on currently viewed UsableActor if implemented.
 */
 void AInvSystemCharacter::Use_Implementation()
 {
 	if (FocusedUsableActor)
 	{
 		FocusedUsableActor->OnUsed(this);
 	}
 }
 
 bool AInvSystemCharacter::Use_Validate()
 {
 	// No special server-side validation performed.
 	return true;
 }
 
 //////////////////////////////////////////////////////////////////////////
 // Input
 
 void AInvSystemCharacter::SetupPlayerInputComponent(class UInputComponent* InputComponent)
 {
 	// set up gameplay key bindings
 	check(InputComponent);
 
 	InputComponent->BindAction("Jump", IE_Pressed, this, &ACharacter::Jump);
 
 	InputComponent->BindAction("Fire", IE_Pressed, this, &AInvSystemCharacter::OnFire);
 	InputComponent->BindTouch(EInputEvent::IE_Pressed, this, &AInvSystemCharacter::TouchStarted);
 
 	InputComponent->BindAxis("MoveForward", this, &AInvSystemCharacter::MoveForward);
 	InputComponent->BindAxis("MoveRight", this, &AInvSystemCharacter::MoveRight);
 
 	// We have 2 versions of the rotation bindings to handle different kinds of devices differently
 	// "turn" handles devices that provide an absolute delta, such as a mouse.
 	// "turnrate" is for devices that we choose to treat as a rate of change, such as an analog joystick
 	InputComponent->BindAxis("Turn", this, &APawn::AddControllerYawInput);
 	InputComponent->BindAxis("TurnRate", this, &AInvSystemCharacter::TurnAtRate);
 	InputComponent->BindAxis("LookUp", this, &APawn::AddControllerPitchInput);
 	InputComponent->BindAxis("LookUpRate", this, &AInvSystemCharacter::LookUpAtRate);
 	InputComponent->BindAction("Use", IE_Pressed, this, &AInvSystemCharacter::Use);
 }
 
 void AInvSystemCharacter::OnFire()
 {
 	// try and fire a projectile
 	if (ProjectileClass != NULL)
 	{
 		const FRotator SpawnRotation = GetControlRotation();
 		// MuzzleOffset is in camera space, so transform it to world space before offsetting from the character location to find the final muzzle position
 		const FVector SpawnLocation = GetActorLocation() + SpawnRotation.RotateVector(GunOffset);
 
 		UWorld* const World = GetWorld();
 		if (World != NULL)
 		{
 			// spawn the projectile at the muzzle
 			World->SpawnActor<AInvSystemProjectile>(ProjectileClass, SpawnLocation, SpawnRotation);
 		}
 	}
 
 	// try and play the sound if specified
 	if (FireSound != NULL)
 	{
 		UGameplayStatics::PlaySoundAtLocation(this, FireSound, GetActorLocation());
 	}
 
 	// try and play a firing animation if specified
 	if(FireAnimation != NULL)
 	{
 		// Get the animation object for the arms mesh
 		UAnimInstance* AnimInstance = Mesh1P->GetAnimInstance();
 		if(AnimInstance != NULL)
 		{
 			AnimInstance->Montage_Play(FireAnimation, 1.f);
 		}
 	}
 
 }
 
 void AInvSystemCharacter::TouchStarted(const ETouchIndex::Type FingerIndex, const FVector Location)
 {
 	// only fire for first finger down
 	if (FingerIndex == 0)
 	{
 		OnFire();
 	}
 }
 
 void AInvSystemCharacter::MoveForward(float Value)
 {
 	if (Value != 0.0f)
 	{
 		// add movement in that direction
 		AddMovementInput(GetActorForwardVector(), Value);
 	}
 }
 
 void AInvSystemCharacter::MoveRight(float Value)
 {
 	if (Value != 0.0f)
 	{
 		// add movement in that direction
 		AddMovementInput(GetActorRightVector(), Value);
 	}
 }
 
 void AInvSystemCharacter::TurnAtRate(float Rate)
 {
 	// calculate delta for this frame from the rate information
 	AddControllerYawInput(Rate * BaseTurnRate * GetWorld()->GetDeltaSeconds());
 }
 
 void AInvSystemCharacter::LookUpAtRate(float Rate)
 {
 	// calculate delta for this frame from the rate information
 	AddControllerPitchInput(Rate * BaseLookUpRate * GetWorld()->GetDeltaSeconds());
 }