void ACharacterTargetSystem::cleanUpTargets(UWorld* currentGameWorld)
{
	// clean up all previous focused enemies
	for (TObjectIterator<ABasicEnemy> enemyFocusIterator; enemyFocusIterator; ++enemyFocusIterator)
	{
		if (enemyFocusIterator->GetWorld() == currentGameWorld)
		{
			ABasicEnemy* enemyChar = *enemyFocusIterator;
			if (!enemyChar->IsPendingKill())
			{
				enemyChar->hideFocusComponent();
				enemyChar->removeFocus();
				enemyChar->disableMenu();
			}
		}
	}

	// clean up all previous focused enemies
	for (TObjectIterator<ABasicNpc> npcFocusIterator; npcFocusIterator; ++npcFocusIterator)
	{
		if (npcFocusIterator->GetWorld() == currentGameWorld)
		{
			ABasicNpc* npcChar = *npcFocusIterator;
			npcChar->hideFocusComponent();
			npcChar->removeFocus();
		}
	}

}

// check only for enemies which are free to target in the given range
bool ACharacterTargetSystem::checkFreeTargetEnemies(ACharacter* player, UWorld* currentGameWorld, float distance)
{
	ABasicEnemy* enemyChar;
	bool enemyFreeForTarget = false;
	float distanceToTarget = distance;
	// TODO
	for (TObjectIterator<ABasicEnemy> enemyIterator; enemyIterator; ++enemyIterator)
	{
		if (enemyIterator->GetWorld() == currentGameWorld)
		{
			enemyChar = *enemyIterator;
			float distanceToPlayer = enemyChar->GetDistanceTo(player);
			if (!enemyChar->IsPendingKill() && distanceToPlayer < distanceToTarget)
			{
				bool isEnemySkipped = enemyChar->bSkippedTarget;
				if (!isEnemySkipped)
				{
					enemyFreeForTarget = true;
				}
			}

		}
	}
	return enemyFreeForTarget;
}

bool UInputBlueprintLibrary::K2_RebindAxisKey(FValorAxisInputBinding OriginalBinding, FValorAxisInputBinding NewBinding)
{
	UInputSettings* Settings = const_cast<UInputSettings*>(GetDefault<UInputSettings>());
	if (!Settings)
	{
		return false;
	}

	TArray<FInputAxisKeyMapping>& AxisMappings = Settings->AxisMappings;

	bool bFound = false;
	for (FInputAxisKeyMapping& AxisKeyMapping : AxisMappings)
	{
		if (AxisKeyMapping.AxisName.ToString() == OriginalBinding.AxisName && AxisKeyMapping.Key == OriginalBinding.Key)
		{
			UpdateAxisMapping(AxisKeyMapping, NewBinding);
			bFound = true;
			break;
		}
	}

	if (bFound)
	{
		const_cast<UInputSettings*>(Settings)->SaveKeyMappings();

		for (TObjectIterator<UPlayerInput> It; It; ++It)
		{
			It->ForceRebuildingKeyMaps(true);
		}
	}
	return bFound;
}

void UInputBlueprintLibrary::K2_RemoveAxisKeyBinding(FValorAxisInputBinding BindingToRemove)
{
	UInputSettings* Settings = GetMutableDefault<UInputSettings>();
	if (!Settings)
	{
		return;
	}

	TArray<FInputAxisKeyMapping>& AxisMappings = Settings->AxisMappings;

	bool bFound = false;
	for (int32 Index = 0; Index < AxisMappings.Num(); ++Index)
	{
		if (AxisMappings[Index].Key == BindingToRemove.Key)
		{
			bFound = true;
			AxisMappings.RemoveAt(Index);
			Index = 0;
		}
	}

	if (bFound)
	{
		Settings->SaveKeyMappings();

		for (TObjectIterator<UPlayerInput> It; It; ++It)
		{
			It->ForceRebuildingKeyMaps(true);
		}
	}
}

FGlobalComponentReregisterContext::FGlobalComponentReregisterContext(const TArray<UClass*>& ExcludeComponents)
{
	ActiveGlobalReregisterContextCount++;

	// wait until resources are released
	FlushRenderingCommands();

	// Detach only actor components that are not in the excluded list
	for(TObjectIterator<UActorComponent> ComponentIt;ComponentIt;++ComponentIt)
	{
		bool bShouldReregister=true;
		for( int32 Idx=0; Idx < ExcludeComponents.Num(); Idx++ )
		{
			UClass* ExcludeClass = ExcludeComponents[Idx];
			if( ExcludeClass &&
				ComponentIt->IsA(ExcludeClass) )
			{
				bShouldReregister = false;
				break;
			}
		}
		if( bShouldReregister )
		{
			new(ComponentContexts) FComponentReregisterContext(*ComponentIt);		
		}
	}
}

void UAkGameplayStatics::LoadBankByName(const FString& BankName)
{
	
	FAkAudioDevice * AudioDevice = FAkAudioDevice::Get();
	if( AudioDevice )
	{
		if(AudioDevice->GetAkBankManager() != NULL )
		{
			for ( TObjectIterator<UAkAudioBank> Iter; Iter; ++Iter )
			{
				if( Iter->GetName() == BankName )
				{
					Iter->Load();
					return;
				}
			}

			// Bank not found in the assets, load it by name anyway
			AkUInt32 bankID;
			AudioDevice->LoadBank(BankName, AK_DEFAULT_POOL_ID, bankID);
		}
		else
		{
			AkUInt32 bankID;
			AudioDevice->LoadBank(BankName, AK_DEFAULT_POOL_ID, bankID);
		}
	}
}

void UAkGameplayStatics::UnloadBankByName(const FString& BankName)
{
	FAkAudioDevice * AudioDevice = FAkAudioDevice::Get();
	if( AudioDevice )
	{
		if(AudioDevice->GetAkBankManager() != NULL )
		{
			for ( TObjectIterator<UAkAudioBank> Iter; Iter; ++Iter )
			{
				if( Iter->GetName() == BankName )
				{
					Iter->Unload();
					return;
				}
			}

			
			// Bank not found in the assets, unload it by name anyway
			AudioDevice->UnloadBank(BankName);
		}
		else
		{
			AudioDevice->UnloadBank(BankName);
		}
	}
}

void UBillboardComponent::SetEditorScale(float InEditorScale)
{
	EditorScale = InEditorScale;
	for(TObjectIterator<UBillboardComponent> It; It; ++It)
	{
		It->MarkRenderStateDirty();
	}
}

void UMaterialInterface::RecacheAllMaterialUniformExpressions()
{
	// For each interface, reacache its uniform parameters
	for( TObjectIterator<UMaterialInterface> MaterialIt; MaterialIt; ++MaterialIt )
	{
		MaterialIt->RecacheUniformExpressions();
	}
}

	void OnObjectReimported(UObject* InObject)
	{
		if (UTexture2D* Texture = Cast<UTexture2D>(InObject))
		{
			for (TObjectIterator<UPaperSprite> SpriteIt; SpriteIt; ++SpriteIt)
			{
				SpriteIt->OnObjectReimported(Texture);
			}
		}
	}

void UColorPadActivator::DeactivateAllColorPads()
{
	for (TObjectIterator<UColorPadActivator> Itr; Itr; ++Itr)
	{
		UColorPadActivator *Trigger = *Itr;
		Itr->IsActive = false;
		if (Itr->GetOwner())
		{
			UE_LOG(LogTemp, Warning, TEXT("%s deactivated"), *Itr->GetOwner()->GetName());
		}
	}
	return;
}

void AFPSCharacter::GetMyHealth()
{
	if (GEngine)
	{
		TObjectIterator< APlayerController > ThePC;
		UWorld* TheWorld = ThePC->GetWorld();
		AFPSGM* MyGM = Cast<AFPSGM>(UGameplayStatics::GetGameMode(TheWorld));
		if (MyGM != NULL)
		{
			GEngine->AddOnScreenDebugMessage(1, 5.f, FColor::Red, FString::FromInt(MyGM->Health));
		}
	}
}

void NUTUtil::GetUnitTestClassDefList(TArray<UUnitTest*>& OutUnitTestClassDefaults)
{
	for (TObjectIterator<UClass> It; It; ++It)
	{
		if (It->IsChildOf(UUnitTest::StaticClass()) && *It != UUnitTest::StaticClass() && *It != UClientUnitTest::StaticClass())
		{
			UUnitTest* CurDefault = Cast<UUnitTest>(It->GetDefaultObject());

			if (CurDefault != NULL)
			{
				OutUnitTestClassDefaults.Add(CurDefault);
			}
		}
	}
}

void AssembleListOfExporters(TArray<UExporter*>& OutExporters)
{
	auto TransientPackage = GetTransientPackage();

	// @todo DB: Assemble this set once.
	OutExporters.Empty();
	for (TObjectIterator<UClass> It; It; ++It)
	{
		if (It->IsChildOf(UExporter::StaticClass()) && !It->HasAnyClassFlags(CLASS_Abstract))
		{
			UExporter* Exporter = NewObject<UExporter>(TransientPackage, *It);
			OutExporters.Add(Exporter);
		}
	}
}

void ACharacterTargetSystem::makeAllNpcsFocusable(UWorld* currentGameWorld)
{
	ABasicNpc* npcChar;
	for (TObjectIterator<ABasicNpc> npcFreeIterator; npcFreeIterator; ++npcFreeIterator)
	{
		if (npcFreeIterator->GetWorld() == currentGameWorld)
		{
			npcChar = *npcFreeIterator;
			if (npcChar)
			{
				npcChar->bSkippedTarget = false;
			}
		}
	}
}

void ACharacterTargetSystem::makeAllEnemiesFocusable(UWorld* currentGameWorld)
{
	ABasicEnemy* enemyChar;
	for (TObjectIterator<ABasicEnemy> enemyFreeIterator; enemyFreeIterator; ++enemyFreeIterator)
	{
		if (enemyFreeIterator->GetWorld() == currentGameWorld)
		{
			enemyChar = *enemyFreeIterator;
			if (enemyChar && !enemyChar->IsPendingKill())
			{
				enemyChar->bSkippedTarget = false;
			}
		}
	}

}

bool ASkill::SphereTrace(AActor* actorToIgnore, const FVector& start, const FVector& end, const float radius, TArray<FHitResult>& hitOut, ECollisionChannel traceChannel /* = ECC_Pawn */)
{
    FCollisionQueryParams traceParams(FName(TEXT("Sphere Trace")), true, actorToIgnore);
    traceParams.bTraceComplex = true;
    traceParams.bReturnPhysicalMaterial = false;

    traceParams.AddIgnoredActor(actorToIgnore);

    TObjectIterator<APlayerController> pc;
    if (!pc)
        return false;

    DrawDebugSphere(pc->GetWorld(), start, radius, 8, FColor::Red, true);

    return pc->GetWorld()->SweepMultiByChannel(hitOut, start, end, FQuat(), traceChannel, FCollisionShape::MakeSphere(radius), traceParams);
}

void USoundCue::PostEditChangeProperty(struct FPropertyChangedEvent& PropertyChangedEvent)
{
	Super::PostEditChangeProperty(PropertyChangedEvent);

	if (PropertyChangedEvent.Property)
	{
		for (TObjectIterator<UAudioComponent> It; It; ++It)
		{
			if (It->Sound == this && It->bIsActive)
			{
				It->Stop();
				It->Play();
			}
		}
	}
}

void ACharacterTargetSystem::findNPCTargetByDistance(ACharacter* player, UWorld* currentGameWorld, float distance)
{
	ABasicNpc* npcChar;
	float distanceToPlayer;
	float distanceToTarget = distance;
	bool npcFreeForTarget = checkFreeTargetNpcs(currentGameWorld);



	// if every enemy has been skipped, set all to be focusable again
	if (!npcFreeForTarget)
	{
		makeAllNpcsFocusable(currentGameWorld);
	}

	// get distance to enemy that can be focused
	for (TObjectIterator<ABasicNpc> npcFocusIterator; npcFocusIterator; ++npcFocusIterator)
	{
		if (npcFocusIterator->GetWorld() == currentGameWorld)
		{
			npcChar = *npcFocusIterator;
			if (npcChar && player && npcChar->bSkippedTarget == false)
			{
				distanceToPlayer = npcChar->GetDistanceTo(player);
				if (distanceToPlayer < distanceToTarget)
				{
					npcChar->bSkippedTarget = true;
					npcChar->setFocus();
					targetedNpc = npcChar;
					break;
				}
				else
				{
					npcChar->removeFocus();
					targetedNpc = nullptr;
				}
			}
			else
			{
				npcChar->removeFocus();
				targetedNpc = nullptr;
			}
		}

	}
}

void ULevelStreaming::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent)
{
	UProperty* OutermostProperty = PropertyChangedEvent.Property;
	if ( OutermostProperty != NULL )
	{
		const FName PropertyName = OutermostProperty->GetFName();
		if (PropertyName == GET_MEMBER_NAME_CHECKED(ULevelStreaming, LevelTransform))
		{
			GetWorld()->UpdateLevelStreaming();
		}

		if (PropertyName == GET_MEMBER_NAME_CHECKED(ULevelStreaming, EditorStreamingVolumes))
		{
			RemoveStreamingVolumeDuplicates();

			// Update levels references in each streaming volume 
			for (TActorIterator<ALevelStreamingVolume> It(GetWorld()); It; ++It)
			{
				(*It)->UpdateStreamingLevelsRefs();
			}
		}

		else if (PropertyName == GET_MEMBER_NAME_CHECKED(ULevelStreaming, LevelColor))
		{
			// Make sure the level's Level Color change is applied immediately by reregistering the
			// components of the actor's in the level
			if( LoadedLevel != NULL )
			{
				UPackage* Package = LoadedLevel->GetOutermost();
				for( TObjectIterator<UActorComponent> It; It; ++It )
				{
					if( It->IsIn( Package ) )
					{
						UActorComponent* ActorComponent = Cast<UActorComponent>( *It );
						if( ActorComponent )
						{
							ActorComponent->RecreateRenderState_Concurrent();
						}
					}
				}
			}
		}
	}

	Super::PostEditChangeProperty(PropertyChangedEvent);
}