void AFlarePlanetarium::BeginPlay()
{
Super::BeginPlay();
FLOG("AFlarePlanetarium::BeginPlay");
TArray<UActorComponent*> Components = GetComponentsByClass(UStaticMeshComponent::StaticClass());
for (int32 ComponentIndex = 0; ComponentIndex < Components.Num(); ComponentIndex++)
{
UStaticMeshComponent* PlanetCandidate = Cast<UStaticMeshComponent>(Components[ComponentIndex]);
if (PlanetCandidate)
{
// Apply a new dynamic material to planets so that we can control shading parameters
UMaterialInstanceConstant* BasePlanetMaterial = Cast<UMaterialInstanceConstant>(PlanetCandidate->GetMaterial(0));
if (BasePlanetMaterial)
{
//FLOGV("AFlarePlanetarium::BeginPlay : found planet '%s'", *PlanetCandidate->GetName());
#if PLATFORM_LINUX
int32 UseNormalAsLightingDirection = 1;
#else
int32 UseNormalAsLightingDirection = 0;
#endif
UMaterialInstanceDynamic* PlanetMaterial = UMaterialInstanceDynamic::Create(BasePlanetMaterial, GetWorld());
PlanetCandidate->SetMaterial(0, PlanetMaterial);
PlanetMaterial->SetScalarParameterValue("UseNormalAsLightingDirection", UseNormalAsLightingDirection);
}
}
}
}
void APlayerCharacter::TertiaryRelease() {
UInventoryComponent* inv = Cast<UInventoryComponent>(GetComponentsByClass(UInventoryComponent::StaticClass())[0]);
if(selectedQuickSlot == Primary) if(inv->PrimarySlot) inv->PrimarySlot->TertiaryRelease(this);
if(selectedQuickSlot == Secondary) if(inv->SecondarySlot) inv->SecondarySlot->TertiaryRelease(this);
if(selectedQuickSlot == Tertiary) if(inv->TertiarySlot) inv->TertiarySlot->TertiaryRelease(this);
}
void AInteractableChar::BeginPlay(){
Super::BeginPlay();
for( UActorComponent* MeshComp : GetComponentsByClass(UMeshComponent::StaticClass()) ){
UMeshComponent* thisMesh = Cast<UMeshComponent>(MeshComp);
Meshes.Push(thisMesh);
}
}
void APlayerCharacter::Select() {
UInventoryComponent* inv = Cast<UInventoryComponent>(GetComponentsByClass(UInventoryComponent::StaticClass())[0]);
bool swapped = false;
if(isInventoryOpen() || isClothingInventoryOpen()) {
if(!(SelectedItem <= -11) && !(HoveredIndex <= -11)) {
inv->SwapIndexes(SelectedItem, HoveredIndex);
swapped = true;
}
}
if (SelectedItem == -11) SelectedItem = HoveredIndex;
if (swapped) SelectedItem = -11;
}
// Called when the game starts or when spawned
void ATestTL::BeginPlay()
{
Super::BeginPlay();
if (TLComp && MoveInterpCurve)
{
UE_LOG(TestTL, Log, TEXT("Begin Play ********%d*****%ls***"),
GetComponentsByClass(UTimelineComponent::StaticClass()).Num(),
MoveInterpDelegate.IsBound()?TEXT("True"):TEXT("False"));
TLComp->Activate(true);
//TLComp->AddInterpFloat
TLComp->AddInterpFloat(MoveInterpCurve, MoveInterpDelegate, FName("MoveInterp"));
TLComp->PlayFromStart();
}
}
void AFlarePlanetarium::PrepareCelestialBody(FFlareCelestialBody* Body, FPreciseVector Offset, double AngleOffset)
{
CelestialBodyPosition BodyPosition;
BodyPosition.Body = Body;
FPreciseVector Location = Offset + Body->AbsoluteLocation;
BodyPosition.AlignedLocation = Location.RotateAngleAxis(AngleOffset, FPreciseVector(0,1,0));
BodyPosition.Radius = Body->Radius;
BodyPosition.Distance = BodyPosition.AlignedLocation.Size();
BodyPosition.TotalRotation = Body->RotationAngle + AngleOffset;
// Find the celestial body component
UStaticMeshComponent* BodyComponent = NULL;
TArray<UActorComponent*> Components = GetComponentsByClass(UStaticMeshComponent::StaticClass());
for (int32 ComponentIndex = 0; ComponentIndex < Components.Num(); ComponentIndex++)
{
UStaticMeshComponent* ComponentCandidate = Cast<UStaticMeshComponent>(Components[ComponentIndex]);
if (ComponentCandidate && ComponentCandidate->GetName() == Body->Identifier.ToString() )
{
BodyComponent = ComponentCandidate;
break;
}
}
if (BodyComponent)
{
BodyPosition.BodyComponent = BodyComponent;
BodyPositions.Add(BodyPosition);
}
else
{
FLOGV("AFlarePlanetarium::PrepareCelestialBody : no planetarium component for celestial body '%s'", *(Body->Identifier.ToString()));
}
if (Body == &Sun)
{
SunOcclusionAngle = FPreciseMath::Asin(BodyPosition.Radius / BodyPosition.Distance);
SunPhase = FMath::UnwindRadians(FMath::Atan2(BodyPosition.AlignedLocation.Z, BodyPosition.AlignedLocation.X));
}
for (int SatteliteIndex = 0; SatteliteIndex < Body->Sattelites.Num(); SatteliteIndex++)
{
FFlareCelestialBody* CelestialBody = &Body->Sattelites[SatteliteIndex];
PrepareCelestialBody(CelestialBody, Offset, AngleOffset);
}
}
void ALD35Character::Tick(float deltaTime)
{
Super::Tick(deltaTime);
if (Health <= 0) return;
ShotCooldown -= deltaTime;
HealthRegenStoppedFor -= deltaTime;
if (IsFiring && ShotCooldown <= 0)
{
ShotCooldown = IsInAlternateForm ? 0.5f : 1.5f;
OnFire();
}
if (IsInAlternateForm)
{
Energy = FMath::Clamp(Energy - deltaTime / MaxTransformTime, 0.f, 1.f);
if (Energy <= 0)
{
Transform();
}
if (HealthRegenStoppedFor <= 0) Health = FMath::Clamp(Health + deltaTime, 0.f, 4.f);
}
for (auto& a : GetComponentsByTag(UPrimitiveComponent::StaticClass(), TEXT("Human")))
{
Cast<UPrimitiveComponent>(a)->SetVisibility(!IsInAlternateForm);
}
for (auto& a : GetComponentsByTag(UPrimitiveComponent::StaticClass(), TEXT("Claw")))
{
Cast<UPrimitiveComponent>(a)->SetVisibility(IsInAlternateForm);
}
for (auto& a : GetComponentsByClass(UPointLightComponent::StaticClass()))
{
Cast<UPointLightComponent>(a)->SetVisibility(!IsSomeoneTransformed);
}
}
void APlayerCharacter::UpdateSpeed() const {
float maxSpeed = baseMovementSpeed;
if(isScoping()) {
maxSpeed *= scopingSpeedModifier;
} if(isSprinting()) {
maxSpeed *= sprintingSpeedModifier;
} if(isInventoryOpen() || isClothingInventoryOpen()) {
maxSpeed *= inventoryOpenSpeedModifier;
}
UInventoryComponent* inv = Cast<UInventoryComponent>(GetComponentsByClass(UInventoryComponent::StaticClass())[0]);
if(inv->GetWeight() >0) {
//maxSpeed *= 1 / (inv->GetWeight() * 0.01); // NEED FORMULA
}
GetCharacterMovement()->MaxWalkSpeed = maxSpeed;
GetCharacterMovement()->MaxWalkSpeedCrouched = 0.5 * maxSpeed;
GetTransform().GetLocation();
}
/******************** StoreResource *************************/
bool APOTLStructure::StoreResource(UResource* Resource)
{
if (Resource)
{
TArray<UActorComponent*> StorageComponents = GetComponentsByClass(UStorageComponent::StaticClass());
for (auto& Component : StorageComponents)
{
UStorageComponent* StorageComponent = Cast<UStorageComponent>(Component);
if (StorageComponent)
{
if (StorageComponent->StoreResource(Resource))
{
return true;
}
}
}
}
if (AttachedTo)
{
return AttachedTo->StoreResource(Resource);
}
return false;
}
void APlayerCharacter::QuaternaryClothingRelease() {
UInventoryComponent* inv = Cast<UInventoryComponent>(GetComponentsByClass(UInventoryComponent::StaticClass())[0]);
if(inv->Bag) inv->Bag->QuaternaryClothingRelease(this);
}
void APlayerCharacter::Drop() {
UInventoryComponent* inv = Cast<UInventoryComponent>(GetComponentsByClass(UInventoryComponent::StaticClass())[0]);
}
/******************** AddResource *************************/
int APOTLStructure::AddResource(FString ResourceId, int32 Quantity)
{
int Leftovers = Quantity;
// Check Attachments for storage with AddResource
if (AttachedTo)
{
Leftovers = AttachedTo->AddResource(ResourceId, Quantity);
}
else {
// distribute to self and attachments?
for (auto& Attachment : AttachedStructures)
{
if (IsValid(Attachment))
{
}
}
}
// Check for storage component in self
if (Leftovers > 0)
{
TArray<UActorComponent*> StorageComponents = GetComponentsByClass(UStorageComponent::StaticClass());
for (auto& Component : StorageComponents)
{
UStorageComponent* StorageComponent = Cast<UStorageComponent>(Component);
if (StorageComponent)
{
Leftovers = StorageComponent->AddResource(ResourceId, Leftovers);
if (Leftovers > 0)
{
}
else
{
//Added = true;
break;
}
}
}
}
/*
switch (Type)
{
case EResourceList::Free:
if (FreeResources.Contains(Id))
{
if (FreeResources[Id] + Quantity < 0)
{
}
else
{
FreeResources[Id] += Quantity;
}
Added = true;
}
else
{
FreeResources.Add(Id, Quantity);
Added = true;
}
break;
case EResourceList::Upkeep:
if (ResourceUpkeep.Contains(Id))
{
if (ResourceUpkeep[Id] + Quantity < 0)
{
}
else
{
ResourceUpkeep[Id] += Quantity;
}
Added = true;
}
else
{
ResourceUpkeep.Add(Id, Quantity);
Added = true;
}
break;
default:
break;
}
*/
return Leftovers;
}
void AFlarePlanetarium::Tick(float DeltaSeconds)
{
Super::Tick(DeltaSeconds);
SmoothTime += DeltaSeconds * TimeMultiplier;
if (GetGame())
{
if (!GetGame()->GetActiveSector())
{
// No active sector, do nothing
Ready = false;
return;
}
bool LightWasAdjusted = false;
UFlareWorld* World = GetGame()->GetGameWorld();
if (World)
{
float LocalTime = GetGame()->GetActiveSector()->GetLocalTime();
CurrentSector = GetGame()->GetActiveSector()->GetSimulatedSector()->GetIdentifier();
if (CurrentSector != PreviousSector)
{
LightWasAdjusted = true;
PreviousSector = CurrentSector;
}
if (Sky == NULL)
{
for (TActorIterator<AActor> ActorItr(GetWorld()); ActorItr; ++ActorItr)
{
if ((*ActorItr)->GetName().StartsWith("Skybox"))
{
FLOG("AFlarePlanetarium::Tick : found the sky");
Sky = *ActorItr;
break;
}
}
}
if (Light == NULL)
{
TArray<UActorComponent*> Components = GetComponentsByClass(UDirectionalLightComponent::StaticClass());
for (int32 ComponentIndex = 0; ComponentIndex < Components.Num(); ComponentIndex++)
{
UDirectionalLightComponent* LightCandidate = Cast<UDirectionalLightComponent>(Components[ComponentIndex]);
if (LightCandidate)
{
Light = LightCandidate;
break;
}
}
}
Ready = true;
do
{
Sun = World->GetPlanerarium()->GetSnapShot(LocalTime, SmoothTime);
// Draw Player
const FFlareSectorOrbitParameters* PlayerOrbit = GetGame()->GetActiveSector()->GetSimulatedSector()->GetOrbitParameters();
FFlareCelestialBody* CurrentParent = World->GetPlanerarium()->FindCelestialBody(PlayerOrbit->CelestialBodyIdentifier);
if (CurrentParent)
{
FPreciseVector ParentLocation = CurrentParent->AbsoluteLocation;
double DistanceToParentCenter = CurrentParent->Radius + PlayerOrbit->Altitude;
FPreciseVector PlayerLocation = ParentLocation + World->GetPlanerarium()->GetRelativeLocation(CurrentParent, LocalTime, SmoothTime, DistanceToParentCenter, 0, PlayerOrbit->Phase);
/*FLOGV("Parent location = %s", *CurrentParent->AbsoluteLocation.ToString());
FLOGV("PlayerLocation = %s", *PlayerLocation.ToString());*/
#ifdef PLANETARIUM_DEBUG
DrawDebugLine(GetWorld(), FVector(1000, 0 ,0), FVector(- 1000, 0 ,0), FColor::Red, false);
DrawDebugLine(GetWorld(), FVector(0, 1000 ,0), FVector(0,- 1000 ,0), FColor::Green, false);
DrawDebugLine(GetWorld(), FVector(0, 0, 900), FVector(0, 0, -1000), FColor::Blue, false);
DrawDebugLine(GetWorld(), FVector(0, 0, 900), FVector(0, 0, 1000), FColor::Cyan, false);
#endif
FPreciseVector DeltaLocation = ParentLocation - PlayerLocation;
FPreciseVector SunDeltaLocation = Sun.AbsoluteLocation - PlayerLocation;
float AngleOffset = 90 + FMath::RadiansToDegrees(FMath::Atan2(DeltaLocation.Z,DeltaLocation.X));
/*FLOGV("DeltaLocation = %s", *DeltaLocation.ToString());
FLOGV("FMath::Atan2(DeltaLocation.Y,DeltaLocation.X) = %f", FMath::Atan2(DeltaLocation.Z,DeltaLocation.X));
FLOGV("AngleOffset = %f", AngleOffset);*/
SunDirection = -(SunDeltaLocation.RotateAngleAxis(AngleOffset, FPreciseVector(0,1,0))).GetUnsafeNormal();
// Reset sun occlusion;
SunOcclusion = 0;
MinDistance = DistanceToParentCenter;
BodyPositions.Empty();
PrepareCelestialBody(&Sun, -PlayerLocation, AngleOffset);
SetupCelestialBodies();
// Try to find night
if (SkipNightTimeRange > 0 && SunOcclusion >= 1)
{
SmoothTime = FMath::FRand() * SkipNightTimeRange;
//FLOGV("AFlarePlanetarium::Tick : night, try to find light at %f (max %f)",SmoothTime, SkipNightTimeRange);
}
else
{
SkipNightTimeRange = 0;
}
if (Sky)
{
Sky->SetActorRotation(FRotator(-AngleOffset, 0 , 0));
//FLOGV("Sky %s rotation= %s",*Sky->GetName(), *Sky->GetActorRotation().ToString());
}
else
{
FLOG("AFlarePlanetarium::Tick : no sky found");
}
//FLOGV("SunOcclusion %f", SunOcclusion);
if (Light)
{
float CurrentIntensity = Light->Intensity;
float Intensity = 5 * FMath::Pow((1.0 - SunOcclusion), 2);
if (FMath::Abs(Intensity - CurrentIntensity) > 0.1f)
{
LightWasAdjusted = true;
FLOG("AFlarePlanetarium::Tick : lighting was adjusted");
}
Light->SetIntensity(Intensity);
}
else
{
FLOG("AFlarePlanetarium::Tick : no sunlight found");
}
}
else
{
FLOGV("AFlarePlanetarium::Tick : failed to find the current sector: '%s' in planetarium", *(PlayerOrbit->CelestialBodyIdentifier.ToString()));
}
} while(SkipNightTimeRange != 0);
// Recapture skylight
if (LightWasAdjusted)
{
FLOG("AFlarePlanetarium::Tick : recapturing skylight");
TArray<AActor*> SkylightCandidates;
UGameplayStatics::GetAllActorsOfClass(GetWorld(), ASkyLight::StaticClass(), SkylightCandidates);
if (SkylightCandidates.Num())
{
Cast<ASkyLight>(SkylightCandidates[0])->GetLightComponent()->RecaptureSky();
}
}
}
}
}