void UChildActorComponent::CreateChildActor()
{
// Kill spawned actor if we have one
DestroyChildActor();
// This is no longer needed
if (CachedInstanceData)
{
delete CachedInstanceData;
CachedInstanceData = nullptr;
}
// If we have a class to spawn.
if(ChildActorClass != nullptr)
{
UWorld* World = GetWorld();
if(World != nullptr)
{
// Before we spawn let's try and prevent cyclic disaster
bool bSpawn = true;
AActor* Actor = GetOwner();
while (Actor && bSpawn)
{
if (Actor->GetClass() == ChildActorClass)
{
bSpawn = false;
UE_LOG(LogChildActorComponent, Error, TEXT("Found cycle in child actor component '%s'. Not spawning Actor of class '%s' to break."), *GetPathName(), *ChildActorClass->GetName());
}
Actor = Actor->ParentComponentActor.Get();
}
if (bSpawn)
{
FActorSpawnParameters Params;
Params.bNoCollisionFail = true;
Params.bDeferConstruction = true; // We defer construction so that we set ParentComponentActor prior to component registration so they appear selected
Params.bAllowDuringConstructionScript = true;
Params.OverrideLevel = GetOwner()->GetLevel();
Params.Name = ChildActorName;
if (!HasAllFlags(RF_Transactional))
{
Params.ObjectFlags &= ~RF_Transactional;
}
// Spawn actor of desired class
FVector Location = GetComponentLocation();
FRotator Rotation = GetComponentRotation();
ChildActor = World->SpawnActor(ChildActorClass, &Location, &Rotation, Params);
// If spawn was successful,
if(ChildActor != nullptr)
{
ChildActorName = ChildActor->GetFName();
// Remember which actor spawned it (for selection in editor etc)
ChildActor->ParentComponentActor = GetOwner();
ChildActor->AttachRootComponentTo(this);
// Parts that we deferred from SpawnActor
ChildActor->FinishSpawning(ComponentToWorld);
}
}
}
}
}
void UCameraComponent::GetCameraView(float DeltaTime, FMinimalViewInfo& DesiredView)
{
if (bUsePawnControlRotation)
{
if (APawn* OwningPawn = Cast<APawn>(GetOwner()))
{
const FRotator PawnViewRotation = OwningPawn->GetViewRotation();
if (!PawnViewRotation.Equals(GetComponentRotation()))
{
SetWorldRotation(PawnViewRotation);
}
}
}
DesiredView.Location = GetComponentLocation();
DesiredView.Rotation = GetComponentRotation();
DesiredView.FOV = FieldOfView;
DesiredView.AspectRatio = AspectRatio;
DesiredView.bConstrainAspectRatio = bConstrainAspectRatio;
DesiredView.ProjectionMode = ProjectionMode;
DesiredView.OrthoWidth = OrthoWidth;
// See if the CameraActor wants to override the PostProcess settings used.
DesiredView.PostProcessBlendWeight = PostProcessBlendWeight;
if (PostProcessBlendWeight > 0.0f)
{
DesiredView.PostProcessSettings = PostProcessSettings;
}
}
void USCarryObjectComponent::TickComponent(float DeltaSeconds, enum ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction)
{
if (APawn* OwningPawn = Cast<APawn>(GetOwner()))
{
if (OwningPawn->IsLocallyControlled())
{
Super::TickComponent(DeltaSeconds, TickType, ThisTickFunction);
}
else
{
/* NOTE: Slightly changed code from base implementation (USpringArmComponent) to use RemoteViewPitch instead of non-replicated ControlRotation */
if (bUsePawnControlRotation)
{
{
/* Re-map uint8 to 360 degrees */
const float PawnViewPitch = (OwningPawn->RemoteViewPitch / 255.f)*360.f;
if (PawnViewPitch != GetComponentRotation().Pitch)
{
FRotator NewRotation = GetComponentRotation();
NewRotation.Pitch = PawnViewPitch;
SetWorldRotation(NewRotation);
}
}
}
UpdateDesiredArmLocation(bDoCollisionTest, bEnableCameraLag, bEnableCameraRotationLag, DeltaSeconds);
}
}
}
void USCarryObjectComponent::TickComponent(float DeltaSeconds, enum ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction)
{
//if (GetIsCarryingActor())
//{
// perform an overlap check of the actor vs. environment. must have 0 overlaps from Static and Dynamic and Pawn channels.
// Use param NAME to update the color between red and green
//}
if (APawn* OwningPawn = Cast<APawn>(GetOwner()))
{
if (OwningPawn->IsLocallyControlled())
{
Super::TickComponent(DeltaSeconds, TickType, ThisTickFunction);
}
else
{
/* NOTE: Slightly changed code from base implementation (USpringArmComponent) to use RemoteViewPitch instead of non-replicated ControlRotation */
if (bUsePawnControlRotation)
{
{
/* Re-map uint8 to 360 degrees */
const float PawnViewPitch = (OwningPawn->RemoteViewPitch / 255.f)*360.f;
if (PawnViewPitch != GetComponentRotation().Pitch)
{
FRotator NewRotation = GetComponentRotation();
NewRotation.Pitch = PawnViewPitch;
SetWorldRotation(NewRotation);
}
}
}
UpdateDesiredArmLocation(bDoCollisionTest, bEnableCameraLag, bEnableCameraRotationLag, DeltaSeconds);
}
}
}
void UMWBotWeaponComponent::Fire()
{
if (!CanFire())
{
return;
}
// cast a line
FHitResult hit;
FCollisionQueryParams traceParams;
traceParams.AddIgnoredActor(GetOwner());
const int32 randSeed = FMath::Rand();
FRandomStream randStream(randSeed);
const FVector traceStart = GetComponentLocation();
const FVector aimDir = GetComponentRotation().Vector();
const FVector shotDir = randStream.VRandCone(aimDir, FMath::DegreesToRadians(Spread));
const FVector traceEnd = traceStart + shotDir * 1e5;
GetWorld()->LineTraceSingle(hit, traceStart, traceEnd, ECollisionChannel::ECC_Visibility, traceParams);
ProcessHit(hit);
// temporary draw
if (hit.bBlockingHit)
{
DrawDebugLine(GetWorld(), traceStart, hit.ImpactPoint, FColor::Red, false, -1.f, 0, 10);
}
else
{
DrawDebugLine(GetWorld(), traceStart, traceEnd, FColor::Red, false, -1.f, 0, 10);
}
}
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"));
}
}
void USCarryObjectComponent::Throw()
{
if (!GetIsCarryingActor())
return;
if (GetOwner()->Role < ROLE_Authority)
{
ServerThrow();
return;
}
/* Grab a reference to the MeshComp before dropping the object */
UStaticMeshComponent* MeshComp = GetCarriedMeshComp();
if (MeshComp)
{
/* Detach and re-enable collision */
OnDropMulticast();
APawn* OwningPawn = Cast<APawn>(GetOwner());
if (OwningPawn)
{
/* Re-map uint8 to 360 degrees */
const float PawnViewPitch = (OwningPawn->RemoteViewPitch / 255.f)*360.f;
FRotator NewRotation = GetComponentRotation();
NewRotation.Pitch = PawnViewPitch;
/* Apply physics impulse, ignores mass */
MeshComp->AddImpulse(NewRotation.Vector() * 1000, NAME_None, true);
}
}
}
void UFireComponent::OnDoAction_Implementation()
{
if (CheckCoolTime && IsCoolTimeOver() == false)
{
return;
}
if (ActionObject != nullptr)
{
UWorld* const World = GetWorld();
if (World)
{
// Set the spawn parameters.
FActorSpawnParameters SpawnParams;
SpawnParams.Owner = GetOwner();
// Get a random location to spawn at.
FVector SpawnLocation = GetComponentLocation();
// Get a random rotation for the spawned item.
FRotator SpawnRotation = GetComponentRotation();
ANruActionObject * actor = World->SpawnActor<ANruActionObject>(ActionObject, SpawnLocation, SpawnRotation, SpawnParams);
actor->Level = Level;
}
}
if (CheckCoolTime)
{
CurCoolTime = 0.f;
}
}
void UDebugHandUtility::DebugOrientation(FRotator Orientation, FVector At, float Scale)
{
FRotator rotation = UKismetMathLibrary::ComposeRotators(Orientation, GetComponentRotation());
FVector EndArrow = (UKismetMathLibrary::GetForwardVector(rotation)*Scale) + At;
DrawDebugDirectionalArrow(GetWorld(), At, EndArrow, 5, FColor::Black);
FVector Extent = Scale * FVector(0.2, 0.2, 0.2);
DrawDebugBox(GetWorld(), EndArrow, Extent, rotation.Quaternion(), FColor::Black);
}
bool UMWBotSensorComponent::CheckAOS(const AActor* Actor, float Angle) const
{
// Calculate dot product of two vector and check the angle between them
if (!Actor/* || bCrazy*/)
{
return false;
}
const FVector toActor = (Actor->GetActorLocation() - GetComponentLocation()).SafeNormal();
const FVector sightOrt = GetComponentRotation().Vector();
const float dotProd = toActor | sightOrt;
const float cosA = FMath::Cos(FMath::DegreesToRadians(Angle));
return dotProd > cosA;
}
void USpringArmComponent::TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
{
Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
if (bUsePawnControlRotation)
{
if (APawn* OwningPawn = Cast<APawn>(GetOwner()))
{
const FRotator PawnViewRotation = OwningPawn->GetViewRotation();
if (PawnViewRotation != GetComponentRotation())
{
SetWorldRotation(PawnViewRotation);
}
}
}
UpdateDesiredArmLocation(bDoCollisionTest, bEnableCameraLag, bEnableCameraRotationLag, DeltaTime);
}
void UDebugHandUtility::DebugOrientationAtRelative(FRotator Orientation, FVector Relative, FVector Offset, float Scale)
{
FVector position = GetComponentRotation().RotateVector(Relative + Offset) + GetComponentLocation();
DebugOrientation(Orientation, position, Scale);
}
void UDebugHandUtility::DebugSphereAtActor(FVector Location, float Scale, float Radius, FVector Offset)
{
FVector res = Scale*this->GetComponentRotation().RotateVector(Location + Offset) + this->GetComponentLocation();
DrawDebugSphere(GetWorld(), GetComponentRotation().RotateVector(res), Radius, 12, FColor::Black);
}
void USpringArmComponent::UpdateDesiredArmLocation(bool bDoTrace, bool bDoLocationLag, bool bDoRotationLag, float DeltaTime)
{
FRotator DesiredRot = GetComponentRotation();
// If inheriting rotation, check options for which components to inherit
if(!bAbsoluteRotation)
{
if(!bInheritPitch)
{
DesiredRot.Pitch = RelativeRotation.Pitch;
}
if (!bInheritYaw)
{
DesiredRot.Yaw = RelativeRotation.Yaw;
}
if (!bInheritRoll)
{
DesiredRot.Roll = RelativeRotation.Roll;
}
}
// Apply 'lag' to rotation if desired
if(bDoRotationLag)
{
DesiredRot = FMath::RInterpTo(PreviousDesiredRot, DesiredRot, DeltaTime, CameraRotationLagSpeed);
}
PreviousDesiredRot = DesiredRot;
// Get the spring arm 'origin', the target we want to look at
FVector ArmOrigin = GetComponentLocation() + TargetOffset;
// We lag the target, not the actuall camera position, so rotating the camera around does not hav lag
FVector DesiredLoc = ArmOrigin;
if (bDoLocationLag)
{
DesiredLoc = FMath::VInterpTo(PreviousDesiredLoc, DesiredLoc, DeltaTime, CameraLagSpeed);
}
PreviousDesiredLoc = DesiredLoc;
// Now offset camera position back along our rotation
DesiredLoc -= DesiredRot.Vector() * TargetArmLength;
// Add socket offset in local space
DesiredLoc += FRotationMatrix(DesiredRot).TransformVector(SocketOffset);
// Do a sweep to ensure we are not penetrating the world
FVector ResultLoc;
if (bDoTrace && (TargetArmLength != 0.0f))
{
static FName TraceTagName(TEXT("SpringArm"));
FCollisionQueryParams QueryParams(TraceTagName, false, GetOwner());
FHitResult Result;
GetWorld()->SweepSingle(Result, ArmOrigin, DesiredLoc, FQuat::Identity, ProbeChannel, FCollisionShape::MakeSphere(ProbeSize), QueryParams);
ResultLoc = BlendLocations(DesiredLoc, Result.Location, Result.bBlockingHit, DeltaTime);
}
else
{
ResultLoc = DesiredLoc;
}
// Form a transform for new world transform for camera
FTransform WorldCamTM(DesiredRot, ResultLoc);
// Convert to relative to component
FTransform RelCamTM = WorldCamTM.GetRelativeTransform(ComponentToWorld);
// Update socket location/rotation
RelativeSocketLocation = RelCamTM.GetLocation();
RelativeSocketRotation = RelCamTM.GetRotation();
UpdateChildTransforms();
}
void UChildActorComponent::CreateChildActor()
{
// Kill spawned actor if we have one
DestroyChildActor();
// If we have a class to spawn.
if(ChildActorClass != nullptr)
{
UWorld* World = GetWorld();
if(World != nullptr)
{
// Before we spawn let's try and prevent cyclic disaster
bool bSpawn = true;
AActor* MyOwner = GetOwner();
AActor* Actor = MyOwner;
while (Actor && bSpawn)
{
if (Actor->GetClass() == ChildActorClass)
{
bSpawn = false;
UE_LOG(LogChildActorComponent, Error, TEXT("Found cycle in child actor component '%s'. Not spawning Actor of class '%s' to break."), *GetPathName(), *ChildActorClass->GetName());
}
if (UChildActorComponent* ParentComponent = Actor->GetParentComponent())
{
Actor = ParentComponent->GetOwner();
}
else
{
Actor = nullptr;
}
}
if (bSpawn)
{
FActorSpawnParameters Params;
Params.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
Params.bDeferConstruction = true; // We defer construction so that we set ParentComponent prior to component registration so they appear selected
Params.bAllowDuringConstructionScript = true;
Params.OverrideLevel = (MyOwner ? MyOwner->GetLevel() : nullptr);
Params.Name = ChildActorName;
if (!HasAllFlags(RF_Transactional))
{
Params.ObjectFlags &= ~RF_Transactional;
}
// Spawn actor of desired class
FVector Location = GetComponentLocation();
FRotator Rotation = GetComponentRotation();
ChildActor = World->SpawnActor(ChildActorClass, &Location, &Rotation, Params);
// If spawn was successful,
if(ChildActor != nullptr)
{
ChildActorName = ChildActor->GetFName();
// Remember which component spawned it (for selection in editor etc)
FActorParentComponentSetter::Set(ChildActor, this);
// Parts that we deferred from SpawnActor
const FComponentInstanceDataCache* ComponentInstanceData = (CachedInstanceData ? CachedInstanceData->ComponentInstanceData : nullptr);
ChildActor->FinishSpawning(ComponentToWorld, false, ComponentInstanceData);
ChildActor->AttachRootComponentTo(this, NAME_None, EAttachLocation::SnapToTarget);
}
}
}
}
// This is no longer needed
if (CachedInstanceData)
{
delete CachedInstanceData;
CachedInstanceData = nullptr;
}
}
void UChildActorComponent::CreateChildActor()
{
AActor* MyOwner = GetOwner();
if (MyOwner && !MyOwner->HasAuthority())
{
AActor* ChildClassCDO = (ChildActorClass ? ChildActorClass->GetDefaultObject<AActor>() : nullptr);
if (ChildClassCDO && ChildClassCDO->GetIsReplicated())
{
// If we belong to an actor that is not authoritative and the child class is replicated then we expect that Actor will be replicated across so don't spawn one
return;
}
}
// Kill spawned actor if we have one
DestroyChildActor();
// If we have a class to spawn.
if(ChildActorClass != nullptr)
{
UWorld* World = GetWorld();
if(World != nullptr)
{
// Before we spawn let's try and prevent cyclic disaster
bool bSpawn = true;
AActor* Actor = MyOwner;
while (Actor && bSpawn)
{
if (Actor->GetClass() == ChildActorClass)
{
bSpawn = false;
UE_LOG(LogChildActorComponent, Error, TEXT("Found cycle in child actor component '%s'. Not spawning Actor of class '%s' to break."), *GetPathName(), *ChildActorClass->GetName());
}
Actor = Actor->GetParentActor();
}
if (bSpawn)
{
FActorSpawnParameters Params;
Params.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
Params.bDeferConstruction = true; // We defer construction so that we set ParentComponent prior to component registration so they appear selected
Params.bAllowDuringConstructionScript = true;
Params.OverrideLevel = (MyOwner ? MyOwner->GetLevel() : nullptr);
Params.Name = ChildActorName;
Params.Template = ChildActorTemplate;
if (!HasAllFlags(RF_Transactional))
{
Params.ObjectFlags &= ~RF_Transactional;
}
// Spawn actor of desired class
ConditionalUpdateComponentToWorld();
FVector Location = GetComponentLocation();
FRotator Rotation = GetComponentRotation();
ChildActor = World->SpawnActor(ChildActorClass, &Location, &Rotation, Params);
// If spawn was successful,
if(ChildActor != nullptr)
{
ChildActorName = ChildActor->GetFName();
// Remember which component spawned it (for selection in editor etc)
FActorParentComponentSetter::Set(ChildActor, this);
// Parts that we deferred from SpawnActor
const FComponentInstanceDataCache* ComponentInstanceData = (CachedInstanceData ? CachedInstanceData->ComponentInstanceData : nullptr);
ChildActor->FinishSpawning(ComponentToWorld, false, ComponentInstanceData);
ChildActor->AttachToComponent(this, FAttachmentTransformRules::SnapToTargetNotIncludingScale);
SetIsReplicated(ChildActor->GetIsReplicated());
}
}
}
}
// This is no longer needed
if (CachedInstanceData)
{
delete CachedInstanceData;
CachedInstanceData = nullptr;
}
}
