void ASpawnerTrigger::spawn(){
	if(whatToSpawn!=NULL){
		UWorld* world = GetWorld();
		if (world) {
			FActorSpawnParameters params;
			params.Owner = this;
			params.bNoCollisionFail = true;
			FVector loc = GetActorLocation()+offset;
			FRotator rotation = FRotator::ZeroRotator;
			rotation.Yaw = 90.f;
			AActor *a = world->SpawnActor<AActor>(whatToSpawn, loc, rotation, params);
			++nbSpawned;
			if( nbSpawned < numToSpawn){ 
				FTimerHandle timerHandler;
				GetWorldTimerManager().SetTimer(timerHandler, this, &ASpawnerTrigger::spawn, timeBetweenSpawn, false);
			}
		}
		if(bDestroyWhenFinished && nbSpawned >= numToSpawn){ Destroy(); }
	}
}

void AWeapon::FireFunction(){
	
	if (firedObject){
		UWorld* world = GetWorld();
		if (world){
			FActorSpawnParameters parameters = FActorSpawnParameters(); 
			parameters.bNoCollisionFail = true;
			parameters.Instigator = Owner;
			parameters.Name = GetProjectileName();
			FVector spawnLocation = GetActorLocation();
			FRotator spawnRotation = GetActorRotation();
			AActor* Spawned = world->SpawnActor(*firedObject, &spawnLocation, &spawnRotation,parameters);
			AFirable* firable = Cast<AFirable>(Spawned);
			firable->SetColor(ProjectileColor);
			firable->Instigator = Owner->GetController();
			firable->Damage = damage;
			firable->OwnerID = OwnerShipNumber;
		}
	}
}

TArray<RobotDataTypes::PlayerLocation>* ARobot::getVisiblePlayers()
{
	FVector ownLocation = GetActorLocation();
	FRotator ownRotation = GetActorRotation();
	TArray<RobotDataTypes::PlayerLocation>* visiblePlayerLocations = new TArray<RobotDataTypes::PlayerLocation>();

	//Iterate through all Robots	
	for (TActorIterator<ARobot> ActorItr(GetWorld()); ActorItr; ++ActorItr)
	{
		ARobot* robot = Cast<ARobot>(*ActorItr);
		if (this == robot) continue;
		
		if (isObjectVisible(robot->getPosition()))
		{
			visiblePlayerLocations->Add(RobotDataTypes::PlayerLocation{ robot->getTeamId(), robot->getPlayerId(), new FVector(robot->getPosition()) });
		}
	}

	return visiblePlayerLocations;
}

void APlayerOvi::AjustPosition() {
  FVector location = GetActorLocation();

  if (location.X > m_limit)
    location.X = m_limit;
  else if (location.X < -m_limit)
    location.X = -m_limit;

  if (location.Y > m_limit)
    location.Y = m_limit;
  else if (location.Y < -m_limit)
    location.Y = -m_limit;

  if (location.Z > m_limit)
    location.Z = m_limit;
  else if (location.Z < -m_limit)
    location.Z = -m_limit;

  SetActorLocation(location);
}

void AUTWeaponPawn::AttachDriver_Implementation(APawn* P)
{
	AUTCharacter* Char = Cast<AUTCharacter>(P);
	if (Char != NULL)
	{
		// UTP.SetWeaponAttachmentVisibility(false); // TODO: FIXME: Weapon attachement visibility // TODO: PR for SetWeaponAttachmentVisibility

		if (MyVehicle->bAttachDriver)
		{
			// UC: UTP.SetCollision(false, false);
			// UC: UTP.bCollideWorld = false;
			Char->SetActorEnableCollision(false);

			//UTP.SetHardAttach(true);  // TODO: FIXME: add hard attach
			Char->SetActorLocation(GetActorLocation());
			//UTP.SetPhysics(PHYS_None); // TODO: FIXME: Set Physics state

			MyVehicle->SitDriver(Char, MySeatIndex);
		}
	}
}

/** Update the modifier */
void AFluidSurfaceOscillator::Update( float DeltaTime )
{
	if( !FluidActor )
		return;

	OscTime += DeltaTime;

	// If frequency is zero - just set velocity to strength
	float Period, Amp, CurrPhase;

	if( Frequency > 0.0001f )
	{
		Period = 1.f / Frequency;
		CurrPhase = ( FMath::Fmod( OscTime, Period ) * Frequency ) + (float) Phase / 255.f;
		Amp = Strength * FMath::Sin( CurrPhase * PI * 2 );
	}
	else
		Amp = Strength;

	FluidActor->FluidSurfaceComponent->Pling( GetActorLocation( ), Amp, Radius );
}

void ATankAIController::Tick(float DeltaTime){
    
    Super::Tick(DeltaTime);
    
    auto PlayerTank = GetWorld()->GetFirstPlayerController()->GetPawn();
    
    auto ControlledTank = GetPawn();
    
    if(!ensure(PlayerTank && ControlledTank)){return ; }
        
        //move towards player
        MoveToActor(PlayerTank, AcceptanceRadius);
        //aim towards the player
    auto AimingComponent = ControlledTank->FindComponentByClass<UTankAimingComponent>();
        AimingComponent->AimAt(PlayerTank->GetActorLocation());
        //Fire if ready
    if(AimingComponent->GetFiringStatus() == EFiringStatus::Locked)
    {
    AimingComponent->Fire();
    }
}

void AProjectile::OnHit(UPrimitiveComponent* HitComponent, AActor* OtherActor, UPrimitiveComponent* OtherComponent, FVector NormalImpulse, const FHitResult& Hit)
{
	LaunchBlast->Deactivate();
	ImpactBlast->Activate();
	ExplosionForce->FireImpulse();

	SetRootComponent(ImpactBlast);
	CollisionMesh->DestroyComponent();

	UGameplayStatics::ApplyRadialDamage(
		this,
		ProjectileDamage,
		GetActorLocation(),
		ExplosionForce->Radius,
		UDamageType::StaticClass(),
		TArray<AActor*>() // don't ignore any actors
	);

	auto Timer = FTimerHandle();
	GetWorld()->GetTimerManager().SetTimer(Timer, this, &AProjectile::OnTimerExpire, DestroyDelay, false);
}

void AHunterMarxo::Attack()
{
		if (MainProjectile != NULL)
		{
				if (Ammo < 1)
				{
						Reload();
						return;
				}
				MainProjectile ->GetDefaultObject<ABasicProjectile>()->SetDamage(Super::Attack);
				const FRotator SpawnRotation = CameraArm->GetComponentRotation();
				const FVector SpawnLocation = GetActorLocation() + SpawnRotation.RotateVector(MainOffset);

				UWorld* const World = GetWorld();
				if (World != NULL)
				{
						World->SpawnActor<ABasicProjectile>(MainProjectile, SpawnLocation, SpawnRotation);
				}
				Ammo--;
		}
}

void AProjectileSpell::UpdateProjectileVelocity()
{
	auto character = Cast<ABaseCharacter>(this->GetInstigator());
	if (character && character->Controller) {
		FVector rotator;
		FVector characterRotation = character->Controller->GetControlRotation().Vector();

		if (TargetDirection != FVector(0)) {
			rotator = TargetDirection;
		} 
		else if (TargetLocation != FVector(0)) {
			auto position = character->GetActorLocation();
			rotator = UKismetMathLibrary::FindLookAtRotation(position, TargetLocation).Vector();
		}
		else {
			rotator = characterRotation;
		}

		MovementComponent->Velocity = rotator * MovementComponent->InitialSpeed;
	}
}

void ATankAIController::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);

	auto PlayerTank = GetWorld()->GetFirstPlayerController()->GetPawn();
	auto ControlledTank =GetPawn();
	if (!ensure(PlayerTank && ControlledTank)) { return; }
	//Move Towards the player
	MoveToActor(PlayerTank, AcceptanceRadius);

	//aim towards the player
	auto AimingComponent = ControlledTank->FindComponentByClass<UTankAimingComponent>();
	AimingComponent->AimAt(PlayerTank->GetActorLocation());
		
	//if aiming or locked
	if (AimingComponent->GetFiringState() == EFiringState::Locked)
	{
		AimingComponent->Fire(); //TODO dont fire every frame , limit fire rate
	}
	
}

void AMeteorProjectile::OnHit(AActor* SelfActor, AActor* OtherActor, FVector NormalImpulse, const FHitResult& Hit)
{
	UE_LOG(LogTemp, Display, TEXT("METEOR HIT"));

	TArray<FOverlapResult> res;

	if (GetWorld()->OverlapMultiByChannel(res, GetActorLocation(), FQuat::Identity, ECollisionChannel::ECC_Visibility, FCollisionShape::MakeSphere(300)))
	{
		for (auto a : res)
		{
			if (a.Actor.IsValid() && Cast<ABaseGamer>(a.Actor.Get()))
			{
				a.Actor->TakeDamage(FMath::FRandRange(6000, 16000), FDamageEvent(), GetInstigator() ? GetInstigator()->GetController() : nullptr, this);
			}
		}
	}

	//DrawDebugSphere(GetWorld(), GetActorLocation(), 300, 16, FColor::Red, false, 1);

	Destroy();
}

void AActor::EditorApplyScale( const FVector& DeltaScale, const FVector* PivotLocation, bool bAltDown, bool bShiftDown, bool bCtrlDown )
{
	if( RootComponent != NULL )
	{
		const FVector CurrentScale = GetRootComponent()->RelativeScale3D;

		// @todo: Remove this hack once we have decided on the scaling method to use.
		FVector ScaleToApply;

		if( AActor::bUsePercentageBasedScaling )
		{
			ScaleToApply = CurrentScale * (FVector(1.0f) + DeltaScale);
		}
		else
		{
			ScaleToApply = CurrentScale + DeltaScale;
		}

		GetRootComponent()->SetRelativeScale3D(ScaleToApply);

		if (PivotLocation)
		{
			const FVector CurrentScaleSafe(CurrentScale.X ? CurrentScale.X : 1.0f,
										   CurrentScale.Y ? CurrentScale.Y : 1.0f,
										   CurrentScale.Z ? CurrentScale.Z : 1.0f);

			FVector Loc = GetActorLocation();
			Loc -= *PivotLocation;
			Loc *= (ScaleToApply / CurrentScaleSafe);
			Loc += *PivotLocation;
			GetRootComponent()->SetWorldLocation(Loc);
		}
	}
	else
	{
		UE_LOG(LogActor, Warning, TEXT("WARNING: EditorApplyTranslation %s has no root component"), *GetName() );
	}

	FEditorSupportDelegates::UpdateUI.Broadcast();
}

void AInteractDoors::Interact(AActor* Interactor)
{
		if (!bIsLocked)
		{
				if (bIsOpen)
				{
					bIsOpen = false;
				}
				else
				{
					bIsOpen = true;
				}
				UGameplayStatics::PlaySoundAtLocation(GetWorld(), SoundEffect, GetActorLocation());

				UInteractableAnimInstance* DoorAnim = Cast<UInteractableAnimInstance>(SkeletalMesh->GetAnimInstance());
				
				if (DoorAnim)
				{
					DoorAnim->bActivated = true;
				}
		}
}

void ASCharacter::DropWeapon()
{
	if (Role < ROLE_Authority)
	{
		ServerDropWeapon();
		return;
	}

	if (CurrentWeapon)
	{
		FVector CamLoc;
		FRotator CamRot;

		if (Controller == nullptr)
			return;

		/* Find a location to drop the item, slightly in front of the player. */
		Controller->GetPlayerViewPoint(CamLoc, CamRot);
		const FVector Direction = CamRot.Vector();
		const FVector SpawnLocation = GetActorLocation() + (Direction * DropItemDistance);

		FActorSpawnParameters SpawnInfo;
		SpawnInfo.bNoCollisionFail = true;
		ASWeaponPickup* NewWeaponPickup = GetWorld()->SpawnActor<ASWeaponPickup>(CurrentWeapon->WeaponPickupClass, SpawnLocation, FRotator::ZeroRotator, SpawnInfo);

		if (NewWeaponPickup)
		{
			/* Apply torque to make it spin when dropped. */
			UStaticMeshComponent* MeshComp = NewWeaponPickup->GetMeshComponent();
			if (MeshComp)
			{
				MeshComp->SetSimulatePhysics(true);
				MeshComp->AddTorque(FVector(1, 1, 1) * 4000000);
			}
		}

		RemoveWeapon(CurrentWeapon);
	}
}

void SELF::RegisterArtifact()
{
	int i;
	AUTCTFFlag* Artifact;
	FActorSpawnParameters Params;
	Params.Owner = this;

	ArtifactNum++;
	Artifact = (*GetWorld()).SpawnActor<AUTCTFFlag>(TeamFlagTypes[TeamNum], GetActorLocation() + FVector(0,0,96), GetActorRotation(), Params);
	if (Artifact)
	{
		ArtifactIDs.Add(Artifact);
		(*Artifact).Init(this);
		// GEm: If not for legacy reasons, could just call Destroy() on the old artifact, but now deactivate the last one
		for (i = 0; i < ArtifactIDs.Num(); i++)
		{
			if (!Cast<AXMPArtifact>(ArtifactIDs[i])->bEnabled)
				Cast<AXMPArtifact>(ArtifactIDs[i])->Deactivate();
		}
		UpdateLegacy();
	}
}

void APlayerOvi::BeginPlay() {
  Super::BeginPlay();
  //tag player
  this->Tags.Add("Player");

  // time for button animation
  m_elapsedAltar = m_elapsedPortal = m_elapsedButton = 0.0f;
  // material for capsule
  CapsuleComponent->SetMaterial(0, nullptr);
  // calculate limit world & initial orientation
  float dotForward = FVector::DotProduct(FVector(1, 1, 1), GetActorForwardVector());
  if (dotForward < 0)
    m_state = States::LEFT;
  else
    m_state = States::RIGHT;

  m_limit = FVector::DotProduct(GetActorLocation(), GetActorRightVector());
  m_limit = abs(m_limit);

  //GetCaspuleValues for simulate physics
  m_capsuleHeight = CapsuleComponent->GetScaledCapsuleHalfHeight();
  m_capsuleRadious = CapsuleComponent->GetScaledCapsuleRadius();
  m_capsuleHeightPadding = m_capsuleHeight * PADDING_COLLISION_PERCENT;
  m_capsuleRadiousPadding = m_capsuleRadious * PADDING_COLLISION_PERCENT_RADIOUS;
  m_capsuleHeightPaddingFeet = m_capsuleHeight * PADDING_COLLISION_PERCENT_FEET;

  //Set player Stick in the animation socket
  if (Mesh) {
    m_stick = GetWorld()->SpawnActor<AStick>(AStick::StaticClass());
    const USkeletalMeshSocket *socket = Mesh->GetSocketByName("Puntodeacople_Baston");
    if (socket)
      socket->AttachActor(m_stick, Mesh);
    m_colorKey = FLinearColor(FVector(0.5f));
    m_stick->SetColor(FLinearColor(FVector(0.5f)), 5.0f);
  }

  m_inTutorial = false;
  m_isValid = false;
}

void ALeafNode::DebugDraw()
{
	const FVector location = GetActorLocation();

	if (UWorld* const a_World = Tree->tidGetWorld())
	{

		FColor Color = FColor::Red;

		//Left
		FVector Start = FVector(location.X, location.Y, location.Z);
		FVector End = FVector(location.X, location.Y + Dimensions.Y, location.Z);

		DrawDebugLine(a_World, Start, End, Color);

		//Bottom
		Start = FVector(location.X, location.Y, location.Z);
		End = FVector(location.X + Dimensions.X, location.Y, location.Z);

		DrawDebugLine(a_World, Start, End, Color);

		//Right
		Start = FVector(location.X + Dimensions.X, location.Y, location.Z);
		End = FVector(location.X + Dimensions.X, location.Y + Dimensions.Y, location.Z);

		DrawDebugLine(a_World, Start, End, Color);

		//Top
		Start = FVector(location.X + Dimensions.X, location.Y + Dimensions.Y, location.Z);
		End = FVector(location.X, location.Y + Dimensions.Y, location.Z);

		DrawDebugLine(a_World, Start, End, Color);

		// Draw debug box at center of node
		//const FVector2D roomPosition = FVector2D(location.X + Dimensions.X * 0.5f, location.Y + Dimensions.Y * 0.5f);
		//DrawDebugBox(a_World, FVector(roomPosition.X, roomPosition.Y, 5.0f), FVector(10.0f), FColor::Blue);

	}
}

bool ADraggableMoveTile::cameraRayIntersectWithTilePlane(
									 const FVector& camlocation,
									 const FVector& dir,
									 FVector& hitPoint)

{
	bool hitPlane = false;
	auto planeNormal = GetActorUpVector();
	auto demon = FMath::Abs(FVector::DotProduct(dir, planeNormal));

	if (demon > FLT_EPSILON)
	{
		auto t = FVector::DotProduct(camlocation - GetActorLocation(), planeNormal) / demon;
		hitPlane = t >= 0;
		if (hitPlane)
		{
			hitPoint = camlocation + dir * t;
		}
	}

	return hitPlane;
}

// Called when the game starts or when spawned
void AGib::BeginPlay()
{
	Super::BeginPlay();
	FVector Origin = this->GetActorLocation();
	//SetActorLocation(FVector(Origin.X, Origin.Y, FloorOffset));
	IsAttacked = false;

	//Applying Impulse force and setting physics on
	GibMesh1->SetSimulatePhysics(true);
	GibMesh1->AddRadialImpulse(Origin, ForceRadius, ImpulseForce, ERadialImpulseFalloff::RIF_Linear, true);

	GibMesh2->SetSimulatePhysics(true);
	GibMesh2->AddRadialImpulse(Origin, ForceRadius, ImpulseForce, ERadialImpulseFalloff::RIF_Linear, true);

	GibMesh3->SetSimulatePhysics(true);
	GibMesh3->AddRadialImpulse(Origin, ForceRadius, ImpulseForce, ERadialImpulseFalloff::RIF_Linear, true);
	
	GibMesh4->SetSimulatePhysics(true);
	GibMesh4->AddRadialImpulse(Origin, ForceRadius, ImpulseForce, ERadialImpulseFalloff::RIF_Linear, true);
	
	GibMesh5->SetSimulatePhysics(true);
	GibMesh5->AddRadialImpulse(Origin, ForceRadius, ImpulseForce, ERadialImpulseFalloff::RIF_Linear, true);
	
	GibMesh6->SetSimulatePhysics(true);
	GibMesh6->AddRadialImpulse(Origin, ForceRadius, ImpulseForce, ERadialImpulseFalloff::RIF_Linear, true);
	

	//Play sound effect
	if (GibSound != NULL)
	{
		UGameplayStatics::PlaySoundAtLocation(this, GibSound, GetActorLocation(), 1, 1);
	}

	//Spawn Particle
	//if (Particles != NULL)
	//{
	//}
}