void AShooterWeapon_Instant::ProcessInstantHit(const FHitResult& Impact, const FVector& Origin, const FVector& ShootDir, int32 RandomSeed, float ReticleSpread) { if (MyPawn && MyPawn->IsLocallyControlled() && GetNetMode() == NM_Client) { // if we're a client and we've hit something that is being controlled by the server if (Impact.GetActor() && Impact.GetActor()->GetRemoteRole() == ROLE_Authority) { // notify the server of the hit ServerNotifyHit(Impact, ShootDir, RandomSeed, ReticleSpread); } else if (Impact.GetActor() == NULL) { if (Impact.bBlockingHit) { // notify the server of the hit ServerNotifyHit(Impact, ShootDir, RandomSeed, ReticleSpread); } else { // notify server of the miss ServerNotifyMiss(ShootDir, RandomSeed, ReticleSpread); } } } // process a confirmed hit ProcessInstantHit_Confirmed(Impact, Origin, ShootDir, RandomSeed, ReticleSpread); }
void AShooterWeapon_Instant::ProcessInstantHit_Confirmed(const FHitResult& Impact, const FVector& Origin, const FVector& ShootDir, int32 RandomSeed, float ReticleSpread) { // handle damage if (ShouldDealDamage(Impact.GetActor())) { DealDamage(Impact, ShootDir); } // play FX on remote clients if (Role == ROLE_Authority) { HitNotify.Origin = Origin; HitNotify.RandomSeed = RandomSeed; HitNotify.ReticleSpread = ReticleSpread; } // play FX locally if (GetNetMode() != NM_DedicatedServer) { const FVector EndTrace = Origin + ShootDir * InstantConfig.WeaponRange; const FVector EndPoint = Impact.GetActor() ? Impact.ImpactPoint : EndTrace; SpawnTrailEffect(EndPoint); SpawnImpactEffects(Impact); } }
/*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; }
void ASWeaponInstant::ProcessInstantHit(const FHitResult& Impact, const FVector& Origin, const FVector& ShootDir) { if (MyPawn && MyPawn->IsLocallyControlled() && GetNetMode() == NM_Client) { // If we are a client and hit something that is controlled by server if (Impact.GetActor() && Impact.GetActor()->GetRemoteRole() == ROLE_Authority) { // Notify the server of our local hit to validate and apply actual hit damage. ServerNotifyHit(Impact, ShootDir); } else if (Impact.GetActor() == nullptr) { if (Impact.bBlockingHit) { ServerNotifyHit(Impact, ShootDir); } else { ServerNotifyMiss(ShootDir); } } } // Process a confirmed hit. ProcessInstantHitConfirmed(Impact, Origin, ShootDir); }
void AKIMCharacter::Interact() { if (IsInRoationState && PickedUpItem) { ((AKIMInteractionActor*)PickedUpItem)->LayBack(this); return; } FHitResult outHit; FCollisionQueryParams params; params.AddIgnoredActor(this); params.AddIgnoredActor(PickedUpItem); FVector TraceStart = CameraComponent->GetComponentLocation(); FVector TraceEnd = TraceStart + (CameraComponent->GetForwardVector() * InteractionDistance); GetWorld()->LineTraceSingleByChannel(outHit, TraceStart, TraceEnd, ECollisionChannel::ECC_PhysicsBody, params); if (outHit.GetActor() != NULL && outHit.GetActor()->GetClass()->IsChildOf(AKIMInteractionActor::StaticClass())) { AKIMInteractionActor* InteractionActor = ((AKIMInteractionActor*)outHit.GetActor()); InteractionActor->Interacted(this, outHit.GetComponent()); UE_LOG(LogClass, Warning, TEXT("Interacted with %s"), *outHit.GetActor()->GetName()); UE_LOG(LogClass, Warning, TEXT("(%s)"), *outHit.GetComponent()->GetName()); } else if (outHit.GetActor() == NULL && PickedUpItem) { PickedUpItem->DetachRootComponentFromParent(true); ((AKIMInteractionActor*)PickedUpItem)->Droped(); ((AKIMInteractionActor*)PickedUpItem)->InteractionType = EKIMInteractionTypes::OnPickUp; UE_LOG(LogClass, Warning, TEXT("Droped %s"), *PickedUpItem->GetName()); PickedUpItem = NULL; } }
void AMainPlayerController::ChooseTargetUnderMouseCursor() { /*if (clickedPawn != nullptr) { delete clickedPawn; clickedPawn = nullptr; }*/ // Trace to see what is under the mouse cursor FHitResult Hit; GetHitResultUnderCursor(ECC_Pawn, false, Hit); if (Hit.bBlockingHit) { //GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Magenta, Hit.GetActor()->GetName()); IGlobalMapInterface * mapObj = Cast<IGlobalMapInterface>(Hit.GetActor()); clickedPawn = Cast<ABasicCharacter>(Hit.GetActor()); if (mapObj != nullptr) { mapObj->showObjectInformation(); } /*if (clickedPawn == nullptr) { Cast<IGlobalMapInterface>(Hit.GetActor())->showObjectInformation(); }*/ } }
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()); } }
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(); } }
void UARFXEffectComponent::SpawnEffectOnHitLoc_Implementation(UParticleSystem* FXIn, FHitResult HitLocation, APawn* Causer) { if (!HitLocation.GetActor() && !FXIn) return; UParticleSystemComponent* ImpactPSC = UGameplayStatics::SpawnEmitterAtLocation(HitLocation.GetActor(), FXIn, HitLocation.ImpactPoint); }
//USE BUTTON CODE// void APlayerCharacter::ActivateButton() { UPeterAnimInstance* PeterAnimInstance = Cast<UPeterAnimInstance>(GetMesh()->GetAnimInstance()); if (PeterAnimInstance) { PeterAnimInstance->bIsInteracting = true; } if (PhysicsHandleActive) { PhysicsHandleActive = false; } else if (!PhysicsHandleActive) { PhysicsHandleActive = true; } bool TraceSuccess; FHitResult OutHit; //Uses Trace Channel: PlayerTrace TraceSuccess = this->TraceFromSelf(OutHit, 300.f, ECollisionChannel::ECC_GameTraceChannel6); if (TraceSuccess) { AInteractable* InteractableObject = NULL; InteractableObject = Cast<AInteractable>(OutHit.GetActor()); if (Cast<ALiftableBox>(OutHit.GetActor())) { if (PhysicsHandleActive) { PickedUpBox = Cast<ALiftableBox>(OutHit.GetActor()); if (PickedUpBox->bIsAbove(this) && PickedUpBox->CanBeLifted == true) { PhysicsHandler->GrabComponent(OutHit.GetComponent(), OutHit.BoneName, OutHit.Location, true); } } return; } else if (InteractableObject && InteractableObject->GetClass()->IsChildOf(ALightSwitch::StaticClass()) == false) { if (FVector::Dist(GetActorLocation(), InteractableObject->GetActorLocation()) < 250) { InteractableObject->Interact(this); } } } }
void ASWeaponInstant::SimulateInstantHit(const FVector& Origin) { const FVector StartTrace = Origin; const FVector AimDir = GetAdjustedAim(); const FVector EndTrace = StartTrace + (AimDir * WeaponRange); const FHitResult Impact = WeaponTrace(StartTrace, EndTrace); if (Impact.bBlockingHit) { SpawnImpactEffects(Impact); SpawnTrailEffects(Impact.ImpactPoint); } else { SpawnTrailEffects(EndTrace); } // Do not spawn near-hit if we actually hit a pawn if (Impact.GetActor() && Impact.GetActor()->IsA(ASCharacter::StaticClass())) { return; } for (FConstPawnIterator It = GetWorld()->GetPawnIterator(); It; It++) { // Find a locally controlled pawn that is not the instigator of the hit. ASCharacter* OtherPawn = Cast<ASCharacter>(*It); if (OtherPawn && OtherPawn != GetPawnOwner() && OtherPawn->IsLocallyControlled()) { // Calculate shortest distance to point. (using the estimated eye height) const float DistanceToPawn = FVector::CrossProduct(AimDir, OtherPawn->GetActorLocation() - Origin).Size(); /* Owner can be lost before client gets to simulate the hit. */ ASCharacter* P = GetPawnOwner(); if (P) { FVector LookAt = (OtherPawn->GetActorLocation() - GetPawnOwner()->GetActorLocation()); LookAt.Normalize(); float LookDot = FVector::DotProduct(AimDir, LookAt); if (DistanceToPawn < NearHitMaxDistance && LookDot > 0) { // TODO: Play at nearest "almost" hit location. const FVector SoundLocation = Origin + (AimDir * DistanceToPawn); // Volume is based on distance to missed shot float Volume = FMath::Clamp(1 - (DistanceToPawn / NearHitMaxDistance), 0.1f, 1.0f); UGameplayStatics::PlaySoundAtLocation(this, NearHitSound, /*SoundLocation*/ OtherPawn->GetActorLocation(), Volume); } } } } }
void UARFXEffectComponent::AttachEffectToTarget_Implementation(UParticleSystem* FXIn, FHitResult Target, FName AttachSocket, APawn* Causer) { if (!Target.GetActor() && !PresitentFX) return; AARCharacter* hitTarget = Cast<AARCharacter>(Target.GetActor()); if (!hitTarget) return; UParticleSystemComponent* AttachedPSC = UGameplayStatics::SpawnEmitterAttached(PresitentFX, hitTarget->Mesh, AttachSocket); }
void ASWeaponInstant::ServerNotifyHit_Implementation(const FHitResult Impact, FVector_NetQuantizeNormal ShootDir) { // If we have an instigator, calculate the dot between the view and the shot if (Instigator && (Impact.GetActor() || Impact.bBlockingHit)) { const FVector Origin = GetMuzzleLocation(); const FVector ViewDir = (Impact.Location - Origin).GetSafeNormal(); const float ViewDotHitDir = FVector::DotProduct(Instigator->GetViewRotation().Vector(), ViewDir); if (ViewDotHitDir > AllowedViewDotHitDir) { // TODO: Check for weapon state if (Impact.GetActor() == nullptr) { if (Impact.bBlockingHit) { ProcessInstantHitConfirmed(Impact, Origin, ShootDir); } } // Assume it told the truth about static things because we don't move and the hit // usually doesn't have significant gameplay implications else if (Impact.GetActor()->IsRootComponentStatic() || Impact.GetActor()->IsRootComponentStationary()) { ProcessInstantHitConfirmed(Impact, Origin, ShootDir); } else { const FBox HitBox = Impact.GetActor()->GetComponentsBoundingBox(); FVector BoxExtent = 0.5 * (HitBox.Max - HitBox.Min); BoxExtent *= ClientSideHitLeeway; BoxExtent.X = FMath::Max(20.0f, BoxExtent.X); BoxExtent.Y = FMath::Max(20.0f, BoxExtent.Y); BoxExtent.Z = FMath::Max(20.0f, BoxExtent.Z); const FVector BoxCenter = (HitBox.Min + HitBox.Max) * 0.5; // If we are within client tolerance if (FMath::Abs(Impact.Location.Z - BoxCenter.Z) < BoxExtent.Z && FMath::Abs(Impact.Location.X - BoxCenter.X) < BoxExtent.X && FMath::Abs(Impact.Location.Y - BoxCenter.Y) < BoxExtent.Y) { ProcessInstantHitConfirmed(Impact, Origin, ShootDir); } } } } // TODO: UE_LOG on failures & rejection }
void AWeapon::ProcessInstantHit(const FHitResult &Impact, const FVector &Origin, const FVector &ShootDir, int32 RandomSeed, float ReticleSpread) { const FVector EndTrace = Origin + ShootDir * WeaponConfig.WeaponRange; const FVector EndPoint = Impact.GetActor() ? Impact.ImpactPoint : EndTrace; DrawDebugLine(this->GetWorld(), Origin, Impact.TraceEnd, FColor::Black, true, 10000, 10.f); AEnemy *Enemy = Cast<AEnemy>(Impact.GetActor()); if (Enemy) { GEngine->AddOnScreenDebugMessage(-1, 3.f, FColor::Red, "YOU HIT AN ENEMY!!"); Enemy->Destroy(); } }
void AWeaponBase::DealDamage(const FHitResult& Hit){ if(Hit.GetActor()){ float DealtDamage = BaseDamage; FVector ShotDir = GetActorLocation() - Hit.ImpactPoint; FPointDamageEvent DamageEvent; DamageEvent.Damage = DealtDamage; DamageEvent.HitInfo = Hit; DamageEvent.ShotDirection = ShotDir; DamageEvent.ShotDirection.Normalize(); Hit.GetActor()->TakeDamage(DealtDamage, DamageEvent, OwningPlayer->GetController(), this); } }
// executes the task when called EBTNodeResult::Type UAIE_UseItem_BTTaskNode::ExecuteTask(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory) { /* call super * should aquire refrences for our BehaviorTreeComp, BlackboardComp, AIController, and BotCharacter * will return EBTNodeResult::Succeeded if we have all of them * will return EBTNodeResult::Failed if it failed to grab any of them */ EBTNodeResult::Type resultFromSuperExecution = Super::ExecuteTask(OwnerComp, NodeMemory); // check that we successfully grabbed the BehaviorTreeComp, BlackboardComp, AIController, and BotCharacter // check that our bot implements the is Usable interface if (resultFromSuperExecution == EBTNodeResult::Succeeded && BotCharacter->GetClass()->ImplementsInterface(UAIE_IsUsable::StaticClass())) { // get our object from blackboard key FBlackboard::FKey DesiredObjectKey = Blackboard->GetKeyID("DesiredObject"); // check that our key is valid if (Blackboard->IsValidKey(DesiredObjectKey)) { // store our object as an actor AActor* desiredObjectActor = Cast<AActor>(Blackboard->GetValue<UBlackboardKeyType_Object>(DesiredObjectKey)); // get the distance from our object float distance = FVector::Dist(desiredObjectActor->GetActorLocation(), BotCharacter->GetActorLocation()); // compare distance to max reach if (distance <= MaxReach) { // array of actors to ignore TArray<AActor*> actorsToIgnore; // the bot can't get in the way of itself actorsToIgnore.Add(BotCharacter); // will hold our hit result FHitResult hit; // fire the trace and check if we hit something if (UAIE_StaticLibrary::Trace(GetWorld(), actorsToIgnore, BotCharacter->GetActorLocation(), desiredObjectActor->GetActorLocation(), hit, ECollisionChannel::ECC_WorldDynamic, false, true)) { #if !UE_BUILD_SHIPPING GEngine->AddOnScreenDebugMessage(-1, 1.0f, FColor::Red, hit.GetActor()->GetName() + " grab object"); #endif if (hit.GetActor() == desiredObjectActor) { #if !UE_BUILD_SHIPPING GEngine->AddOnScreenDebugMessage(-1, 1.0f, FColor::Red, BotCharacter->BotName.ToString() + " trying to grab object"); #endif // exacute AI_UseItem on our bot with the Desired object IAIE_IsUsable::Execute_AI_ActivateUseItem(BotCharacter, desiredObjectActor); // return success return EBTNodeResult::Succeeded; } } } } } // return failed return EBTNodeResult::Failed; }
float UAISense_Aquaphobia::Update() { AIPerception::FListenerMap& ListenersMap = *GetListeners(); //For each listener who has this sense we're going to perform a sweep to determine nearby aqua actors for (auto& Elem : ListenersMap) { //Get the listener FPerceptionListener Listener = Elem.Value; const AActor* ListenerBodyActor = Listener.GetBodyActor(); for (int32 DigestedPropertyIndex = 0; DigestedPropertyIndex < DigestedProperties.Num(); DigestedPropertyIndex++) { //Create the sphere for this sense and perform the sweep to determine nearby actors FCollisionShape CollisionSphere = FCollisionShape::MakeSphere(DigestedProperties[DigestedPropertyIndex].PhobiaRadius); TArray<FHitResult> HitResults; GetWorld()->SweepMultiByChannel(HitResults, ListenerBodyActor->GetActorLocation(), ListenerBodyActor->GetActorLocation() + FVector::UpVector*CollisionSphere.GetSphereRadius(), FQuat(), ECollisionChannel::ECC_WorldDynamic, CollisionSphere); //Draw debug sphere if we have activated it via the config if (DigestedProperties[DigestedPropertyIndex].bDisplayDebugSphere) { DrawDebugSphere(GetWorld(), ListenerBodyActor->GetActorLocation(), DigestedProperties[DigestedPropertyIndex].PhobiaRadius, 8, FColor::Blue, false, 30.f, 1, 2.f); } //Check hit results for aqua actors for (int32 i = 0; i < HitResults.Num(); i++) { FHitResult hit = HitResults[i]; //To simplify things, we're going to assume that "water resources" for this post are actors that have the following game tag if (hit.GetActor()->ActorHasTag(FName("AquaActor"))) { if ((hit.GetActor()->GetActorLocation() - ListenerBodyActor->GetActorLocation()).Size() <= DigestedProperties[DigestedPropertyIndex].PhobiaRadius) { Elem.Value.RegisterStimulus(hit.GetActor(), FAIStimulus(*this, 5.f, hit.GetActor()->GetActorLocation(), ListenerBodyActor->GetActorLocation())); GLog->Log("registered stimulus!"); } } } } } //Time until next update; in this case we're forcing the update to happen in each frame return 0.f; }
void AWeapon::DoDamage(FHitResult& ObjectHit) { FVector ImpactPoint; FVector ImpactNormal; ImpactPoint.X = ObjectHit.ImpactPoint.X; ImpactPoint.Y = ObjectHit.ImpactPoint.Y; ImpactPoint.Z = ObjectHit.ImpactPoint.Z; ImpactNormal.X = ObjectHit.ImpactNormal.X; //Use this data for placing decals if bullets hit walls etc. ImpactNormal.Y = ObjectHit.ImpactNormal.Y; ImpactNormal.Z = ObjectHit.ImpactNormal.Z; const UWorld* World = GetWorld(); if (World) { DrawDebugSphere(World, ImpactPoint, 10.0f, 8, FColor(255, 0, 0), false, 3, 0); APlayerController* PlayerController = Cast<APlayerController>(WeaponOwner->GetController()); if (PlayerController != nullptr) { const AActor* HitActor = ObjectHit.GetActor(); if (HitActor != nullptr) { if (HitActor->IsA(AEnemy::StaticClass())) { AEnemy* Enemy = (AEnemy*)HitActor; TSubclassOf<UDamageType> const ValidDamageTypeClass = TSubclassOf<UDamageType>(UDamageType::StaticClass()); FDamageEvent DamageEvent(ValidDamageTypeClass); Enemy->TakeDamage(Config.Damage, DamageEvent, PlayerController, this); } } } } }
void ADebugCameraController::Select( FHitResult const& Hit ) { // First untrack the currently tracked lightmap. UTexture2D* Texture2D = GDebugSelectedLightmap ? GDebugSelectedLightmap->GetTexture(0) : NULL; if ( Texture2D ) { UntrackTexture( Texture2D->GetName() ); } // store selection SelectedActor = Hit.GetActor(); SelectedComponent = Hit.Component.Get(); GDebugSelectedActor = SelectedActor; GDebugSelectedComponent = SelectedComponent; // figure out lightmap GDebugSelectedLightmap = NULL; UStaticMeshComponent* StaticMeshComponent = Cast<UStaticMeshComponent>( SelectedComponent ); if ( StaticMeshComponent && StaticMeshComponent->LODData.Num() > 0 ) { const FStaticMeshComponentLODInfo& LODInfo = StaticMeshComponent->LODData[0]; if ( LODInfo.LightMap ) { GDebugSelectedLightmap = LODInfo.LightMap->GetLightMap2D(); Texture2D = GDebugSelectedLightmap ? GDebugSelectedLightmap->GetTexture(0) : NULL; if ( Texture2D ) { extern bool TrackTexture( const FString& TextureName ); TrackTexture( Texture2D->GetName() ); } } } }
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); }
void ABaseWeapon::Instant_Fire() { const int32 RandomSeed = FMath::Rand(); FRandomStream WeaponRandomStream(RandomSeed); const float CurrentSpread = WeaponConfig.WeaponSpread; const float SpreadCone = FMath::DegreesToRadians(WeaponConfig.WeaponSpread * 0.5); const FVector AimDir = MyPawn->GetActorForwardVector(); const FVector StartTrace = MyPawn->GetActorLocation(); const FVector ShootDir = WeaponRandomStream.VRandCone(AimDir, SpreadCone, SpreadCone); FVector EndTrace; if (Target) { FVector TargetDir = (MyPawn->GetActorLocation() - Target->GetActorLocation()); TargetDir.Normalize(); FVector ShootDir2 = WeaponRandomStream.VRandCone(-TargetDir, SpreadCone, SpreadCone); EndTrace = StartTrace + ShootDir2 * WeaponConfig.WeaponRange; } else { EndTrace = StartTrace + ShootDir * WeaponConfig.WeaponRange; } const FHitResult Impact = WeaponTrace(StartTrace, EndTrace); SpawnParticle(EndTrace); HitActor = Cast<AActor>(Impact.GetActor()); //DrawDebugLine(GetWorld(), StartTrace, EndTrace, FColor::Red, false, 1.0f); if (HitActor) { Server_DealDamage(Impact, ShootDir, WeaponConfig); } }
void ATraceWeapon::HitResult(FHitResult Impact, const FVector Origin, FVector ShootDir) { FVector EndTrace = Origin + ShootDir * Range; FVector EndPoint = Impact.GetActor() ? Impact.ImpactPoint : EndTrace; DrawDebugLine(this->GetWorld(), Origin, Impact.TraceEnd, FColor::Blue, false, 0.2f, 10.f, 2.f); if (Impact.GetActor()) { UGameplayStatics::ApplyDamage(Impact.GetActor(), DamageDealt, Instigator->GetController(), Instigator, UDamageType::StaticClass()); } }
void ASWeaponInstant::DealDamage(const FHitResult& Impact, const FVector& ShootDir) { float ActualHitDamage = HitDamage; /* Handle special damage location on the zombie body (types are setup in the Physics Asset of the zombie */ USDamageType* DmgType = Cast<USDamageType>(DamageType->GetDefaultObject()); UPhysicalMaterial * PhysMat = Impact.PhysMaterial.Get(); if (PhysMat && DmgType) { if (PhysMat->SurfaceType == SURFACE_ZOMBIEHEAD) { ActualHitDamage *= DmgType->GetHeadDamageModifier(); } else if (PhysMat->SurfaceType == SURFACE_ZOMBIELIMB) { ActualHitDamage *= DmgType->GetLimbDamageModifier(); } } FPointDamageEvent PointDmg; PointDmg.DamageTypeClass = DamageType; PointDmg.HitInfo = Impact; PointDmg.ShotDirection = ShootDir; PointDmg.Damage = ActualHitDamage; Impact.GetActor()->TakeDamage(PointDmg.Damage, PointDmg, MyPawn->Controller, this); }
const FHitResult UGrabber::GetFirstPhysicsBodyInReach() { /// Get Player position and view data FVector PlayerViewPointLocation; FRotator PlayerViewPointRotation; GetWorld()->GetFirstPlayerController()->GetPlayerViewPoint(OUT PlayerViewPointLocation, OUT PlayerViewPointRotation); /*UE_LOG(LogTemp, Warning, TEXT("Location: %s, Rotation: %s"), *PlayerViewPointLocation.ToString(), *PlayerViewPointRotation.ToString());*/ /// Draw Debug Line based on how far can reach FVector LineTraceEnd = PlayerViewPointLocation + (PlayerViewPointRotation.Vector() * Reach); //DrawDebugLine(GetWorld(), PlayerViewPointLocation, LineTraceEnd, FColor(255, 0, 0), false, 0.f, 0.f, 10.f); /// Decide what can detect as collision FCollisionQueryParams TraceParameters(FName(TEXT("")), false, GetOwner()); FHitResult LineTraceHit; GetWorld()->LineTraceSingleByObjectType(OUT LineTraceHit, PlayerViewPointLocation, LineTraceEnd, FCollisionObjectQueryParams(ECollisionChannel::ECC_PhysicsBody), TraceParameters); AActor* ActorHit = LineTraceHit.GetActor(); if (ActorHit) { UE_LOG(LogTemp, Warning, TEXT("Line Trace Hit: %s"), *(ActorHit->GetName())); } return LineTraceHit; }
void UCarditWeapon::Fire() { auto Camera = Cast<ACarditCharacter>(GetOwner())->GetCamera(); auto CameraLocation = Camera->GetComponentLocation(); auto EndLocation = Camera->GetComponentLocation() + (Camera->GetComponentRotation().Vector() * MaxRangeInCm); DrawDebugLine(GetWorld(), CameraLocation, EndLocation, FColor(255, 0, 0), false, 5.f, 0, 2.5f); FHitResult OutHit; if (GetWorld()->LineTraceSingleByChannel( OutHit, CameraLocation, EndLocation, ECC_Visibility ) ) { if (Cast<ACarditCharacter>(OutHit.GetActor())) { GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, "Character hit"); Cast<ACarditGameMode>(UGameplayStatics::GetGameMode(GetWorld()))->DealDamageOntoCharacter(Cast<ACarditCharacter>(OutHit.GetActor()), DamagePerShot); } else { UE_LOG(LogTemp, Warning, TEXT("Non-character hit")); } } else { UE_LOG(LogTemp, Warning, TEXT("Nothing hit")); } }
AActor* ASrPlayerController::GetFriendlyTargetUnderCursor(const FVector2D& ScreenPoint, FVector& WorldImpactPoint) const { FHitResult Hit; if (GetHitResultAtScreenPosition(ScreenPoint, COLLISION_WEAPON, true, Hit)) { auto HitActor = Hit.GetActor(); if (HitActor && HitActor->Implements<USrSelectionInterface>()) { if (this == ISrSelectionInterface::Execute_GetTeamController(HitActor)) { WorldImpactPoint = Hit.ImpactPoint; return Hit.GetActor(); } } } return nullptr; }
void AProjectile::OnHit_Implementation(UPrimitiveComponent* HitComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, FVector NormalImpulse, const FHitResult& Hit) { IDamageInterface* damageInterface = Cast<IDamageInterface>(Hit.GetActor()); //check that the actor that has hit can receive damage if (damageInterface && Hit.GetActor() != this->Instigator) //Check validity of the actor's pointer { damageInterface->ReceiveDamage(this->Stats.Damage, this, Hit); //receive damage DeactivateProjectile(); SpawnImpactFX(Hit); OnHitTarget(); //trigger blueprint event } else if (Hit.GetActor() != this->Instigator) //if the actor hit can't receive damage, deactivate the projectile (like when hitting walls) { DeactivateProjectile(); SpawnImpactFX(Hit); OnHitTarget(); } }
void ALogVisualizerHUD::PostRender() { static const FColor TextColor(200, 200, 128, 255); Super::Super::PostRender(); if (bShowHUD) { ALogVisualizerCameraController* DebugCamController = Cast<ALogVisualizerCameraController>( 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()->LineTraceSingleByChannel(Hit, CamLoc, CamRot.Vector() * 100000.f + CamLoc, ECC_Pawn, TraceParams); if (bHit && Hit.GetActor() != nullptr) { 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 AShooterWeapon_Instant::DealDamage(const FHitResult& Impact, const FVector& ShootDir) { FPointDamageEvent PointDmg; PointDmg.DamageTypeClass = InstantConfig.DamageType; PointDmg.HitInfo = Impact; PointDmg.ShotDirection = ShootDir; PointDmg.Damage = InstantConfig.HitDamage; Impact.GetActor()->TakeDamage(PointDmg.Damage, PointDmg, MyPawn->Controller, this); }
void AKIMCharacter::CheckTraceDistance() { if (IsInRoationState) { return; } FHitResult outHit; FCollisionQueryParams params; params.AddIgnoredActor(this); params.AddIgnoredActor(PickedUpItem); FVector TraceStart = CameraComponent->GetComponentLocation(); FVector TraceEnd = TraceStart + (CameraComponent->GetForwardVector() * InteractionDistance); GetWorld()->LineTraceSingleByChannel(outHit, TraceStart, TraceEnd, ECollisionChannel::ECC_PhysicsBody, params); if (outHit.GetActor() != NULL && outHit.GetActor()->GetClass()->IsChildOf(AKIMInteractionActor::StaticClass())) { if (((AKIMInteractionActor*)outHit.GetActor())->InteractionType != StoredType){ StoredType = ((AKIMInteractionActor*)outHit.GetActor())->InteractionType; SwitchIconState(StoredType); } } else { if (StoredType != EKIMInteractionTypes::NONE) { StoredType = EKIMInteractionTypes::NONE; SwitchIconState(StoredType); } } }