void ASpawnEnemy::SpawnRandomEnemy()
{
TArray<FString> Parsed;
TArray<FString> HowMuch;
TArray<FString> TypeEnemy;
const TCHAR* Delims[] = { TEXT(":"), TEXT(";") };
float RandomNumber = (float)rand() / (float)RAND_MAX;
int SetNumber = RandomNumber * (Enemies.Num());
Enemies[SetNumber].ParseIntoArray(&Parsed, Delims, 2);
int SizeOfArrayParsed = Parsed.Num() - 1;
for (int x = 0; x <= SizeOfArrayParsed; x = x + 2) {
HowMuch.Add(Parsed[x]);
}
for (int x = 1; x <= SizeOfArrayParsed; x = x + 2) {
TypeEnemy.Add(Parsed[x]);
}
for (auto Itr(HowMuch.CreateIterator()); Itr; Itr++) {
APawn* NewPawn = NULL;
FVector BoxOnWorld = GetActorLocation();
FRotator RotatorBoxOnWorld = GetActorRotation();
FBox BoxInfo = GetComponentsBoundingBox();
FVector BoxSize = BoxInfo.GetSize();
if (TypeEnemy[Itr.GetIndex()] == "PegEnemyLight")
{
EnemyClass = PegLightEnemyClass;
}
else if (TypeEnemy[Itr.GetIndex()] == "PegDarkEnemy") {
EnemyClass = PegDarkEnemyClass;
}
else if (TypeEnemy[Itr.GetIndex()] == "GarbageEnemy") {
EnemyClass = GarbageEnemyClass;
}
else if (TypeEnemy[Itr.GetIndex()] == "MeleeBookEnemy") {
EnemyClass = MeleeBookEnemyClass;
}
else if (TypeEnemy[Itr.GetIndex()] == "RangeBookEnemy") {
EnemyClass = RangeBookEnemyClass;
}
else if (TypeEnemy[Itr.GetIndex()] == "PianoChargeEnemy") {
EnemyClass = PianoEnemyClass;
}
else if (TypeEnemy[Itr.GetIndex()] == "BarrelChargeEnemy") {
EnemyClass = BarrelEnemyClass;
}
else if (TypeEnemy[Itr.GetIndex()] == "FridgeChargeEnemy") {
EnemyClass = FridgeEnemyClass;
}
if (GetWorld())
{
int32 MyShinyNewInt = FCString::Atoi(*HowMuch[Itr.GetIndex()]);
for (int x = 1; x <= MyShinyNewInt; x++) {
float random = (float)rand() / (float)RAND_MAX;
float randomy = (float)rand() / (float)RAND_MAX;
int xValue = 1 + random * ((3) - (1));
int yValue = 1 + randomy * ((3) - (1));
float z, y;
if (xValue == 1)
z = random * (0 + (BoxSize[0] / 2));
else
z = random * (0 - (BoxSize[0] / 2));
if (yValue == 1)
y = random * (0 + (BoxSize[1] / 2));
else
y = random * (0 - (BoxSize[1] / 2));
BoxOnWorld[0] += z;
BoxOnWorld[1] += y;
if (ShouldSpawnEnemies)
{
if (BoxInfo.IsInside(BoxOnWorld))
{
NewPawn = GetWorld()->SpawnActor<AAI_BasicEnemy>(EnemyClass, BoxOnWorld, RotatorBoxOnWorld);
FVector BoxOnWorld = GetActorLocation();
if (NewPawn != NULL)
{
if (NewPawn->Controller == NULL)
{
NewPawn->SpawnDefaultController();
}
if (BehaviorTree != NULL)
{
AAIController* AIController = Cast<AAIController>(NewPawn->Controller);
if (AIController != NULL)
{
AIController->RunBehaviorTree(BehaviorTree);
}
}
}
//AI Direct laten aanvallen wanneer die spawnt!
AAI_BasicController* Controller = (AAI_BasicController*)NewPawn->GetController();
Controller->FoundPlayer();
Controller->AISetAttackState();
}
}
}
}
}
EnemyClass = NULL;
APawn* NewPawn = NULL;
}
AHierarchicalLODVolume* FHierarchicalLODUtilities::CreateVolumeForLODActor(ALODActor* InLODActor, UWorld* InWorld)
{
FBox BoundingBox = InLODActor->GetComponentsBoundingBox(true);
AHierarchicalLODVolume* Volume = InWorld->SpawnActor<AHierarchicalLODVolume>(AHierarchicalLODVolume::StaticClass(), FTransform(BoundingBox.GetCenter()));
// this code builds a brush for the new actor
Volume->PreEditChange(NULL);
Volume->PolyFlags = 0;
Volume->Brush = NewObject<UModel>(Volume, NAME_None, RF_Transactional);
Volume->Brush->Initialize(nullptr, true);
Volume->Brush->Polys = NewObject<UPolys>(Volume->Brush, NAME_None, RF_Transactional);
Volume->GetBrushComponent()->Brush = Volume->Brush;
Volume->BrushBuilder = NewObject<UCubeBuilder>(Volume, NAME_None, RF_Transactional);
UCubeBuilder* CubeBuilder = static_cast<UCubeBuilder*>(Volume->BrushBuilder);
CubeBuilder->X = BoundingBox.GetSize().X * 1.5f;
CubeBuilder->Y = BoundingBox.GetSize().Y * 1.5f;
CubeBuilder->Z = BoundingBox.GetSize().Z * 1.5f;
Volume->BrushBuilder->Build(InWorld, Volume);
FBSPOps::csgPrepMovingBrush(Volume);
// Set the texture on all polys to NULL. This stops invisible textures
// dependencies from being formed on volumes.
if (Volume->Brush)
{
for (int32 poly = 0; poly < Volume->Brush->Polys->Element.Num(); ++poly)
{
FPoly* Poly = &(Volume->Brush->Polys->Element[poly]);
Poly->Material = NULL;
}
}
Volume->PostEditChange();
return Volume;
}
void FLevelCollectionModel::UpdateAllLevels()
{
bRequestedUpdateAllLevels = false;
for (auto It = AllLevelsList.CreateConstIterator(); It; ++It)
{
(*It)->Update();
}
// Update world size
FBox WorldBounds = GetLevelsBoundingBox(AllLevelsList, false);
WorldSize.X = FMath::RoundToInt(WorldBounds.GetSize().X);
WorldSize.Y = FMath::RoundToInt(WorldBounds.GetSize().Y);
}
void FNavigationOctree::AddActor(class AActor* Actor, FNavigationOctreeElement& Data)
{
if (Actor == NULL || Actor->IsPendingKill())
{
return;
}
INavRelevantActorInterface* NavRelevantActor = InterfaceCast<INavRelevantActorInterface>(Actor);
UNavigationProxy* ProxyOb = NavRelevantActor ? NavRelevantActor->GetNavigationProxy() : NULL;
UObject* NodeOwner = ProxyOb ? (UObject*)ProxyOb : Actor;
Data.Owner = NodeOwner;
const FBox BBox = Actor->GetComponentsBoundingBox();
if (BBox.IsValid && !BBox.GetSize().IsNearlyZero())
{
Data.Bounds = BBox;
#if NAVOCTREE_CONTAINS_COLLISION_DATA
bool bExportGeometry = true;
{
SCOPE_CYCLE_COUNTER(STAT_Navigation_GatheringNavigationModifiersSync);
if (NavRelevantActor)
{
bExportGeometry = NavRelevantActor->GetNavigationRelevantData(Data.Data);
}
TArray<UNavRelevantComponent*> Components;
Actor->GetComponents(Components);
for (int32 i = 0; i < Components.Num(); i++)
{
UNavRelevantComponent* NavRelevantComponent = Components[i];
if (NavRelevantComponent && NavRelevantComponent->IsNavigationRelevant())
{
NavRelevantComponent->OnApplyModifiers(Data.Data.Modifiers);
}
}
}
if (bExportGeometry)
{
SCOPE_CYCLE_COUNTER(STAT_Navigation_ActorsGeometryExportSync);
NavigableGeometryExportDelegate.ExecuteIfBound(*Actor, Data.Data);
}
#endif // NAVOCTREE_CONTAINS_COLLISION_DATA
AddNode(Data);
}
}
void ALevelBounds::UpdateLevelBounds()
{
FBox LevelBounds = CalculateLevelBounds(GetLevel());
if (LevelBounds.IsValid)
{
FVector LevelCenter = LevelBounds.GetCenter();
FVector LevelSize = LevelBounds.GetSize();
SetActorTransform(FTransform(FQuat::Identity, LevelCenter, LevelSize));
bUsingDefaultBounds = false;
}
else
{
SetActorTransform(FTransform(FQuat::Identity, FVector::ZeroVector, DefaultLevelSize));
bUsingDefaultBounds = true;
}
BroadcastLevelBoundsUpdated();
}
inline FString convert(FBox& x)
{
return x.GetSize().ToString();
}