void AVessel::UpdateVisibility()
{
if (BuildStage != EVesselBuildStage::Hidden || ShowEvenWhenHidden) {
SetActorHiddenInGame(false);
}
else {
// BuildStage == Hidden && ShowEvenWhenHidden == false
SetActorHiddenInGame(true);
}
}
// Executed when CurrentWeaponIndex is replicated
void AMurphysLawCharacter::OnRep_CurrentWeaponIndex(int32 OldIndex)
{
auto OldWeapon = Inventory->GetWeapon(OldIndex);
auto OldFullMeshWeapon = Inventory->GetFullMeshWeapon(OldIndex);
auto NewFullMeshWeapon = Inventory->GetFullMeshWeapon(CurrentWeaponIndex);
// Hide the old weapons
if (OldWeapon != nullptr) OldWeapon->SetActorHiddenInGame(true);
if (OldFullMeshWeapon != nullptr) OldFullMeshWeapon->SetActorHiddenInGame(true);
// And show the new ones
if (HasWeaponEquipped()) GetEquippedWeapon()->SetActorHiddenInGame(false);
if (NewFullMeshWeapon != nullptr) NewFullMeshWeapon->SetActorHiddenInGame(false);
}
void AVehiclePawn::OnDeath()
{
AVehiclePlayerController* MyPC = Cast<AVehiclePlayerController>(GetController());
bReplicateMovement = false;
bIsDying = true;
DetachFromControllerPendingDestroy();
// hide and disable
TurnOff();
SetActorHiddenInGame(true);
if (EngineAC)
{
EngineAC->Stop();
}
if (SkidAC)
{
SkidAC->Stop();
}
PlayDestructionFX();
// Give use a finite lifespan
SetLifeSpan( 0.2f );
}
// Sets default values
AOrionCrystal::AOrionCrystal()
{
// Set this actor to call Tick() every frame. You can turn this off to improve performance if you don't need it.
PrimaryActorTick.bCanEverTick = true;
SetActorHiddenInGame(true);
}
void AMech_RPGCharacter::PostHealthChange(FHealthChange healthChange)
{
CLAMP(health, GetMaxHealth(), 0);
if (OnPostHealthChange.IsBound()) {
OnPostHealthChange.Broadcast(healthChange);
}
UFloatingTextUI::CreateFloatingText(floatingTextClass, healthChange);
if (health <= 0) {
health = 0;
SetDead(true);
SetActorHiddenInGame(true);
if (GetCurrentWeapon() != nullptr) GetCurrentWeapon()->SetActorHiddenInGame(true);
OnStopFiring.Broadcast();
healthChange.manipulator->EnemyKilled(this);
if (GetGroup()->GetPlayer() == nullptr) {
ItemEnumns::ItemType type = UMiscLibrary::GetRandomEnum(ItemEnumns::Resource);
AItem* newItem = CalucluateItemDrop(healthChange.manipulator->GetGroup(), type);
AItemPickup::CreateItemPickup(newItem)->SetActorLocation(GetActorLocation());
}
}
if (GetFloatingStats() != nullptr) {
GetFloatingStats()->UpdateHealthBar();
}
if (GetCharacterStats() != nullptr) {
GetCharacterStats()->UpdateHealthBar();
}
}
void AViewManager::TurnOnOutlineRendering()
{
PostProcessVolume->bEnabled = true;
for (TObjectIterator<AActor> Itr; Itr; ++Itr)
{
auto CurrentObject = *Itr;
bool FoundOutlineObject = false;
for (auto OutlineObject : PlanElements)
{
if (OutlineObject == CurrentObject)
{
FoundOutlineObject = true;
}
}
if (!FoundOutlineObject)
{
CurrentObject->SetActorHiddenInGame(true);
}
}
for (auto OutlineObject : PlanElements)
{
if (OutlineObject)
{
OutlineObject->SetActorHiddenInGame(false);
auto RenderComponent = OutlineObject->GetRootPrimitiveComponent();
if (RenderComponent)
{
RenderComponent->bRenderCustomDepth = true;
RenderComponent->bRenderInMainPass = false;
RenderComponent->MarkRenderStateDirty();
}
}
}
}
ACVehicleSpawner::ACVehicleSpawner(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer){
USkeletalMeshComponent* Mesh = ObjectInitializer.CreateDefaultSubobject<USkeletalMeshComponent>(this, TEXT("Mesh"));
static ConstructorHelpers::FObjectFinder<USkeletalMesh> PlaceHolderMesh(TEXT("SkeletalMesh'/Game/Spawner/placeholder_vehicle.placeholder_vehicle'"));
Mesh->SetSkeletalMesh(PlaceHolderMesh.Object);
RootComponent = Mesh;
SetActorHiddenInGame(true);
static ConstructorHelpers::FClassFinder<AFlockingVehicle> CarFinder(TEXT("/Game/Vehicle/FlockingCar"));
static ConstructorHelpers::FClassFinder<AFlockingVehicle> SedanFinder(TEXT("/Game/Vehicle/FlockingSedan"));
static ConstructorHelpers::FClassFinder<AFlockingVehicle> EmergencyFinder(TEXT("/Game/Vehicle/EmergencyVehicle"));
static ConstructorHelpers::FClassFinder<AFlockingVehicle> BusFinder(TEXT("/Game/Vehicle/FlockingBus"));
static ConstructorHelpers::FObjectFinder<UMaterial> Yellow(TEXT("Material'/Game/Sedan/Materials/M_Vehicle_Sedan_yelllo.M_Vehicle_Sedan_yelllo'"));
static ConstructorHelpers::FObjectFinder<UMaterial> Blue(TEXT("Material'/Game/Sedan/Materials/M_Vehicle_Sedan.M_Vehicle_Sedan'"));
static ConstructorHelpers::FObjectFinder<UMaterial> Green(TEXT("Material'/Game/Sedan/Materials/M_Vehicle_Sedan_green.M_Vehicle_Sedan_green'"));
VehicleTypeClass.Add((uint8)EVehicleType::VT_Car, CarFinder.Class);
VehicleTypeClass.Add((uint8)EVehicleType::VT_Sedan, SedanFinder.Class);
VehicleTypeClass.Add((uint8)EVehicleType::VT_Bus, BusFinder.Class);
VehicleTypeClass.Add((uint8)EVehicleType::VT_Emergency, EmergencyFinder.Class);
TArray<UMaterial*> Materials;
Materials.Add(Yellow.Object);
Materials.Add(Blue.Object);
Materials.Add(Green.Object);
VehicleTypeMaterials.Add((uint8)EVehicleType::VT_Car, Materials);
VehicleTypeMaterials.Add((uint8)EVehicleType::VT_Sedan, Materials);
}
void AViewManager::TurnOffOutlineRendering()
{
PostProcessVolume->bEnabled = false;
for (TObjectIterator<AActor> Itr; Itr; ++Itr)
{
auto CurrentObject = *Itr;
if (CurrentObject)
{
CurrentObject->SetActorHiddenInGame(false);
}
}
for (auto OutlineObject : PlanElements)
{
if (OutlineObject)
{
OutlineObject->SetActorHiddenInGame(false);
auto RenderComponent = OutlineObject->GetRootPrimitiveComponent();
if (RenderComponent)
{
RenderComponent->bRenderCustomDepth = false;
RenderComponent->bRenderInMainPass = true;
RenderComponent->MarkRenderStateDirty();
}
}
}
CameraSwitchToStandardPerspective();
}
void ABaseCharacter::SetRagdollPhysics()
{
USkeletalMeshComponent* Mesh3P = GetMesh();
if (Mesh3P)
{
Mesh3P->SetCollisionProfileName(TEXT("Ragdoll"));
}
SetActorEnableCollision(true);
if (!IsPendingKill() || Mesh3P || Mesh3P->GetPhysicsAsset())
{
Mesh3P->SetAllBodiesSimulatePhysics(true);
Mesh3P->SetSimulatePhysics(true);
Mesh3P->WakeAllRigidBodies();
Mesh3P->bBlendPhysics = true;
SetLifeSpan(TimeAfterDeathBeforeDestroy);
}
else
{
// Immediately hide the pawn
TurnOff();
SetActorHiddenInGame(true);
SetLifeSpan(1.0f);
}
UCharacterMovementComponent* CharacterComp = Cast<UCharacterMovementComponent>(GetMovementComponent());
if (CharacterComp)
{
CharacterComp->StopMovementImmediately();
CharacterComp->DisableMovement();
CharacterComp->SetComponentTickEnabled(false);
}
}
void ABomb::OnExplosion_Implementation()
{
if (ExplosionEffects)
UGameplayStatics::SpawnEmitterAtLocation(this, ExplosionEffects, GetActorLocation(), FRotator::ZeroRotator, true);
SetActorEnableCollision(false);
SetActorHiddenInGame(true);
}
void ARPGProjectile::DisableAndDestroy()
{
SetActorHiddenInGame(true);
MovementComp->StopMovementImmediately();
// give clients some time to show explosion
SetLifeSpan( 1.0f );
}
void AInventoryItem::UseItem(AProject_152Character* ItemOwner)
{
SetActorHiddenInGame(true);
SetActorEnableCollision(false);
ItemUsed(ItemOwner); // Call the blueprint event
}
void ANavigationData::CleanUpAndMarkPendingKill()
{
CleanUp();
SetActorHiddenInGame(true);
// do NOT destroy here! it can be called from PostLoad and will crash in DestroyActor()
MarkPendingKill();
MarkComponentsAsPendingKill();
}
void ALeafNode::Init(UBinaryTree* a_Tree, const FVector2D& a_Dimensions)
{
Tree = a_Tree;
SetActorHiddenInGame(true);
Dimensions = a_Dimensions;
Rand.GenerateNewSeed();
}
float AGhost::TakeDamage(float Damage, FDamageEvent const & DamageEvent, AController * EventInstigator, AActor * DamageCauser)
{
if (ShouldTakeDamage(Damage, DamageEvent, EventInstigator, DamageCauser))
{
SetActorHiddenInGame(true);
Destroy();
}
return 0.f;
}
bool AGameplayCueNotify_Actor::Recycle()
{
bHasHandledOnActiveEvent = false;
bHasHandledWhileActiveEvent = false;
bHasHandledOnRemoveEvent = false;
ClearOwnerDestroyedDelegate();
if (FinishTimerHandle.IsValid())
{
FinishTimerHandle.Invalidate();
}
// End timeline components
TInlineComponentArray<UTimelineComponent*> TimelineComponents(this);
for (UTimelineComponent* Timeline : TimelineComponents)
{
if (Timeline)
{
// May be too spammy, but want to call visibility to this. Maybe make this editor only?
if (Timeline->IsPlaying())
{
ABILITY_LOG(Warning, TEXT("GameplayCueNotify_Actor %s had active timelines when it was recycled."), *GetName());
}
Timeline->SetPlaybackPosition(0.f, false, false);
Timeline->Stop();
}
}
UWorld* MyWorld = GetWorld();
if (MyWorld)
{
// Note, ::Recycle is called on CDOs too, so that even "new" GCs start off in a recycled state.
// So, its ok if there is no valid world here, just skip the stuff that has to do with worlds.
if (MyWorld->GetLatentActionManager().GetNumActionsForObject(this))
{
// May be too spammy, but want ot call visibility to this. Maybe make this editor only?
ABILITY_LOG(Warning, TEXT("GameplayCueNotify_Actor %s has active latent actions (Delays, etc) when it was recycled."), *GetName());
}
// End latent actions
MyWorld->GetLatentActionManager().RemoveActionsForObject(this);
// End all timers
MyWorld->GetTimerManager().ClearAllTimersForObject(this);
}
// Clear owner, hide, detach from parent
SetOwner(nullptr);
SetActorHiddenInGame(true);
DetachRootComponentFromParent();
return true;
}
void ACreatureCollectionActor::HideAllActors(ACreatureCollectionClip& collection_data, ACreatureActor * exceptActor)
{
for (auto& cur_data : collection_data.actor_sequence)
{
auto cur_actor = cur_data.first;
if (exceptActor != cur_actor) {
cur_actor->SetDriven(false);
cur_actor->SetActorHiddenInGame(true);
}
}
}
void AProjectile::Tick(float DeltaTime)
{
Super::Tick(DeltaTime);
if (HasAuthority())
{
if ((movementComponent->bIsHomingProjectile && !IsValid(homingTarget)) || (movementComponent->bIsHomingProjectile && IsValid(homingTarget) && !homingTarget->IsTargetable()))
{
Destroy();
return;
}
if (((movementComponent->bIsHomingProjectile && IsValid(homingTarget) && !homingTarget->IsAlive())) && GetWorldTimerManager().GetTimerRemaining(TimerHandle_LifeSpanExpired) <= 0.f)
{
SetLifeSpan(5.f);
return;
}
if (movementComponent->bIsHomingProjectile && IsValid(homingTarget) && homingTarget->GetActorLocation().Equals(GetActorLocation(), 15.f))
{
homingTarget->PlayCharacterSound(hitSound);
FDamageEvent damageEvent(damageType);
homingTarget->CharacterTakeDamage(damage, damageEvent, projectileSpawner->GetRealmController(), this, realmDamage, damageDesc);
Destroy();
return;
}
}
else
{
//if its a homing projectile, hide if the owner is hidden unless the target is the local player
if (IsValid(homingTarget) && IsValid(projectileSpawner) && projectileSpawner->bHidden)
SetActorHiddenInGame(true);
ARealmPlayerController* localPC = Cast<ARealmPlayerController>(GetWorld()->GetFirstPlayerController());
if (bHidden && IsValid(localPC) && IsValid(localPC->GetPlayerCharacter()))
SetActorHiddenInGame(!(localPC->GetPlayerCharacter() == homingTarget));
}
}
void AEnemy::NotifyActorBeginOverlap(AActor* Other)
{
if (!bHidden && Other->ActorHasTag(TEXT("player")))
{
player = (AUfo*)Other;
if (player)
{
if (player->isSpecial)
{
AudioDied->Play();
gameState->score += 500;
SetActorHiddenInGame(true);
GetWorldTimerManager().ClearTimer(newHandle);
GetWorldTimerManager().SetTimer(newHandle, this, &AEnemy::SpawnNew, 3.0f, false);
}
else if(!player->dying)
{
AudioKilled->Play();
player->SetActorHiddenInGame(true);
player->dying = true;
player->velMultiplier = 0.0f;
gameState->score -= 1000;
if (gameState->score < 0)
{
gameState->score = 0;
}
gameState->lives -= 1;
if (gameState->lives <= 0)
{
gameState->gameOver = true;
//Can't decide if I pause the game completely or just keep it going...
//UGameplayStatics::SetGamePaused(GetWorld(), true);
player->StaticMesh->SetAllPhysicsLinearVelocity(FVector::ZeroVector);
player->velMultiplier = 0.0f;
player->StaticMesh->SetAllPhysicsPosition(FVector(0.0f, 0.0f, 500.0f));
}
else
{
GetWorldTimerManager().ClearTimer(playerHandle);
GetWorldTimerManager().SetTimer(playerHandle, this, &AEnemy::RespawnPlayer, 3.0f, false);
}
}
}
}
}
void ADwarfGold::OnPickedUp(ADwarfPlayerController* DwarfController)
{
if (bCollected)
{
return;
}
ADwarfGameState* DwarfGameState = GetWorld()->GetGameState<ADwarfGameState>();
DwarfGameState->CoinsCollected++;
SetActorHiddenInGame(true);
SetLifeSpan(0.1f);
bCollected = true;
}
void AProjectile::DeactivateProjectile()
{
bIsActive = false;
SetActorHiddenInGame(true);
//set the projectile in a hidden position outside game
SetActorLocation(FVector(0, 1000, 3000));
//deactive collisions and movement
CollisionComp->Deactivate();
MovementComp->Deactivate();
}
void AActor::PostNetReceive()
{
ExchangeB( bHidden, SavedbHidden );
Exchange ( Owner, SavedOwner );
if (bHidden != SavedbHidden)
{
SetActorHiddenInGame(SavedbHidden);
}
if (Owner != SavedOwner)
{
SetOwner(SavedOwner);
}
}
void AMagicBattleSoccerWeapon::AttachMeshToPawn(FName InSocketName)
{
if (nullptr != MyPawn)
{
// Remove and hide both first and third person meshes
DetachMeshFromPawn();
// Attach the weapon to the player's right hand
USkeletalMeshComponent* PlayerMesh = Cast<USkeletalMeshComponent>(MyPawn->GetComponentByClass(USkeletalMeshComponent::StaticClass()));
AttachRootComponentTo(PlayerMesh, InSocketName, EAttachLocation::SnapToTarget);
// Show our mesh
SetActorHiddenInGame(false);
}
}
void APacmanPickup::NotifyActorBeginOverlap(AActor *OtherActor)
{
Super::NotifyActorBeginOverlap(OtherActor);
// Pickup can be taken only once
if (!IsPendingKill())
{
// Apply pickup effect
Pickup(OtherActor);
UGameplayStatics::PlaySound2D(this, PickupSound);
SetActorHiddenInGame(true);
Destroy();
}
}
void AProjectile::ActivateProjectile(const FVector& location, const FRotator& rotator, ACharacter* initializer)
{
bIsActive = true;
//set the projectile at the start position, and rotates to the aim rotation
SetActorLocation(location);
SetActorRotation(rotator);
Instigator = initializer;
SetActorHiddenInGame(false);
InitializeProjectile(initializer);
CollisionComp->Activate(true);
MovementComp->Activate(true);
}
void ALonelyMenCharacter::SetRagDollPhysics()
{
bool bInRagdoll = false;
if (IsPendingKill())
{
bInRagdoll = false;
}
else if (!GetMesh() || !GetMesh()->GetPhysicsAsset())
{
bInRagdoll = false;
}
else
{
//init physics
GetMesh()->SetAllBodiesSimulatePhysics(true);
GetMesh()->SetSimulatePhysics(true);
GetMesh()->WakeAllRigidBodies();
GetMesh()->bBlendPhysics = true;
bInRagdoll = true;
}
GetCharacterMovement()->StopMovementImmediately();
GetCharacterMovement()->DisableMovement();
GetCharacterMovement()->SetComponentTickEnabled(false);
if (!bInRagdoll)
{
//hide and set short lifespan
TurnOff();
SetActorHiddenInGame(true);
SetLifeSpan(1.0f);
}
else
{
float beginTime, endTime;
GetMesh()->AnimScriptInstance->GetCurrentActiveMontage()->GetSectionStartAndEndTime(0, beginTime, endTime);
SetLifeSpan(endTime - endTime*0.4);
}
}
// Sets default values
AOrionRandomWaveSpawner::AOrionRandomWaveSpawner(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer)
{
PrimaryActorTick.bCanEverTick = true;
//PreviewMesh = ObjectInitializer.CreateOptionalDefaultSubobject<USkeletalMeshComponent>(this, TEXT("Preview"));
//PreviewMesh->AlwaysLoadOnClient = true;
//PreviewMesh->AlwaysLoadOnServer = true;
//PreviewMesh->bHiddenInGame = true;
//RootComponent = PreviewMesh;
LastPodTime = -20.0f;
bRaptor = true;
bCompy = true;
bDilo = true;
bTRex = true;
bTriceratops = true;
bRham = true;
bPtera = true;
bAnky = true;
bKruger = true;
bJeckyl = true;
bNamor = true;
bViper = true;
bOrbDroid = true;
bBones = true;
bAssault = true;
bSupport = true;
bRecon = true;
bTech = true;
bDemo = true;
SpawnRadius = 5000.0f;
MaxToSpawnPerFrame = 10;
SetActorHiddenInGame(true);
static ConstructorHelpers::FObjectFinder<UBlueprint> FilterObject(TEXT("/Game/AI/Blueprints/NavFilter_LargeDino.NavFilter_LargeDino"));
if (FilterObject.Object != NULL)
{
DefaultFilterClass = (UClass*)FilterObject.Object->GeneratedClass;
}
}
void AShooterCharacter::SetRagdollPhysics()
{
bool bInRagdoll = false;
USkeletalMeshComponent* Mesh3P = GetMesh();
if (IsPendingKill())
{
bInRagdoll = false;
}
else if (!Mesh3P || !Mesh3P->GetPhysicsAsset())
{
bInRagdoll = false;
}
else
{
Mesh3P->SetAllBodiesSimulatePhysics(true);
Mesh3P->SetSimulatePhysics(true);
Mesh3P->WakeAllRigidBodies();
Mesh3P->bBlendPhysics = true;
bInRagdoll = true;
}
UCharacterMovementComponent* CharacterComp = Cast<UCharacterMovementComponent>(GetMovementComponent());
if (CharacterComp)
{
CharacterComp->StopMovementImmediately();
CharacterComp->DisableMovement();
CharacterComp->SetComponentTickEnabled(false);
}
if (!bInRagdoll)
{
// Immediately hide the pawn
TurnOff();
SetActorHiddenInGame(true);
SetLifeSpan(1.0f);
}
else
{
SetLifeSpan(10.0f);
}
}
void AMech_RPGCharacter::Resurrect()
{
FindSpawnpoint();
SetDead(false);
SetActorHiddenInGame(false);
SetActorEnableCollision(true);
FHealthChange change;
change.heals = true;
change.healthChange = GetMaxHealth();
change.manipulator = this;
change.target = this;
ChangeHealth(change);
ApplyCrowdControl(EffectEnums::Damage, false);
GetWorld()->GetTimerManager().SetTimer(TimerHandle_Invunrelbility, this, &AMech_RPGCharacter::ResetInvunrelbility, 3.0F);
}
void APawn::OutsideWorldBounds()
{
if ( !bProcessingOutsideWorldBounds )
{
bProcessingOutsideWorldBounds = true;
// AI pawns on the server just destroy
if (Role == ROLE_Authority && Cast<APlayerController>(Controller) == NULL)
{
Destroy();
}
else
{
DetachFromControllerPendingDestroy();
TurnOff();
SetActorHiddenInGame(true);
SetLifeSpan( FMath::Clamp(InitialLifeSpan, 0.1f, 1.0f) );
}
bProcessingOutsideWorldBounds = false;
}
}
