void UCheatManager::DestroyTarget()
{
APlayerController* const MyPC = GetOuterAPlayerController();
if ((MyPC == NULL) || (MyPC->PlayerCameraManager == NULL))
{
return;
}
check(GetWorld() != NULL);
FVector const CamLoc = MyPC->PlayerCameraManager->GetCameraLocation();
FRotator const CamRot = MyPC->PlayerCameraManager->GetCameraRotation();
FCollisionQueryParams TraceParams(NAME_None, true, MyPC->GetPawn());
FHitResult Hit;
bool bHit = GetWorld()->LineTraceSingle(Hit, CamLoc, CamRot.Vector() * 100000.f + CamLoc, ECC_Pawn, TraceParams);
if (bHit)
{
check(Hit.GetActor() != NULL);
APawn* Pawn = Cast<APawn>(Hit.GetActor());
if (Pawn != NULL)
{
if ((Pawn->Controller != NULL) && (Cast<APlayerController>(Pawn->Controller) == NULL))
{
// Destroy any associated controller as long as it's not a player controller.
Pawn->Controller->Destroy();
}
}
Hit.GetActor()->Destroy();
}
}
/*
Performs ray-trace to find closest looked-at UsableActor.
*/
ASUsableActor* ASCharacter::GetUsableInView()
{
FVector CamLoc;
FRotator CamRot;
if (Controller == nullptr)
return nullptr;
Controller->GetPlayerViewPoint(CamLoc, CamRot);
const FVector TraceStart = CamLoc;
const FVector Direction = CamRot.Vector();
const FVector TraceEnd = TraceStart + (Direction * MaxUseDistance);
FCollisionQueryParams TraceParams(TEXT("TraceUsableActor"), true, this);
TraceParams.bTraceAsyncScene = true;
TraceParams.bReturnPhysicalMaterial = false;
/* Not tracing complex uses the rough collision instead making tiny objects easier to select. */
TraceParams.bTraceComplex = false;
FHitResult Hit(ForceInit);
GetWorld()->LineTraceSingleByChannel(Hit, TraceStart, TraceEnd, ECC_Visibility, TraceParams);
//DrawDebugLine(GetWorld(), TraceStart, TraceEnd, FColor::Red, false, 1.0f);
return Cast<ASUsableActor>(Hit.GetActor());
}
AActor* USCarryObjectComponent::GetActorInView()
{
APawn* PawnOwner = Cast<APawn>(GetOwner());
AController* Controller = PawnOwner->Controller;
if (Controller == nullptr)
{
return nullptr;
}
FVector CamLoc;
FRotator CamRot;
Controller->GetPlayerViewPoint(CamLoc, CamRot);
const FVector TraceStart = CamLoc;
const FVector Direction = CamRot.Vector();
const FVector TraceEnd = TraceStart + (Direction * MaxPickupDistance);
FCollisionQueryParams TraceParams(TEXT("TraceActor"), true, PawnOwner);
TraceParams.bTraceAsyncScene = true;
TraceParams.bReturnPhysicalMaterial = false;
TraceParams.bTraceComplex = false;
FHitResult Hit(ForceInit);
GetWorld()->LineTraceSingleByChannel(Hit, TraceStart, TraceEnd, ECC_Visibility, TraceParams);
/* Check to see if we hit a staticmesh component that has physics simulation enabled */
UStaticMeshComponent* MeshComp = Cast<UStaticMeshComponent>(Hit.GetComponent());
if (MeshComp && MeshComp->IsSimulatingPhysics())
{
return Hit.GetActor();
}
return nullptr;
}
void UCheatManager::DamageTarget(float DamageAmount)
{
APlayerController* const MyPC = GetOuterAPlayerController();
if ((MyPC == NULL) || (MyPC->PlayerCameraManager == NULL))
{
return;
}
check(GetWorld() != NULL);
FVector const CamLoc = MyPC->PlayerCameraManager->GetCameraLocation();
FRotator const CamRot = MyPC->PlayerCameraManager->GetCameraRotation();
FCollisionQueryParams TraceParams(NAME_None, true, MyPC->GetPawn());
FHitResult Hit;
bool bHit = GetWorld()->LineTraceSingle(Hit, CamLoc, CamRot.Vector() * 100000.f + CamLoc, ECC_Pawn, TraceParams);
if (bHit)
{
check(Hit.GetActor() != NULL);
FVector ActorForward, ActorSide, ActorUp;
FRotationMatrix(Hit.GetActor()->GetActorRotation()).GetScaledAxes(ActorForward, ActorSide, ActorUp);
FPointDamageEvent DamageEvent(DamageAmount, Hit, -ActorForward, UDamageType::StaticClass());
Hit.GetActor()->TakeDamage(DamageAmount, DamageEvent, MyPC, MyPC->GetPawn());
}
}
AActor* USCarryObjectComponent::GetActorInView()
{
APawn* PawnOwner = Cast<APawn>(GetOwner());
AController* Controller = PawnOwner->Controller;
if (Controller == nullptr)
{
return nullptr;
}
FVector CamLoc;
FRotator CamRot;
Controller->GetPlayerViewPoint(CamLoc, CamRot);
const FVector TraceStart = CamLoc;
const FVector Direction = CamRot.Vector();
const FVector TraceEnd = TraceStart + (Direction * MaxPickupDistance);
FCollisionQueryParams TraceParams(TEXT("TraceActor"), true, PawnOwner);
TraceParams.bTraceAsyncScene = true;
TraceParams.bReturnPhysicalMaterial = false;
TraceParams.bTraceComplex = false;
FHitResult Hit(ForceInit);
GetWorld()->LineTraceSingle(Hit, TraceStart, TraceEnd, ECC_Visibility, TraceParams);
//DrawDebugLine(GetWorld(), TraceStart, TraceEnd, FColor::Red, false, 1.0f);
return Hit.GetActor();
}
FHitResult UGTTraceBase::SingleLineRangedTrace(const FVector& StartTrace, const FVector& EndTrace)
{
FHitResult Hit(ForceInit);
UWorld* world = GetWorld();
if (!TraceInterface->GetGamePawn())
return Hit;
static FName PowerTag = FName(TEXT("SingleLineTrace"));
FCollisionQueryParams TraceParams(PowerTag, false, TraceInterface->GetGamePawn());
TraceParams.bTraceComplex = false;
TraceParams.bTraceAsyncScene = false;
TraceParams.bReturnPhysicalMaterial = true;
if (bIgnoreSelf)
{
TraceParams.AddIgnoredActor(TraceInterface->GetGamePawn());
}
bool traceResult = GetWorld()->LineTraceSingle(Hit, StartTrace, EndTrace, TraceParams, CollisionObjectParams);
if (bDrawDebug)
{
if (traceResult && Hit.bBlockingHit)
{
::DrawDebugLine(world, StartTrace, Hit.ImpactPoint, FColor::Red, false, 2);
::DrawDebugLine(world, Hit.ImpactPoint, EndTrace, FColor::Green, false, 2);
::DrawDebugPoint(world, Hit.ImpactPoint, 7, FColor::Red, false, 2);
}
else
{
::DrawDebugPoint(world, Hit.ImpactPoint, 15, FColor::Red, false, 2);
}
}
return Hit;
}
AInventoryItem* APlayerCharacter::GetUsableItemInView()
{
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 * MaxUseDist);
FCollisionQueryParams TraceParams(FName(TEXT("")), true, this);
TraceParams.bTraceAsyncScene = true;
TraceParams.bReturnPhysicalMaterial = false;
TraceParams.bTraceComplex = true;
FHitResult Hit(ForceInit);
GetWorld()->LineTraceSingleByChannel(Hit, start_trace, end_trace, ECollisionChannel::ECC_EngineTraceChannel1, TraceParams);
//DrawDebugLine(GetWorld(), start_trace, end_trace, FColor(255, 0, 0), false, -1, 0, 12.333);
return Cast<AInventoryItem>(Hit.GetActor());
}
bool AKinectPlayerController::FindDeathCameraSpot(FVector& CameraLocation, FRotator& CameraRotation)
{
const FVector PawnLocation = GetPawn()->GetActorLocation();
FRotator ViewDir = GetControlRotation();
ViewDir.Pitch = -45.0f;
const float YawOffsets[] = { 0.0f, -180.0f, 90.0f, -90.0f, 45.0f, -45.0f, 135.0f, -135.0f };
const float CameraOffset = 600.0f;
FCollisionQueryParams TraceParams(TEXT("DeathCamera"), true, GetPawn());
for (int32 i = 0; i < ARRAY_COUNT(YawOffsets); i++)
{
FRotator CameraDir = ViewDir;
CameraDir.Yaw += YawOffsets[i];
CameraDir.Normalize();
const FVector TestLocation = PawnLocation - CameraDir.Vector() * CameraOffset;
const bool bBlocked = GetWorld()->LineTraceTest(PawnLocation, TestLocation, ECC_Camera, TraceParams);
if (!bBlocked)
{
CameraLocation = TestLocation;
CameraRotation = CameraDir;
return true;
}
}
return false;
}
void ABETCharacter::OnInteract()
{
FCollisionQueryParams TraceParams(FName(TEXT("Interact Trace")), true);
TraceParams.bTraceComplex = true;
TraceParams.bReturnPhysicalMaterial = false;
TraceParams.AddIgnoredActor(this);
// Re-init hit info
TArray<FOverlapResult>Overlaps;
if (GetWorld()->OverlapMultiByChannel(Overlaps,
GetActorLocation(),
FQuat(),
ECC_GameTraceChannel2,
FCollisionShape::MakeSphere(50.f),
TraceParams))
{
for (FOverlapResult Result : Overlaps)
{
//if (ABETInteractable->InteractAudio != NULL)
//{
//UGameplayStatics::PlaySoundAtLocation(this, ABETInteractable->InteractableAudio, GetActorLocation());
if (ABETInteractable* Interactable = Cast<ABETInteractable>(Result.Actor.Get()))
{
UE_LOG(LogTemp, Display, TEXT("INTERACTABLE FOUND"));
Interactable->Interact();
//Interactable->OnServerInteract();
}
//}
}
}
}
AUsableActor* AXtremeJanitorCharacter::GetUsableInView()
{
FVector CamLoc;
FRotator CamRot;
if (Controller == NULL)
return NULL;
Controller->GetPlayerViewPoint(CamLoc, CamRot);
const FVector TraceStart = CamLoc;
const FVector Direction = CamRot.Vector();
const FVector TraceEnd = TraceStart + (Direction * MaxUseDistance);
FCollisionQueryParams TraceParams(FName(TEXT("TraceUsableActor")), true, this);
TraceParams.bTraceAsyncScene = true;
TraceParams.bReturnPhysicalMaterial = false;
TraceParams.bTraceComplex = true;
FHitResult Hit(ForceInit);
GetWorld()->LineTraceSingleByChannel(Hit, TraceStart, TraceEnd, ECC_Visibility, TraceParams);
// Cette ligne sera en commentaire plus tard
DrawDebugLine(GetWorld(), TraceStart, TraceEnd, FColor::Red, false, 1.0f);
return Cast<AUsableActor>(Hit.GetActor());
}
bool ASwoim::TraceAhead(const FVector& Start, const FVector& End, UWorld* World, FHitResult& HitOut) {
if (!World)
{
return false;
}
bool ReturnPhysMat = false;
FCollisionQueryParams TraceParams(FName(TEXT("VictoreCore Trace")), true, this);
TraceParams.bTraceComplex = true;
TraceParams.bReturnPhysicalMaterial = ReturnPhysMat;
TraceParams.AddIgnoredActor(this);
ECollisionChannel CollisionChannel = ECollisionChannel::ECC_WorldStatic;
//Re-initialize hit info
HitOut = FHitResult(ForceInit);
//Trace!
World->LineTraceSingleByChannel(
HitOut, //result
Start, //start
End, //end
CollisionChannel, //collision channel
TraceParams
);
//Hit any Actor?
return (HitOut.GetActor() != NULL);
}
/*Description: Raycasts forward and detects where the player is aiming to adjust the reticles*/
bool APoseidonCharacter::TraceHitForward(APlayerController* InController, FHitResult& OutTraceResult)
{
// Calculate the direction we are 'looking'
FVector CamLoc;
FRotator CamRot;
InController->GetPlayerViewPoint(CamLoc, CamRot);
const FVector TraceDirection = CamRot.Vector();
// Calculate the start location for trace
FVector StartTrace = FVector::ZeroVector;
if (InController)
{
FRotator UnusedRotation;
InController->GetPlayerViewPoint(StartTrace, UnusedRotation);
// Adjust trace so there is nothing blocking the ray between the camera and the pawn, and calculate distance from adjusted start
StartTrace = StartTrace + TraceDirection * ((GetActorLocation() - StartTrace) | TraceDirection);
}
// Calculate endpoint of trace
const FVector EndTrace = StartTrace + TraceDirection * mGrappleRange;
// Setup the trace query
static FName FireTraceIdent = FName(TEXT("GrappleTrace"));
FCollisionQueryParams TraceParams(FireTraceIdent, true, this);
TraceParams.bTraceAsyncScene = true;
// Perform the trace
GetWorld()->LineTraceSingleByChannel(OutTraceResult, StartTrace, EndTrace, COLLISION_GRAPPLE, TraceParams);
if (OutTraceResult.GetActor() != NULL)
{
FString filterEnemy = TEXT("Character");
if (OutTraceResult.GetActor()->GetHumanReadableName().Contains(filterEnemy))
{
if (mIsGrappleReady)
{
PlayerHUD->ChangeCrosshair(EReticleEnum::RE_HIT_AIM);
}
}
else
{
if (mIsGrappleReady)
{
PlayerHUD->ChangeCrosshair(EReticleEnum::RE_AIM);
}
else
{
PlayerHUD->ChangeCrosshair(EReticleEnum::RE_HIP);
}
}
return true;
}
PlayerHUD->ChangeCrosshair(EReticleEnum::RE_HIP);
return false;
}
bool UEnvQueryTest_Trace::RunLineTraceFrom(const FVector& ItemPos, const FVector& ContextPos, AActor* ItemActor, UWorld* World, enum ECollisionChannel Channel, const FCollisionQueryParams& Params, const FVector& Extent)
{
FCollisionQueryParams TraceParams(Params);
TraceParams.AddIgnoredActor(ItemActor);
const bool bHit = World->LineTraceTestByChannel(ItemPos, ContextPos, Channel, TraceParams);
return bHit;
}
bool UEnvQueryTest_Trace::RunBoxTraceFrom(const FVector& ItemPos, const FVector& ContextPos, AActor* ItemActor, UWorld* World, enum ECollisionChannel Channel, const FCollisionQueryParams& Params, const FVector& Extent)
{
FCollisionQueryParams TraceParams(Params);
TraceParams.AddIgnoredActor(ItemActor);
const bool bHit = World->SweepTestByChannel(ItemPos, ContextPos, FQuat((ContextPos - ItemPos).Rotation()), Channel, FCollisionShape::MakeBox(Extent), TraceParams);
return bHit;
}
bool UEnvQueryTest_Trace::RunCapsuleTraceFrom(const FVector& ItemPos, const FVector& ContextPos, AActor* ItemActor, UWorld* World, enum ECollisionChannel Channel, const FCollisionQueryParams& Params, const FVector& Extent)
{
FCollisionQueryParams TraceParams(Params);
TraceParams.AddIgnoredActor(ItemActor);
const bool bHit = World->SweepTestByChannel(ItemPos, ContextPos, FQuat::Identity, Channel, FCollisionShape::MakeCapsule(Extent.X, Extent.Z), TraceParams);
return bHit;
}
void AWeapon::FireProjectile()
{
FHitResult ObjectHit(EForceInit::ForceInit);
FVector CameraLocation;
FRotator CameraRotation;
WeaponOwner->Controller->GetPlayerViewPoint(CameraLocation, CameraRotation);
const FVector TraceStart = CameraLocation;
const FVector TraceDirection = CameraRotation.Vector();
FRandomStream WeaponRandomStream(FMath::Rand());
const float SpreadCone = FMath::DegreesToRadians(Config.Spread * 0.5);
const FVector ShotDirection = WeaponRandomStream.VRandCone(TraceDirection, SpreadCone, SpreadCone);
const FVector TraceEnd = TraceStart + ShotDirection * Config.Range;
FCollisionQueryParams TraceParams(FName(TEXT("TraceShot")), true, this);
TraceParams.AddIgnoredActor(WeaponOwner);
//Weapon Recoil Calculation
WeaponOwner->AddControllerPitchInput(-(Config.Recoil));
if (FMath::FRand() >= 0.65f)
{
WeaponOwner->AddControllerYawInput(Config.Recoil);
}
else
{
WeaponOwner->AddControllerYawInput(-(Config.Recoil));
}
const UWorld* World = GetWorld();
//debug code start//////////////////////////////////
if (GEngine)
{
//GEngine->AddOnScreenDebugMessage(0, 5.f, FColor::Yellow, ShotDirection.ToString());
}
DrawDebugLine(
World,
TraceStart,
TraceEnd,
FColor(255, 0, 0),
false, 3, 0,
3.0
);
//debug code end////////////////////////////////////
bool HitDetected = false;
if (World)
{
HitDetected = World->LineTraceSingle(ObjectHit, TraceStart, TraceEnd, ECollisionChannel::ECC_WorldDynamic, TraceParams);
if (HitDetected)
{
DoDamage(ObjectHit);
}
}
}
FHitResult ASWeapon::WeaponTrace(const FVector& TraceFrom, const FVector& TraceTo) const
{
FCollisionQueryParams TraceParams(TEXT("WeaponTrace"), true, Instigator);
TraceParams.bTraceAsyncScene = true;
TraceParams.bReturnPhysicalMaterial = true;
FHitResult Hit(ForceInit);
GetWorld()->LineTraceSingleByChannel(Hit, TraceFrom, TraceTo, COLLISION_WEAPON, TraceParams);
return Hit;
}
FHitResult AFP_FirstPersonCharacter::WeaponTrace(const FVector& StartTrace, const FVector& EndTrace) const
{
// Perform trace to retrieve hit info
FCollisionQueryParams TraceParams(WeaponFireTraceIdent, true, Instigator);
TraceParams.bTraceAsyncScene = true;
TraceParams.bReturnPhysicalMaterial = true;
FHitResult Hit(ForceInit);
GetWorld()->LineTraceSingleByChannel(Hit, StartTrace, EndTrace, COLLISION_WEAPON, TraceParams);
return Hit;
}
/**
* [local + server] handle weapon attack
*/
FHitResult AWeapon::WeaponTrace(const FVector& TraceFrom, const FVector& TraceTo) const
{
static FName WeaponAttackTag = FName(TEXT("WeaponTrace"));
FCollisionQueryParams TraceParams(WeaponAttackTag, true, Instigator);
TraceParams.bTraceAsyncScene = true;
TraceParams.bReturnPhysicalMaterial = true;
FHitResult Hit(ForceInit);
GetWorld()->LineTraceSingle(Hit, TraceFrom, TraceTo, ECollisionChannel::ECC_Vehicle, TraceParams);
return Hit;
}
void ADebugCameraController::SelectTargetedObject()
{
FVector CamLoc;
FRotator CamRot;
GetPlayerViewPoint(CamLoc, CamRot);
FHitResult Hit;
FCollisionQueryParams TraceParams(NAME_None, true, this);
bool const bHit = GetWorld()->LineTraceSingle(Hit, CamLoc, CamRot.Vector() * 5000.f * 20.f + CamLoc, ECC_Pawn, TraceParams);
if( bHit)
{
Select(Hit);
}
}
void AHUD::ShowDebugInfo(float& YL, float& YPos)
{
if (DebugCanvas != nullptr )
{
FLinearColor BackgroundColor(0.f, 0.f, 0.f, 0.2f);
DebugCanvas->Canvas->DrawTile(0, 0, DebugCanvas->ClipX, DebugCanvas->ClipY, 0.f, 0.f, 0.f, 0.f, BackgroundColor);
FDebugDisplayInfo DisplayInfo(DebugDisplay, ToggledDebugCategories);
if (bShowDebugForReticleTarget)
{
FRotator CamRot; FVector CamLoc; PlayerOwner->GetPlayerViewPoint(CamLoc, CamRot);
FCollisionQueryParams TraceParams(NAME_None, true, PlayerOwner->PlayerCameraManager->ViewTarget.Target);
FHitResult Hit;
bool bHit = GetWorld()->LineTraceSingleByChannel(Hit, CamLoc, CamRot.Vector() * 100000.f + CamLoc, ECC_WorldDynamic, TraceParams);
if (bHit)
{
AActor* HitActor = Hit.Actor.Get();
if (HitActor && (ShowDebugTargetDesiredClass == NULL || HitActor->IsA(ShowDebugTargetDesiredClass)))
{
ShowDebugTargetActor = HitActor;
}
}
}
else
{
ShowDebugTargetActor = PlayerOwner->PlayerCameraManager->ViewTarget.Target;
}
if (ShowDebugTargetActor && !ShowDebugTargetActor->IsPendingKill())
{
ShowDebugTargetActor->DisplayDebug(DebugCanvas, DisplayInfo, YL, YPos);
}
if (ShouldDisplayDebug(NAME_Game))
{
AGameModeBase* AuthGameMode = GetWorld()->GetAuthGameMode();
if (AuthGameMode)
{
AuthGameMode->DisplayDebug(DebugCanvas, DisplayInfo, YL, YPos);
}
}
if (bShowDebugInfo)
{
OnShowDebugInfo.Broadcast(this, DebugCanvas, DisplayInfo, YL, YPos);
}
}
}
FHitResult AShooterWeapon::WeaponTrace(const FVector& StartTrace, const FVector& EndTrace) const
{
static FName WeaponFireTag = FName(TEXT("WeaponTrace"));
// Perform trace to retrieve hit info
FCollisionQueryParams TraceParams(WeaponFireTag, true, Instigator);
TraceParams.bTraceAsyncScene = true;
TraceParams.bReturnPhysicalMaterial = true;
FHitResult Hit(ForceInit);
GetWorld()->LineTraceSingleByChannel(Hit, StartTrace, EndTrace, COLLISION_WEAPON, TraceParams);
return Hit;
}
void AAgent::CheckLoS()
{
AAgentController* Controller = Cast<AAgentController>(GetController());
if (Controller != NULL)
{
// Get the location of the agent
FVector AgentLocation = GetActorLocation();
// Get the direction the agent is facing
FVector Direction = GetActorForwardVector();
// Default trace params
FCollisionQueryParams TraceParams(TEXT("LineOfSight_Trace"), false, this);
TraceParams.bTraceAsyncScene = true;
//=====Draw line trace from agent to player=====//
FHitResult Hit(ForceInit);
UWorld* World = GetWorld();
World->LineTraceSingleByChannel(Hit, AgentLocation + Direction, Controller->GetFocalPoint(), ECollisionChannel::ECC_Visibility, TraceParams, FCollisionResponseParams::DefaultResponseParam);
//DrawDebugLine(World, AgentLocation + Direction, Controller->GetFocalPoint(), FColor::Yellow, false, -1, 0, 2.0f);
//==============================================//
AActor* HitActor = Hit.GetActor();
if (HitActor != NULL && HitActor->ActorHasTag("Player"))
{
}
/* Otherwise we can assume the actor intersecting the line trace is blocking the line of sight
from the agent to the player */
else if (HitActor != NULL)
{
/* The focal point is currently on the player actor. Set the PlayerLocation blackboard key
to the location of this focal point, so that when the agent moves into the Search behaviour
it will move to the actual location of the player when the agent lost LoS as opposed to the last
location it sensed the player at.
*/
Controller->SetPlayerLocation(Controller->GetFocalPoint());
// LoS to player is blocked
bPlayerSeen = false;
// Reset the player has seen blackboard key so that the Agent can begin searching.
Controller->SetPlayerFound(bPlayerSeen);
// Clear the focus on the player
Controller->ClearFocus(EAIFocusPriority::Gameplay);
bCanSearch = true;
Controller->SetCanSearch(bCanSearch);
// Stop firing if still firing
if (isFiring)
StopFiring();
}
}
}
FHitResult AWeapon::WeaponTrace(const FVector &TraceFrom, const FVector &TraceTo) const
{
static FName WeaponFireTag = FName(TEXT("WeaponTrace"));
FCollisionQueryParams TraceParams(WeaponFireTag, true, Instigator);
TraceParams.bTraceAsyncScene = true;
TraceParams.bReturnPhysicalMaterial = true;
TraceParams.AddIgnoredActor(this);
FHitResult Hit(ForceInit);
GetWorld()->LineTraceSingle(Hit, TraceFrom, TraceTo, TRACE_WEAPON, TraceParams);
return Hit;
}
FHitResult ABaseWeapon::WeaponTrace(const FVector &TraceFrom, const FVector &TraceTo) const
{
static FName WeaponFireTag = FName(TEXT("WeaponTrace"));
FCollisionQueryParams TraceParams(WeaponFireTag, true, MyPawn->Controller);
TraceParams.TraceTag = WeaponFireTag;
TraceParams.bTraceAsyncScene = true;
TraceParams.bReturnPhysicalMaterial = true;
TraceParams.AddIgnoredActor(MyPawn);
FHitResult Hit(ForceInit);
MyPawn->GetWorld()->LineTraceSingleByChannel(Hit, TraceFrom, TraceTo, COLLISION_WEAPON, TraceParams);
return Hit;
}
void ABaseWeapon::fireTargetingRaycasts()
{
const int32 RandomSeed = FMath::Rand();
FRandomStream WeaponRandomStream(RandomSeed);
const float CurrentSpread = 2.0f;
const float SpreadCone = FMath::DegreesToRadians(CurrentSpread * 0.5f);
FVector Up_StartTrace = (MyPawn->GetActorLocation() + (MyPawn->GetActorForwardVector() * 500)) + (MyPawn->GetActorUpVector() * 30);
FVector Up_Dir = MyPawn->GetActorForwardVector();
FVector Up_EndTrace = Up_StartTrace + Up_Dir * (WeaponConfig.WeaponRange);
FVector Down_StartTrace = (MyPawn->GetActorLocation() + (MyPawn->GetActorForwardVector() * 500)) + (MyPawn->GetActorUpVector() * -30);
FVector Down_Dir = MyPawn->GetActorForwardVector();
FVector Down_EndTrace = Down_StartTrace + Down_Dir * (WeaponConfig.WeaponRange);
FVector Left_StartTrace = (MyPawn->GetActorLocation() + (MyPawn->GetActorForwardVector() * 500)) + (MyPawn->GetActorRightVector() * -30);
FVector Left_Dir = MyPawn->GetActorForwardVector();
FVector Left_EndTrace = Left_StartTrace + Left_Dir * (WeaponConfig.WeaponRange);
FVector Right_StartTrace = (MyPawn->GetActorLocation() + (MyPawn->GetActorForwardVector() * 500)) + (MyPawn->GetActorRightVector() * 30);
FVector Right_Dir = MyPawn->GetActorForwardVector();
FVector Right_EndTrace = Right_StartTrace + Right_Dir * (WeaponConfig.WeaponRange);
FName TraceTag("TraceTag");
FCollisionQueryParams TraceParams(TraceTag, true, this);
TraceParams.bTraceAsyncScene = true;
TraceParams.bReturnPhysicalMaterial = true;
TraceParams.AddIgnoredActor(MyPawn);
TraceParams.TraceTag = TraceTag;
GetWorld()->LineTraceSingleByChannel(Up_hit, Up_StartTrace, Up_EndTrace, COLLISION_TARGET, TraceParams);
//DrawDebugLine(GetWorld(), Up_StartTrace, Up_EndTrace, FColor::Cyan, false, -1.0f, 0, 2);
GetWorld()->LineTraceSingleByChannel(Down_hit, Down_StartTrace, Down_EndTrace, COLLISION_TARGET, TraceParams);
//DrawDebugLine(GetWorld(), Down_StartTrace, Down_EndTrace, FColor::Cyan, false, -1.0f, 0, 2);
GetWorld()->LineTraceSingleByChannel(Left_hit, Left_StartTrace, Left_EndTrace, COLLISION_TARGET, TraceParams);
//DrawDebugLine(GetWorld(), Left_StartTrace, Left_EndTrace, FColor::Cyan, false, -1.0f, 0, 2);
GetWorld()->LineTraceSingleByChannel(Right_hit, Right_StartTrace, Right_EndTrace, COLLISION_TARGET, TraceParams);
//DrawDebugLine(GetWorld(), Right_StartTrace, Right_EndTrace, FColor::Cyan, false, -1.0f, 0, 2);
}
void AVisualLoggerHUD::PostRender()
{
static const FColor TextColor(200, 200, 128, 255);
Super::Super::PostRender();
if (bShowHUD)
{
AVisualLoggerCameraController* DebugCamController = Cast<AVisualLoggerCameraController>(PlayerOwner);
if( DebugCamController != NULL )
{
FCanvasTextItem TextItem( FVector2D::ZeroVector, FText::GetEmpty(), GEngine->GetSmallFont(), TextColor);
TextItem.FontRenderInfo = TextRenderInfo;
float X = Canvas->SizeX * 0.025f+1;
float Y = Canvas->SizeX * 0.025f+1;
FVector const CamLoc = DebugCamController->PlayerCameraManager->GetCameraLocation();
FRotator const CamRot = DebugCamController->PlayerCameraManager->GetCameraRotation();
FCollisionQueryParams TraceParams(NAME_None, true, this);
FHitResult Hit;
bool bHit = GetWorld()->LineTraceSingle(Hit, CamLoc, CamRot.Vector() * 100000.f + CamLoc, ECC_Pawn, TraceParams);
if( bHit )
{
TextItem.Text = FText::FromString(FString::Printf(TEXT("Under cursor: '%s'"), *Hit.GetActor()->GetName()));
Canvas->DrawItem( TextItem, X, Y );
DrawDebugLine( GetWorld(), Hit.Location, Hit.Location+Hit.Normal*30.f, FColor::White );
}
else
{
TextItem.Text = LOCTEXT("NotActorUnderCursor", "Not actor under cursor" );
}
Canvas->DrawItem( TextItem, X, Y );
Y += TextItem.DrawnSize.Y;
if (DebugCamController->PickedActor != NULL)
{
TextItem.Text = FText::FromString(FString::Printf(TEXT("Selected: '%s'"), *DebugCamController->PickedActor->GetName()));
Canvas->DrawItem( TextItem, X, Y );
}
}
}
}
void ARifleWeapon::Fire()
{
Super::Fire();
if (Mesh1P && ThePlayer && ThePlayer->Controller)
{
/// Get Camera Location and Rotation
FVector CamLoc;
FRotator CamRot;
ThePlayer->Controller->GetPlayerViewPoint(CamLoc, CamRot);
// Get Mesh Fire Socket Location and calculatre Fire end point
const FVector StartTrace = GetFireSocketTransform().GetLocation();;
const FVector Direction = CamRot.Vector();
const FVector EndTrace = StartTrace + Direction *MainFire.FireDistance;
// Set trace values and perform trace to retrieve hit info
FCollisionQueryParams TraceParams(FName(TEXT("WeaponTrace")), true, this);
TraceParams.bTraceAsyncScene = true;
TraceParams.bReturnPhysicalMaterial = true;
TraceParams.AddIgnoredActor(ThePlayer);
// Trace Hit
FHitResult Hit(ForceInit);
if (GetWorld()->LineTraceSingleByChannel(Hit, StartTrace, EndTrace, ECC_WorldStatic, TraceParams))
{
// Check if player character
ARadeCharacter* EnemyPlayer = Cast<ARadeCharacter>(Hit.GetActor());
if (EnemyPlayer)
{
// Hit Enemy
BP_HitEnemy(Hit);
// Apply Damage
UGameplayStatics::ApplyDamage(EnemyPlayer, MainFire.FireDamage, ThePlayer->Controller, Cast<AActor>(this), UDamageType::StaticClass());
}
}
}
}
bool ARadiantWebViewActor::TraceScreenPoint(APawn* InPawn, FVector2D& OutUV)
{
FVector Location;
FRotator Rotation;
APlayerController *PC = Cast<APlayerController>(InPawn->GetController());
if (PC)
{
PC->GetPlayerViewPoint(Location, Rotation);
}
else
{
InPawn->GetActorEyesViewPoint(Location, Rotation);
}
const FVector VectorToTarget = Location - GetActorLocation();
const float DistanceToTrace = VectorToTarget.Size() + TraceOversize;
const FVector EndTrace = Location + Rotation.Vector()*DistanceToTrace;
// Is this actor "pointing" at our surface mesh?
static FName TraceTag = FName(TEXT("RadiantGUITrace"));
FCollisionQueryParams TraceParams(TraceTag, true, InPawn);
// TraceParams.bTraceAsyncScene = true;
TraceParams.bReturnFaceIndex = true;
FHitResult HitResult;
UWorld* const World = GetWorld();
if (World->LineTraceSingleByChannel(HitResult, Location, EndTrace, TraceChannel, TraceParams))
{
if (HitResult.Actor.IsValid() && (HitResult.Actor.Get() == this))
{
FVector ActorRelativeLocation = ActorToWorld().InverseTransformPosition(HitResult.Location);
return GetUVForPoint(HitResult.FaceIndex, ActorRelativeLocation, OutUV);
}
}
return false;
}
void ASideScrollerCharacter::Interact()
{
FHitResult Hit(ForceInit);
const FVector start_trace = this->GetTransform().GetLocation();;
const FVector direction = this->GetActorForwardVector();
const FVector end_trace = start_trace + (direction * fInteractDist);
const FName traceTag("RaycastTrace");
GetWorld()->DebugDrawTraceTag = traceTag;
FCollisionQueryParams TraceParams(FName(TEXT("")), true, this);
TraceParams.TraceTag = traceTag;
TraceParams.bTraceAsyncScene = true;
TraceParams.bReturnPhysicalMaterial = false;
TraceParams.bTraceComplex = true;
if(GetWorld()->LineTraceSingle(Hit, start_trace, end_trace, COLLISION_INTERACTIVE, TraceParams))
OnInteractionEvent.Broadcast(Hit);
}
