FightEncounter

// Fight.h

#pragma once

#include "CoreMinimal.h"
#include "UObject/NoExportTypes.h"
#include "Fight.generated.h"

class ACombatCharacter;
class AAlly;
class AEnemy;
class AFightEncounter;
class ADefaultHUD;
class ADefaultGameMode;
class USkill;
class USummonSkill;
class UItem;
class APlayerController;

UCLASS()
class WIRSPRAWIEDLIWOSCI_API UFight : public UObject
{
    GENERATED_BODY()
public:
    UFight();
    void BuildTurnOrder();

    UFUNCTION()
    void StartTurn();

    UFUNCTION()
    void EndTurn();

    void MarkTargetsForSelection();
    void MarkAllyTargetsForSelection();
    void MarkEnemyTargetsForSelection();
    bool SkillTargetsAlly();
    bool SkillTargetsEnemy();
    void AddCurrentCharacterToOverlay();
    void AddSkillIconClickedEvents();
    void AddItemClickedEvents();
    void PerformEnemyTurn();
    void ChooseAttackTarget();
    AAlly* GetFirstAliveAlly();
    bool NoTargetsForEnemyAttack();
    void TriggerMelee(ACombatCharacter* Source);
    void UseSkillMelee();
    void CharacterMoveToLocation();
    void ClearEnemyArrows();
    AEnemy* GetLowestHealthEnemy();
    AAlly* GetDefenderAlly();
    AEnemy* GetDefenderEnemy();
    AAlly* GetSpecificTarget();
    USkill* GetEnemyHealingSkill(AEnemy* CurrentEnemy);
    USkill* GetEnemySupportSkill(AEnemy* CurrentEnemy);
    USkill* GetEnemySummonSkill(AEnemy* CurrentEnemy);
    TArray<USkill*> GetEnemyAttacks(AEnemy* CurrentEnemy);
    TArray<ACombatCharacter*> BuildTargetArray();
    TArray<int32> GetAvailableAllyRanks();

    UFUNCTION()
    void HandleOnSkillIconClicked(USkill* ClickedSkill);

    UFUNCTION()
    void HandleOnEndTurnButtonClicked();

    UFUNCTION()
    void HandleOnCharacterHover(ACombatCharacter* HoveredCharacter);

    UFUNCTION()
    void HandleOnCharacterEndHover(ACombatCharacter* HoveredCharacter);

    UFUNCTION()
    void HandleOnCharacterClicked(ACombatCharacter* ClickedCharacter);

    void UseSkill();

    void UseSummonSkill(USummonSkill* Skill);

    UFUNCTION()
    void UseItem(UItem* Item);

    UFUNCTION()
    void HandleOnTargetReached(ACombatCharacter* Character);

    UFUNCTION()
    void HandleOnLocationReached(ACombatCharacter* Character);

    UFUNCTION()
    void HandleOnCharacterDeath(ACombatCharacter* DeadCharacter);

    void EnableMouseEvents();
    void DisableMouseEvents();

    inline static bool IsFaster(ACombatCharacter* A, ACombatCharacter* B);

    UPROPERTY()
    APlayerController* Controller;

    UPROPERTY()
    ADefaultGameMode* CurrentGameMode;

    UPROPERTY()
    ACombatCharacter* CurrentCharacter;

    UPROPERTY()
    ACombatCharacter* CurrentTarget;

    UPROPERTY()
    TArray<ACombatCharacter*> Targets;

    UPROPERTY()
    USkill* CurrentSkill;

    UPROPERTY()
    TArray<AAlly*> AlliedParty;

    UPROPERTY()
    TArray<AEnemy*> EnemyParty;

    UPROPERTY()
    AFightEncounter* Encounter;

    UPROPERTY()
    int16 AlliesAlive;

    UPROPERTY()
    int16 EnemiesAlive;

    UPROPERTY()
    ADefaultHUD* CurrentHUD;

    TQueue<ACombatCharacter*> TurnQueue;

    UPROPERTY()
    FTimerHandle TurnTimer;
};

//Fight.cpp

// Fill out your copyright notice in the Description page of Project Settings.


#include "GameMechanics/Combat/Fight.h"
#include "GameMechanics/Combat/FightEncounter.h"
#include "GameMechanics/Skill.h"
#include "GameMechanics/SummonSkill.h"
#include "Characters/CombatCharacter.h"
#include "Characters/Ally.h"
#include "Characters/Enemy.h"
#include "GameMechanics/AttributeComponent.h"
#include "GameMechanics/Effect.h"
#include "GameMechanics/GameModes/DefaultGameMode.h"
#include "UI/DefaultHUD.h"
#include "UI/InventorySlot.h"
#include "UI/InventoryWidget.h"
#include "UI/CombatOverlay.h"
#include "UI/SkillIcon.h"
#include "Items/Item.h"
#include "Kismet/KismetStringLibrary.h"

UFight::UFight()
{
}

void UFight::BuildTurnOrder()
{
    TurnQueue.Empty();
    TArray<ACombatCharacter*> BothParties;
    BothParties.Append(AlliedParty);
    BothParties.Append(EnemyParty);
    Algo::Sort(BothParties, UFight::IsFaster);
    for (ACombatCharacter* Character : BothParties)
    {
        TurnQueue.Enqueue(Character);
        UE_LOG(LogTemp, Log, TEXT("Added character to TurnQueue: %s"), *Character->GetName());
    }
    BothParties.Empty();
}

void UFight::StartTurn()
{
    CurrentSkill = nullptr;
    CurrentCharacter = nullptr;
    Targets.Empty();
    TurnQueue.Dequeue(CurrentCharacter);
    if (TurnQueue.IsEmpty())
    {
        BuildTurnOrder();
    }
    AddCurrentCharacterToOverlay();
    if(!CurrentCharacter || !CurrentCharacter->IsValidLowLevel())
    {
        UE_LOG(LogTemp, Warning, TEXT("Invalid CurrentCharacter in StartTurn"));
        EndTurn();
        return;
    }
    CurrentCharacter->SetArrowToWhite();
    CurrentCharacter->ShowArrow();
    CurrentCharacter->StartTurn();
    if (CurrentCharacter->ActorHasTag(FName("Stunned")))
    {
        CurrentCharacter->ReturnFromStun();
        EndTurn();
        return;
    }
    if (CurrentCharacter->ActorHasTag(FName("Dead")))
    {
        EndTurn();
        return;
    }
    if (CurrentCharacter->IsA(AEnemy::StaticClass()))
    {
        CurrentCharacter->GetWorldTimerManager().SetTimer(TurnTimer, this, &UFight::PerformEnemyTurn, 2.f);
    }
}

void UFight::EndTurn()
{
    if(CurrentCharacter) CurrentCharacter->GetWorldTimerManager().ClearTimer(TurnTimer);
    DisableMouseEvents();
    if (TurnQueue.IsEmpty())
    {
        BuildTurnOrder();
    }
    float TimeToWait = 0.5f;
    if (CurrentSkill)
    {
        TimeToWait = CurrentSkill->AnimDuration + 0.3f;
    }
    if (CurrentHUD && CurrentHUD->CombatOverlay)
    {
        CurrentHUD->CombatOverlay->SetNewAlly(nullptr);
    }
    if (CurrentCharacter)
    {
        CurrentCharacter->UpdateEffectIcons();
        CurrentCharacter->GetWorldTimerManager().SetTimer(CurrentCharacter->TurnTimer, CurrentCharacter, &ACombatCharacter::EndTurn, TimeToWait);
        CurrentCharacter->GetWorldTimerManager().SetTimer(TurnTimer, this, &UFight::StartTurn, TimeToWait + 0.2);
        CurrentCharacter->HideArrow();
    }
}

void UFight::MarkTargetsForSelection()
{
    MarkAllyTargetsForSelection();
    MarkEnemyTargetsForSelection();
}

void UFight::MarkAllyTargetsForSelection()
{
    bool bSkillHasSpecificTarget = false;
    AAlly* SpecificTarget = GetSpecificTarget();
    if (SpecificTarget)
    {
        bSkillHasSpecificTarget = true;
    }
    for (int i = 0; i < AlliedParty.Num(); i++)
    {
        if (SkillTargetsAlly() && CurrentSkill->ValidFirstTargetRanks.Contains(i + 1) && !AlliedParty[i]->ActorHasTag(FName("Dead")))
        {
            if (bSkillHasSpecificTarget && SpecificTarget->CharacterName != AlliedParty[i]->CharacterName)
            {
                AlliedParty[i]->bSelectable = false;
            }
            else
            {
                AlliedParty[i]->bSelectable = true;
            }
        }
        else
        {
            AlliedParty[i]->bSelectable = false;
        }
    }
}

void UFight::MarkEnemyTargetsForSelection()
{
    AEnemy* EnemyDefender = GetDefenderEnemy();
    if (EnemyDefender)
    {
        for (int i = 0; i < EnemyParty.Num(); i++)
        {
            EnemyParty[i]->bSelectable = false;
        }
        EnemyDefender->bSelectable = true;
        return;
    }
    for (int i = 0; i < EnemyParty.Num(); i++)
    {
        if (SkillTargetsEnemy() && CurrentSkill->ValidFirstTargetRanks.Contains(EnemyParty[i]->Rank))
        {
            EnemyParty[i]->bSelectable = true;
        }
        else
        {
            EnemyParty[i]->bSelectable = false;
        }
    }
}

bool UFight::SkillTargetsAlly()
{
    return CurrentSkill->SkillType == ESkillType::EST_Heal || CurrentSkill->SkillType == ESkillType::EST_Support || CurrentSkill->SkillType == ESkillType::EST_AttackAlly
        || CurrentSkill->SkillType == ESkillType::EST_UltSupport;
}

bool UFight::SkillTargetsEnemy()
{
    return CurrentSkill->SkillType == ESkillType::EST_Attack || CurrentSkill->SkillType == ESkillType::EST_UltAttack;
}

void UFight::AddCurrentCharacterToOverlay()
{
    if (TurnQueue.IsEmpty()) return;
    if (!CurrentCharacter->IsValidLowLevel()) return;
    CurrentHUD = Cast<ADefaultHUD>(GetWorld()->GetFirstPlayerController()->GetHUD());
    if (CurrentHUD && CurrentHUD->CombatOverlay)
    {
        AAlly* CurrentAlly = Cast<AAlly>(CurrentCharacter);
        if (CurrentAlly->IsValidLowLevel())
        {
            CurrentHUD->CombatOverlay->SetNewAlly(CurrentAlly);
            AddSkillIconClickedEvents();
        }
        AEnemy* CurrentEnemy = Cast<AEnemy>(CurrentCharacter);
        if (CurrentEnemy->IsValidLowLevel())
        {
            CurrentHUD->CombatOverlay->SetNewEnemy(CurrentEnemy);
        }
    }
}

void UFight::AddSkillIconClickedEvents()
{
    CurrentHUD = Cast<ADefaultHUD>(GetWorld()->GetFirstPlayerController()->GetHUD());
    if (!CurrentHUD) return;
    TArray<USkillIcon*> SkillIcons = CurrentHUD->CombatOverlay->GetAllySkillIconsAsArray();
    for (USkillIcon* SkillIcon : SkillIcons)
    {
        if (SkillIcon && SkillIcon->Skill)
        {
            SkillIcon->OnSkillIconClicked.AddUniqueDynamic(this, &UFight::HandleOnSkillIconClicked);
        }
    }
    CurrentHUD->CombatOverlay->AllyUlt->OnSkillIconClicked.AddUniqueDynamic(this, &UFight::HandleOnSkillIconClicked);
}

void UFight::AddItemClickedEvents()
{
    if (!CurrentHUD) return;
    for (UInventorySlot* ItemSlot : CurrentHUD->InventoryWidget->InventorySlots)
    {
        ItemSlot->OnItemClicked.AddUniqueDynamic(this, &UFight::UseItem);
    }
}

void UFight::PerformEnemyTurn()
{
    AEnemy* CurrentEnemy = Cast<AEnemy>(CurrentCharacter);
    CurrentCharacter->GetWorldTimerManager().SetTimer(TurnTimer, this, &UFight::EndTurn, 15.f);
    if (CurrentEnemy)
    {
        USkill* SummonSkill = GetEnemySummonSkill(CurrentEnemy);
        if (SummonSkill && CurrentEnemy->Attributes->GetHealthPercent() <= 0.4 && EnemyParty.Num()<=3)
        {
            CurrentTarget = CurrentEnemy;
            CurrentSkill = SummonSkill;
            Targets = BuildTargetArray();
            CurrentCharacter->GetWorldTimerManager().ClearTimer(TurnTimer);
            UseSkill();
            EndTurn();
        }
        AEnemy* LowestHealthEnemy = GetLowestHealthEnemy();
        USkill* HealingSkill = GetEnemyHealingSkill(CurrentEnemy);
        if (LowestHealthEnemy->Attributes->GetHealthPercent()<=0.35f && HealingSkill)
        {
            CurrentTarget = LowestHealthEnemy;
            CurrentSkill = HealingSkill;
            Targets = BuildTargetArray();
            if (CurrentSkill->bMelee)
            {
                TriggerMelee(CurrentEnemy);
            }
            else
            {
                CurrentCharacter->GetWorldTimerManager().ClearTimer(TurnTimer);
                UseSkill();
                EndTurn();
            }
            return;
        }
        USkill* SupportSkill = GetEnemySupportSkill(CurrentEnemy);
        if (CurrentEnemy->Turn<=3 && !CurrentEnemy->bHasBuffs() && SupportSkill &&
            !(SupportSkill->GetInflictedEffect() && SupportSkill->GetInflictedEffect()->bHeal
                && LowestHealthEnemy->Attributes->GetHealth() == LowestHealthEnemy->Attributes->GetMaxHealth()))
        {
            CurrentSkill = SupportSkill;
            int32 Rank =
                CurrentSkill->ValidFirstTargetRanks.IsEmpty() ? EnemyParty.Find(CurrentEnemy)+1 :
                FMath::RandRange(CurrentSkill->ValidFirstTargetRanks[0], CurrentSkill->ValidFirstTargetRanks[CurrentSkill->ValidFirstTargetRanks.Num() - 1]);
            if ((Rank - 1) < EnemyParty.Num())
            {
                CurrentTarget = EnemyParty[Rank - 1];
            }
            Targets = BuildTargetArray();
            if (CurrentSkill->bMelee)
            {
                TriggerMelee(CurrentEnemy);
            }
            else
            {
                CurrentCharacter->GetWorldTimerManager().ClearTimer(TurnTimer);
                UseSkill();
                EndTurn();
            }
            return;
        }
        TArray<USkill*> EnemyAttacks = GetEnemyAttacks(CurrentEnemy);
        if (!EnemyAttacks.IsEmpty())
        {
            int32 Index = FMath::RandRange(0, EnemyAttacks.Num() - 1);
            CurrentSkill = EnemyAttacks[Index];
            ChooseAttackTarget();
            UEffect* InflictedEffect = CurrentSkill->GetInflictedEffect();
            if (InflictedEffect)
            {
                UEffect* EffectOfType = CurrentTarget->GetEffectOfType(InflictedEffect->EffectType);
                if (EffectOfType && EffectOfType->GetDuration() >= 2)
                {
                    EnemyAttacks.Remove(CurrentSkill);
                    if (EnemyAttacks.IsEmpty())
                    {
                        EndTurn();
                        return;
                    }
                    Index = FMath::RandRange(0, EnemyAttacks.Num() - 1);
                    CurrentSkill = EnemyAttacks[Index];
                    ChooseAttackTarget();
                }
            }
            if (NoTargetsForEnemyAttack())
            {
                EnemyAttacks.Remove(CurrentSkill);
                if (EnemyAttacks.IsEmpty())
                {
                    EndTurn();
                    return;
                }
                Index = FMath::RandRange(0, EnemyAttacks.Num() - 1);
                CurrentSkill = EnemyAttacks[Index];
                if (NoTargetsForEnemyAttack())
                {
                    EndTurn();
                    return;
                }
                ChooseAttackTarget();
            }
            Targets = BuildTargetArray();
            if (CurrentSkill->bMelee)
            {
                TriggerMelee(CurrentEnemy);
            }
            else
            {
                CurrentCharacter->GetWorldTimerManager().ClearTimer(TurnTimer);
                UseSkill();
                EndTurn();
            }
            return;
        }
    }
    else
    {
        CurrentCharacter->GetWorldTimerManager().ClearTimer(TurnTimer);
        EndTurn();
        return;
    }
}

void UFight::ChooseAttackTarget()
{
    AAlly* AllyDefender = GetDefenderAlly();
    if (AllyDefender)
    {
        CurrentTarget = AllyDefender;
        return;
    }
    if (NoTargetsForEnemyAttack())
    {
        EndTurn();
        return;
    }
    TArray<int32> AvailableAllyRanks = GetAvailableAllyRanks();
    if (AvailableAllyRanks.IsEmpty())
    {
        EndTurn();
        return;
    }
    else
    {
        int32 Index = FMath::RandRange(0, AvailableAllyRanks.Num() - 1);
        if (AvailableAllyRanks[Index] < AlliedParty.Num() && AlliedParty[AvailableAllyRanks[Index]])
        {
            CurrentTarget = AlliedParty[AvailableAllyRanks[Index]];
        }
        else
        {
            ChooseAttackTarget();
        }
    }
}

AAlly* UFight::GetFirstAliveAlly()
{
    for (AAlly* Ally : AlliedParty)
    {
        if (Ally->ActorHasTag(FName("Dead")))
        {
            return Ally;
        }
    }
    return nullptr;
}

bool UFight::NoTargetsForEnemyAttack()
{
    for (AAlly* Ally : AlliedParty)
    {
        if (CurrentSkill && CurrentSkill->ValidFirstTargetRanks.Contains(AlliedParty.Find(Ally)) && !Ally->ActorHasTag(FName("Dead")))
        {
            return false;
        }
    }
    return true;
}

void UFight::TriggerMelee(ACombatCharacter* Source)
{
    if (Targets.IsEmpty())
    {
        EndTurn();
        return;
    }
    if(Targets[0] != Source)
    {
        Source->CombatTarget = Targets[0];
        Source->TargetLocation = Source->InitialLocation;
        Source->bShouldMoveToTarget = true;
    }
    else
    {
        CurrentCharacter->GetWorldTimerManager().ClearTimer(TurnTimer);
        UseSkill();
        EndTurn();
        return;
    }
}

AEnemy* UFight::GetLowestHealthEnemy()
{
    if (EnemyParty.IsEmpty()) return nullptr;
    AEnemy* LowestHealthEnemy = EnemyParty[0];
    for (int i = 1; i < EnemyParty.Num(); i++)
    {
        if (i < EnemyParty.Num() && EnemyParty[i] && EnemyParty[i]->Attributes->GetHealth() < EnemyParty[i - 1]->Attributes->GetHealth())
        {
            LowestHealthEnemy = EnemyParty[i];
        }
    }
    return LowestHealthEnemy;
}

AAlly* UFight::GetDefenderAlly()
{
    if (AlliedParty.IsEmpty())
    {
        return nullptr;
    }
    for (int i = 0; i < AlliedParty.Num(); i++)
    {
        if (AlliedParty[i] && AlliedParty[i]->ActorHasTag(FName("Defender")) && !AlliedParty[i]->ActorHasTag(FName("Dead")))
        {
            return AlliedParty[i];
        }
    }
    return nullptr;
}

AEnemy* UFight::GetDefenderEnemy()
{
    if (EnemyParty.IsEmpty()) return nullptr;
    for (int i = 0; i < EnemyParty.Num(); i++)
    {
        if (EnemyParty[i] && EnemyParty[i]->ActorHasTag(FName("Defender")))
        {
            return EnemyParty[i];
        }
    }
    return nullptr;
}

AAlly* UFight::GetSpecificTarget()
{
    for (int i = 1; i < AlliedParty.Num(); i++)
    {
        if (CurrentSkill && AlliedParty[i] && AlliedParty[i]->CharacterName == CurrentSkill->SpecificTargetName)
        {
            return AlliedParty[i];
        }
    }
    return nullptr;
}

USkill* UFight::GetEnemyHealingSkill(AEnemy* CurrentEnemy)
{
    if (CurrentEnemy->EquippedSkills.IsEmpty()) return nullptr;
    for (USkill* Skill : CurrentEnemy->EquippedSkills)
    {
        if (Skill->SkillType == ESkillType::EST_Heal && Skill->ManaCost <= CurrentCharacter->Attributes->GetMana())
        {
            return Skill;
        }
    }
    return nullptr;
}

USkill* UFight::GetEnemySupportSkill(AEnemy* CurrentEnemy)
{
    if (CurrentEnemy->EquippedSkills.IsEmpty()) return nullptr;
    for (USkill* Skill : CurrentEnemy->EquippedSkills)
    {
        if ((Skill->SkillType == ESkillType::EST_Support || Skill->SkillType == ESkillType::EST_AttackAlly)
            && Skill->ManaCost <= CurrentCharacter->Attributes->GetMana())
        {
            return Skill;
        }
    }
    return nullptr;
}

USkill* UFight::GetEnemySummonSkill(AEnemy* CurrentEnemy)
{
    if (CurrentEnemy->EquippedSkills.IsEmpty()) return nullptr;

    for (USkill* Skill : CurrentEnemy->EquippedSkills)
    {
        if ((Skill->SkillType == ESkillType::EST_Summon)
            && Skill->ManaCost <= CurrentCharacter->Attributes->GetMana())
        {
            return Skill;
        }
    }
    return nullptr;
}

TArray<USkill*> UFight::GetEnemyAttacks(AEnemy* CurrentEnemy)
{
    TArray<USkill*> EnemyAttacks;

    if (CurrentEnemy->EquippedSkills.IsEmpty()) return EnemyAttacks;

    for (USkill* Skill : CurrentEnemy->EquippedSkills)
    {
        if (Skill->SkillType == ESkillType::EST_Attack && Skill->SelfDamage<CurrentEnemy->Attributes->GetHealth()
            && Skill->ManaCost <= CurrentCharacter->Attributes->GetMana())
        {
            EnemyAttacks.AddUnique(Skill);
        }
    }
    return EnemyAttacks;
}

TArray<ACombatCharacter*> UFight::BuildTargetArray()
{
    TArray<ACombatCharacter*> NewTargets;
    if (CurrentCharacter == nullptr || CurrentSkill == nullptr || CurrentTarget == nullptr) return NewTargets;
    if (CurrentSkill->NumberOfTargets == 0)
    {
        NewTargets = { CurrentCharacter };
        return NewTargets;
    }
    if(CurrentTarget->IsA(AAlly::StaticClass()))
    {
        AAlly* AllyTarget = Cast<AAlly>(CurrentTarget);
        int32 Index = AlliedParty.Find(AllyTarget);
        for (int32 i = Index; i < Index + CurrentSkill->NumberOfTargets; i++)
        {
            if (i < AlliedParty.Num() && AlliedParty[i] && !AlliedParty[i]->ActorHasTag(FName("Dead")))
            {
                NewTargets.Add(AlliedParty[i]);
            }
        }
    }
    if (CurrentTarget->IsA(AEnemy::StaticClass()))
    {
        AEnemy* EnemyTarget = Cast<AEnemy>(CurrentTarget);
        int32 Index = EnemyParty.Find(EnemyTarget);
        for (int32 i = Index; i < Index + CurrentSkill->NumberOfTargets; i++)
        {
            if (i < EnemyParty.Num())
            {
                NewTargets.Add(EnemyParty[i]);
            }
        }
    }
    return NewTargets;
}

TArray<int32> UFight::GetAvailableAllyRanks()
{
    TArray<int32> AliveAllyRanks;
    for (AAlly* Ally : AlliedParty)
    {
        int32 AllyIndex = AlliedParty.Find(Ally);
        if (CurrentSkill && CurrentSkill->ValidFirstTargetRanks.Contains(AllyIndex + 1)
            && !Ally->ActorHasTag(FName("Dead")))
        {
            AliveAllyRanks.AddUnique(AllyIndex);
        }
    }
    return AliveAllyRanks;
}

void UFight::HandleOnSkillIconClicked(USkill* ClickedSkill)
{
    EnableMouseEvents();
    if (ClickedSkill)
    {
        CurrentSkill = ClickedSkill;
        MarkTargetsForSelection();
        if (CurrentSkill->ManaCost > CurrentCharacter->Attributes->GetMana())
        {
            CurrentCharacter->ShowSpecialInfoText(TEXT("Za ma\u0142o many!"));
            DisableMouseEvents();
            return;
        }
        if (ClickedSkill->NumberOfTargets == 0)
        {
            Targets = { CurrentCharacter };
            UseSkill();
            DisableMouseEvents();
            CurrentCharacter->GetWorldTimerManager().ClearTimer(TurnTimer);
            EndTurn();
            return;
        }
    }
}

void UFight::HandleOnEndTurnButtonClicked()
{
    if (CurrentCharacter && !CurrentCharacter->IsA(AEnemy::StaticClass()))
    {
        EndTurn();
    }
}

void UFight::HandleOnCharacterHover(ACombatCharacter* HoveredCharacter)
{
    if (HoveredCharacter == nullptr || CurrentSkill->NumberOfTargets <= 1) return;
    if (HoveredCharacter->IsA(AAlly::StaticClass()))
    {
        int32 Index = AlliedParty.Find(Cast<AAlly>(HoveredCharacter));
        for (int i = Index + 1; i < Index + CurrentSkill->NumberOfTargets; i++)
        {
            if (i >= AlliedParty.Num()) return;
            AlliedParty[i]->SetArrowToColor();
            AlliedParty[i]->ShowArrow();
        }
    }
    else
    {
        AEnemy* CurrentEnemy = Cast<AEnemy>(HoveredCharacter);
        if (!CurrentEnemy->IsValidLowLevel()) return;
        //AEnemy* EnemyDefender = GetDefenderEnemy();
        //if (EnemyDefender && EnemyDefender != CurrentEnemy)
        //  return;
        CurrentHUD = Cast<ADefaultHUD>(GetWorld()->GetFirstPlayerController()->GetHUD());
        if(CurrentHUD && CurrentHUD->CombatOverlay)
        {
            CurrentHUD->CombatOverlay->SetNewEnemy(CurrentEnemy);
        }
        int32 Index = EnemyParty.Find(CurrentEnemy);
        for (int i = Index + 1; i < Index + CurrentSkill->NumberOfTargets; i++)
        {
            if (i >= EnemyParty.Num()) return;
            EnemyParty[i]->SetArrowToColor();
            EnemyParty[i]->ShowArrow();
        }
    }
}

void UFight::HandleOnCharacterEndHover(ACombatCharacter* HoveredCharacter)
{
    if (HoveredCharacter == nullptr || CurrentSkill->NumberOfTargets <= 1) return;
    if (CurrentSkill->NumberOfTargets <= 1) return;
    if (HoveredCharacter->IsA(AAlly::StaticClass()))
    {
        int32 Index = AlliedParty.Find(Cast<AAlly>(HoveredCharacter));
        for (int i = Index + 1; i < Index + CurrentSkill->NumberOfTargets; i++)
        {
            if (i >= AlliedParty.Num()) return;
            AlliedParty[i]->HideArrow();
        }
    }
    else
    {
        int32 Index = EnemyParty.Find(Cast<AEnemy>(HoveredCharacter));
        for (int i = Index + 1; i < Index + CurrentSkill->NumberOfTargets; i++)
        {
            if (i >= EnemyParty.Num()) return;
            EnemyParty[i]->HideArrow();
        }
    }
}

void UFight::HandleOnCharacterClicked(ACombatCharacter* ClickedCharacter)
{
    Targets.Empty();
    ClearEnemyArrows();
    if (ClickedCharacter == nullptr) return;
    if (ClickedCharacter->IsA(AAlly::StaticClass()))
    {
        int32 Index = AlliedParty.Find(Cast<AAlly>(ClickedCharacter));
        for (int i = Index; i < Index + CurrentSkill->NumberOfTargets; i++)
        {
            if (i >= AlliedParty.Num()) break;
            Targets.Add(AlliedParty[i]);
        }
    }
    else
    {
        AEnemy* CurrentEnemy = Cast<AEnemy>(ClickedCharacter);
        AEnemy* EnemyDefender = GetDefenderEnemy();
        if (CurrentEnemy && EnemyDefender && EnemyDefender != CurrentEnemy)
            return;
        int32 Index = EnemyParty.Find(CurrentEnemy);
        for (int i = Index; i < Index + CurrentSkill->NumberOfTargets; i++)
        {
            if (i >= EnemyParty.Num()) break;
            Targets.Add(EnemyParty[i]);
        }
    }
    if (CurrentSkill && !Targets.IsEmpty())
    {
        if (CurrentSkill->bMelee)
        {
            TriggerMelee(CurrentCharacter);
            DisableMouseEvents();
        }
        else
        {
            CurrentCharacter->GetWorldTimerManager().ClearTimer(TurnTimer);
            UseSkill();
            EndTurn();
        }
    }
}

void UFight::HandleOnTargetReached(ACombatCharacter* Character)
{
    if (Character && Character == CurrentCharacter)
    {
        UseSkillMelee();
    }
}

void UFight::HandleOnLocationReached(ACombatCharacter* Character)
{
    if (Character == nullptr || Character != CurrentCharacter) return;
    Character->Flip(false);
    if (Character->IsA(AAlly::StaticClass()))
    {
        Character->SetActorRotation(FRotator::ZeroRotator);
    }
    else
    {
        Character->SetActorRotation(FRotator(0.f, 180.f, 0.f));
    }
    Character->SetActorLocation(Character->TargetLocation);

    CurrentCharacter->GetWorldTimerManager().ClearTimer(TurnTimer);
    EndTurn();
}

void UFight::HandleOnCharacterDeath(ACombatCharacter* DeadCharacter)
{
    if (DeadCharacter->IsA(AAlly::StaticClass()))
    {
        AlliesAlive--;
        if (AlliesAlive == 0)
        {
            Encounter->GetWorldTimerManager().SetTimer(TurnTimer, Encounter, &AFightEncounter::EndFightFailure, 2.f);
        }
    }
    if (DeadCharacter->IsA(AEnemy::StaticClass()))
    {
        EnemiesAlive--;
        Encounter->GainedExp += DeadCharacter->GetExperience();
        if (EnemiesAlive == 0)
        {
            Encounter->GetWorldTimerManager().SetTimer(TurnTimer, Encounter, &AFightEncounter::EndFightSuccess, 1.5f);
        }
        EnemyParty.Remove(Cast<AEnemy>(DeadCharacter));
        CurrentHUD = Cast<ADefaultHUD>(GetWorld()->GetFirstPlayerController()->GetHUD());
        if (CurrentHUD && CurrentHUD->CombatOverlay)
        {
            CurrentHUD->CombatOverlay->SetNewEnemy(nullptr);
        }
        DeadCharacter->SetLifeSpan(2.f);
    }
    TurnQueue.Empty();
    BuildTurnOrder();
}

void UFight::UseSkill()
{
    if (CurrentCharacter == nullptr || CurrentSkill == nullptr || Targets.IsEmpty()) return;
    CurrentHUD = Cast<ADefaultHUD>(GetWorld()->GetFirstPlayerController()->GetHUD());
    if (CurrentHUD)
    {
        CurrentHUD->ShowInfoText(CurrentSkill->SkillName);
    }
    if (CurrentSkill->IsA(USummonSkill::StaticClass()))
    {
        USummonSkill* SummonSkill = Cast<USummonSkill>(CurrentSkill);
        if (SummonSkill)
        {
            UseSummonSkill(SummonSkill);
        }
    }
    CurrentSkill->UseSkill(CurrentCharacter, Targets);
}

void UFight::UseSummonSkill(USummonSkill* Skill)
{
    int32 EnemyPartySize = EnemyParty.Num();
    if (EnemyPartySize >= 4 || Encounter==nullptr)
    {
        return;
    }
    FVector DesiredLocation = EnemyParty[EnemyPartySize - 1]->GetActorLocation();
    Encounter->OffestEnemySpawnLocation(DesiredLocation);
    Encounter->SpawnEnemy(DesiredLocation, Skill->SummonedEnemyClasses);
}

void UFight::UseItem(UItem* Item)
{
    CurrentHUD = Cast<ADefaultHUD>(GetWorld()->GetFirstPlayerController()->GetHUD());
    if (CurrentHUD && CurrentHUD->InventoryWidget)
    {
        CurrentHUD->InventoryWidget->UpdateInventorySlots();
        CurrentHUD->HideInventory();
    }
    AAlly* CurrentAlly = Cast<AAlly>(CurrentCharacter);
    if (Item == nullptr || CurrentCharacter == nullptr || CurrentAlly == nullptr) return;
    Item->UseItem(CurrentAlly);
    CurrentAlly->bCanUseItems = false;
}

void UFight::UseSkillMelee()
{
    UseSkill();
    CurrentCharacter->GetWorldTimerManager().SetTimer(TurnTimer, this, &UFight::CharacterMoveToLocation, 1.f);
}

void UFight::CharacterMoveToLocation()
{
    CurrentCharacter->bShouldMoveToLocation = true;
}

void UFight::ClearEnemyArrows()
{
    for (AEnemy* Enemy : EnemyParty)
    {
        Enemy->HideArrow();
    }
}

void UFight::EnableMouseEvents()
{
    if (Controller)
    {

        Controller->bEnableClickEvents = true;
        Controller->bEnableMouseOverEvents = true;
    }
}

void UFight::DisableMouseEvents()
{
    if (Controller)
    {
        Controller->bEnableClickEvents = false;
        Controller->bEnableMouseOverEvents = false;
    }
}

inline bool UFight::IsFaster(ACombatCharacter* A, ACombatCharacter* B)
{
    return A->Attributes->Stats.Find(TEXT("Narwano\u015b\u0107")) >= B->Attributes->Stats.Find(TEXT("Narwano\u015b\u0107"));
}

//FightEncounter.h

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "FightEncounter.generated.h"

DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnFightEndedDelegate);
class UFight;
class AEnemy;
class ADefaultGameMode;
class USpringArmComponent;
class UCameraComponent;
class USceneComponent;
class UAudioComponent;
class UItem;

UCLASS()
class WIRSPRAWIEDLIWOSCI_API AFightEncounter : public AActor
{
    GENERATED_BODY()

public:
    AFightEncounter();

    virtual void Tick(float DeltaTime) override;

    UFUNCTION(BlueprintCallable)
    void SpawnFirstEnemy();

    UFUNCTION(BlueprintCallable)
    virtual void StartFight();

    void EndFightSuccess();
    void EndFightFailure();
    void SpawnEnemyParty();
    void SpawnEnemy(FVector& Location, TArray<TSubclassOf<AEnemy>> EnemyClassArray);
    void SetupAllies();
    void OffsetAllyLocation(FVector& Location);
    void OffestEnemySpawnLocation(FVector& Location);
    void SetupAlliesAfterFightEnd();
    void PlayBattleSong();
    void StopBattleSong();
    void PlaySuccessSound();
    void PlayFailSound();

    void SwitchToCombatOverlay();
    void SwitchToPartyOverlay();

    UFUNCTION(BlueprintCallable)
    void EnableMouseCursor();

    UFUNCTION(BlueprintCallable)
    void DisableMouseCursor();

    ADefaultGameMode* CurrentGameMode;

    UPROPERTY(EditAnywhere)
    int16 Level;

    UPROPERTY(EditAnywhere)
    bool bIndoors;

    UPROPERTY(EditAnywhere)
    int32 RespawnsLeft;

    AEnemy* SpawnedEnemy;

    UPROPERTY(EditAnywhere)
    TSubclassOf<AEnemy> SpawnedEnemyClass;

    UPROPERTY(EditAnywhere)
    TArray<TSubclassOf<AEnemy>> EnemyPartyClassesRankOne;

    UPROPERTY(EditAnywhere)
    TArray<TSubclassOf<AEnemy>> EnemyPartyClassesRankTwo;

    UPROPERTY(EditAnywhere)
    TArray<TSubclassOf<AEnemy>> EnemyPartyClassesRankThree;

    UPROPERTY(EditAnywhere)
    TArray<TSubclassOf<AEnemy>> EnemyPartyClassesRankFour;

    UPROPERTY(EditAnywhere)
    TArray<TSubclassOf<UItem>> ItemRewardClasses;

    UPROPERTY()
    UItem* ItemReward;

    UPROPERTY()
    UFight* Fight;

    int32 GainedExp = 0;

    UPROPERTY(EditAnywhere)
    float MoneyReward = 0.f;

    UPROPERTY(EditAnywhere, Category = Sound)
    TArray<USoundBase*> BattleSongs;

    UPROPERTY(EditAnywhere, Category = Sound)
    USoundBase* SuccessSound;

    UPROPERTY(EditAnywhere, Category = Sound)
    USoundBase* FailSound;

    UPROPERTY(BlueprintAssignable, Category = Events)
    FOnFightEndedDelegate OnFightEnded;
protected:
    virtual void BeginPlay() override;

    UPROPERTY(EditAnywhere)
    bool bUseYAxis = false;

    UPROPERTY(EditAnywhere)
    USceneComponent* MainComponent;

    UPROPERTY(EditAnywhere)
    UCameraComponent* Camera;

    UPROPERTY(EditAnywhere)
    UAudioComponent* MusicPlayer;

    FTimerHandle FightEndTimer;
};

//FightEncounter.cpp
#include "GameMechanics/Combat/FightEncounter.h"
#include "GameMechanics/Combat/Fight.h"
#include "GameMechanics/GameModes/DefaultGameMode.h"
#include "GameMechanics/AttributeComponent.h"
#include "GameMechanics/Skill.h"
#include "Characters/Enemy.h"
#include "Characters/Ally.h"
#include "Characters/MainCharacter.h"
#include "AIController.h"
#include "Kismet/GameplayStatics.h"
#include "Components/SceneComponent.h"
#include "Components/AudioComponent.h"
#include "GameFramework/SpringArmComponent.h"
#include "Camera/CameraComponent.h"
#include "UI/DefaultHUD.h"
#include "UI/CombatOverlay.h"
#include "Items/Item.h"

AFightEncounter::AFightEncounter()
{
    PrimaryActorTick.bCanEverTick = true;
    MainComponent = CreateDefaultSubobject<USceneComponent>(TEXT("Root"));
    SetRootComponent(MainComponent);
    Camera = CreateDefaultSubobject<UCameraComponent>(TEXT("Camera"));
    Camera->SetupAttachment(GetRootComponent());
    MusicPlayer = CreateDefaultSubobject<UAudioComponent>(TEXT("Music Player"));
    MusicPlayer->SetupAttachment(GetRootComponent());
}

void AFightEncounter::BeginPlay()
{
    Super::BeginPlay();

    MusicPlayer->Stop();
    if(Tags.IsEmpty())
    {
        SpawnFirstEnemy();
    }
}

void AFightEncounter::SpawnFirstEnemy() //spawns enemy who chases you
{
    if (GetWorld())
    {
        if(RespawnsLeft <= 0) return;
        SpawnedEnemy = GetWorld()->SpawnActor<AEnemy>(SpawnedEnemyClass, MainComponent->GetComponentLocation(), FRotator::ZeroRotator);
        if (SpawnedEnemy)
        {
            SpawnedEnemy->SpawnerEncounter = this;
            AAIController* NewAIController = GetWorld()->SpawnActor<AAIController>(AAIController::StaticClass(), GetActorLocation(), FRotator::ZeroRotator);
            NewAIController->Possess(SpawnedEnemy);
            SpawnedEnemy->AIController = NewAIController;
        }
    }
    CurrentGameMode = Cast<ADefaultGameMode>(UGameplayStatics::GetGameMode(this));
}

void AFightEncounter::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
}

void AFightEncounter::StartFight()
{
    Fight = nullptr;
    if (RespawnsLeft <= 0) return;
    RespawnsLeft--;
    if(SpawnedEnemy)
    {
        SpawnedEnemy->Destroy();
    }
    Fight = NewObject<UFight>(this, UFight::StaticClass());
    Fight->Encounter = this;
    CurrentGameMode = Cast<ADefaultGameMode>(UGameplayStatics::GetGameMode(this));
    if (CurrentGameMode == nullptr) return;
    Fight->CurrentGameMode = CurrentGameMode;
    ADefaultHUD* CurrentHUD = Cast<ADefaultHUD>(GetWorld()->GetFirstPlayerController()->GetHUD());
    Fight->CurrentHUD = CurrentHUD;
    CurrentHUD->ShowInfoText(TEXT("WALKA!"));
    CurrentGameMode->CurrentMode = ECurrentMode::ECM_Combat;

    APlayerController* Controller = GetWorld()->GetFirstPlayerController();
    Fight->Controller = Controller;
    Fight->AddItemClickedEvents();

    Controller->SetViewTargetWithBlend(this, 1.f);
    SpawnEnemyParty();

    SetupAllies();

    SwitchToCombatOverlay();
    Fight->BuildTurnOrder();
    Fight->StartTurn();
    EnableMouseCursor();
    PlayBattleSong();
}

void AFightEncounter::EndFightSuccess()
{
    StopBattleSong();
    PlaySuccessSound();
    CurrentGameMode = Cast<ADefaultGameMode>(UGameplayStatics::GetGameMode(this));
    if (CurrentGameMode)
    {
        if (bIndoors)
        {
            CurrentGameMode->CurrentMode = ECurrentMode::ECM_ExplorationInterior;
        }
        else
        {
            CurrentGameMode->CurrentMode = ECurrentMode::ECM_Exploration;
        }
        SwitchToPartyOverlay();
        ADefaultHUD* CurrentHUD = Cast<ADefaultHUD>(GetWorld()->GetFirstPlayerController()->GetHUD());
        if(!ItemRewardClasses.IsEmpty())
        {
            int32 ItemIndex = FMath::RandRange(0, ItemRewardClasses.Num() - 1);
            ItemReward = NewObject<UItem>(GetOuter(), ItemRewardClasses[ItemIndex]);
            ItemReward->Quantity = 1;
            ItemReward->AddToInventory();
        }
        CurrentGameMode->Money += MoneyReward;
        if (CurrentHUD)
        {
            CurrentHUD->ShowVictoryDialogue(GainedExp, ItemReward, MoneyReward);
        }
        AMainCharacter* MainCharacter = Cast<AMainCharacter>(UGameplayStatics::GetPlayerCharacter(GetWorld(), 0));
        if (MainCharacter == nullptr) return;
        if(MainCharacter->Ult)
        {
            MainCharacter->Ult->bUsable = true;
        }
        APlayerController* Controller = GetWorld()->GetFirstPlayerController();
        Controller->SetViewTargetWithBlend(MainCharacter, 1.f);
        GetWorldTimerManager().SetTimer(FightEndTimer, this, &AFightEncounter::SetupAlliesAfterFightEnd, 1.f);
        OnFightEnded.Broadcast();
    }
}

void AFightEncounter::EndFightFailure()
{
    StopBattleSong();
    ADefaultHUD* CurrentHUD = Cast<ADefaultHUD>(GetWorld()->GetFirstPlayerController()->GetHUD());
    if (CurrentHUD)
    {
        CurrentHUD->ShowGameOverDialogue();
    }
    UGameplayStatics::GetPlayerController(this, 0)->SetPause(true);
    PlayFailSound();
}

void AFightEncounter::SpawnEnemyParty()
{
    FVector Location = GetActorLocation();

    SpawnEnemy(Location, EnemyPartyClassesRankOne);
    OffestEnemySpawnLocation(Location);
    SpawnEnemy(Location, EnemyPartyClassesRankTwo);
    OffestEnemySpawnLocation(Location);
    SpawnEnemy(Location, EnemyPartyClassesRankThree);
    OffestEnemySpawnLocation(Location);
    SpawnEnemy(Location, EnemyPartyClassesRankFour);
    Fight->EnemiesAlive = Fight->EnemyParty.Num();
}

void AFightEncounter::SpawnEnemy(FVector& Location, TArray<TSubclassOf<AEnemy>> EnemyClassArray)
{
    int32 RandomIndex;
    if (!EnemyClassArray.IsEmpty())
    {
        RandomIndex = FMath::RandRange(0, EnemyClassArray.Num()-1);
        FRotator Rotator;
        if (!bUseYAxis)
        {
            Rotator = FRotator(0.f, 180.f, 0.f);
        }
        else
        {
            Rotator = FRotator(0.f, -90.f, 0.f);
        }
        AEnemy* NewEnemy = GetWorld()->SpawnActor<AEnemy>(EnemyClassArray[RandomIndex],
            Location, Rotator);

        //used for melee skills to return to the initial location
        NewEnemy->InitialLocation = Location;
        if(NewEnemy && CurrentGameMode)
        {
            NewEnemy->Attributes->SetLevel(Level);
            CurrentGameMode->InitializeCharacter(NewEnemy, CurrentGameMode->FindEnemy(NewEnemy));
            CurrentGameMode->InitializeEnemySkills(NewEnemy, Level);
            FActorSpawnParameters ControllerSpawnParams;
            ControllerSpawnParams.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
            AAIController* NewAIController = GetWorld()->SpawnActor<AAIController>(AAIController::StaticClass(), NewEnemy->GetActorLocation(), FRotator::ZeroRotator, ControllerSpawnParams);
            NewAIController->Possess(NewEnemy);
            NewEnemy->AIController = NewAIController;
            NewEnemy->DisableSphereCollisions();
            NewEnemy->ShowWidget();
            NewEnemy->ChangeFlipbook(TEXT("IdleCombat"));
            Fight->EnemyParty.Add(NewEnemy);
            NewEnemy->Rank = Fight->EnemyParty.Find(NewEnemy) + 1;
            NewEnemy->OnCharacterHover.AddDynamic(Fight, &UFight::HandleOnCharacterHover);
            NewEnemy->OnCharacterEndHover.AddDynamic(Fight, &UFight::HandleOnCharacterEndHover);
            NewEnemy->OnCharacterClicked.AddDynamic(Fight, &UFight::HandleOnCharacterClicked);
            NewEnemy->OnTargetReached.AddDynamic(Fight, &UFight::HandleOnTargetReached);
            NewEnemy->OnLocationReached.AddDynamic(Fight, &UFight::HandleOnLocationReached);
            NewEnemy->OnCharacterDeath.AddDynamic(Fight, &UFight::HandleOnCharacterDeath);
        }
    }
}

void AFightEncounter::SetupAllies()
{
    Fight->AlliedParty.Empty();
    if (CurrentGameMode == nullptr) return;
    Fight->AlliedParty = CurrentGameMode->AlliedParty;
    Fight->AlliesAlive = Fight->AlliedParty.Num();
    AMainCharacter* MainCharacter = Cast<AMainCharacter>(UGameplayStatics::GetPlayerCharacter(GetWorld(), 0));
    if (MainCharacter)
    {
        MainCharacter->SetControllerRotation(GetActorRotation());
        MainCharacter->SetActorRotation(FRotator::ZeroRotator);
        MainCharacter->Flip(false);
        if (MainCharacter->Ult && (MainCharacter->Attributes == nullptr || MainCharacter->Attributes->GetRage() < MainCharacter->Attributes->GetMaxRage()))
        {
            MainCharacter->Ult->bUsable = false;
        }
        else if(MainCharacter->Ult)
        {
            MainCharacter->Ult->bUsable = true;
        }
    }
    FVector Location;
    if(!bUseYAxis)
    {
        Location = GetActorLocation() - FVector(200.f, 0.f, 0.f);
    }
    else
    {
        Location = GetActorLocation() - FVector(0.f, 200.f, 0.f);
    }
    for (AAlly* Ally : CurrentGameMode->AlliedParty)
    {
        Ally->SetActorLocation(Location);
        Ally->InitialLocation = Location;

        Ally->Flip(false);
        Ally->ShowWidget();
        Ally->HideArrow();
        Ally->UpdateEffectIcons();
        Ally->ChangeFlipbook(TEXT("IdleCombat"));
        Ally->OnCharacterHover.AddDynamic(Fight, &UFight::HandleOnCharacterHover);
        Ally->OnCharacterEndHover.AddDynamic(Fight, &UFight::HandleOnCharacterEndHover);
        Ally->OnCharacterClicked.AddDynamic(Fight, &UFight::HandleOnCharacterClicked);
        Ally->OnTargetReached.AddDynamic(Fight, &UFight::HandleOnTargetReached);
        Ally->OnLocationReached.AddDynamic(Fight, &UFight::HandleOnLocationReached);
        Ally->OnCharacterDeath.AddDynamic(Fight, &UFight::HandleOnCharacterDeath);
        OffsetAllyLocation(Location);
    }
}

void AFightEncounter::OffsetAllyLocation(FVector& Location)
{
    if (bUseYAxis)
    {
        Location.Y -= 100.f;
        return;
    }
    Location.X -= 100.f;
}

void AFightEncounter::OffestEnemySpawnLocation(FVector& Location)
{
    if (bUseYAxis)
    {
        Location.Y += 100.f;
        return;
    }
    Location.X += 100.f;
}

void AFightEncounter::SetupAlliesAfterFightEnd()
{
    if (CurrentGameMode == nullptr) return;
    for (AAlly* Ally : CurrentGameMode->AlliedParty)
    {
        Ally->Turn = 0;
        Ally->HideWidget();
        Ally->ChangeFlipbook(TEXT("Idle"));
        if (Ally->ActorHasTag(FName("Dead")))
        {
            Ally->bIsAlive = true;
            Ally->Tags.Remove(FName("Dead"));
            Ally->Attributes->SetHealth(Ally->Attributes->GetMaxHealth() / 2.f);
        }
        int32 AllyExp = Ally->GetExperience();
        Ally->SetExperience(AllyExp + GainedExp);
    }
    for (AAlly* Ally : CurrentGameMode->AvailableAllies)
    {
        if (!CurrentGameMode->AlliedParty.Contains(Ally))
        {
            int32 AllyExp = Ally->GetExperience();
            Ally->SetExperience(AllyExp + (GainedExp/2));
        }
    }
}

void AFightEncounter::PlayBattleSong()
{
    if (BattleSongs.IsEmpty()) return;
    USoundBase* BattleSong = BattleSongs[FMath::RandRange(0, BattleSongs.Num() - 1)];
    if(BattleSong)
    {
        MusicPlayer->SetSound(BattleSong);
        MusicPlayer->Play();
    }
}

void AFightEncounter::StopBattleSong()
{
    if (MusicPlayer->IsPlaying())
    {
        MusicPlayer->Stop();
    }
}

void AFightEncounter::PlaySuccessSound()
{
    if (SuccessSound)
    {
        UGameplayStatics::PlaySound2D(this, SuccessSound);
    }
}

void AFightEncounter::PlayFailSound()
{
    if (FailSound)
    {
        UGameplayStatics::PlaySound2D(this, FailSound);
    }
}

void AFightEncounter::SwitchToCombatOverlay()
{
    ADefaultHUD* CurrentHUD = Cast<ADefaultHUD>(GetWorld()->GetFirstPlayerController()->GetHUD());
    if (CurrentHUD)
    {
        CurrentHUD->SwitchToCombatOverlay();
    }
    if (Fight && CurrentHUD && CurrentHUD->CombatOverlay)
    {
        CurrentHUD->CombatOverlay->OnEndTurnButtonClicked.AddDynamic(Fight, &UFight::HandleOnEndTurnButtonClicked);
    }
}

void AFightEncounter::SwitchToPartyOverlay()
{
    ADefaultHUD* CurrentHUD = Cast<ADefaultHUD>(GetWorld()->GetFirstPlayerController()->GetHUD());
    if (CurrentHUD)
    {
        CurrentHUD->SwitchToPartyOverlay();
    }
}

void AFightEncounter::EnableMouseCursor()
{
    GetWorld()->GetFirstPlayerController()->bShowMouseCursor = true;
}

void AFightEncounter::DisableMouseCursor()
{
    GetWorld()->GetFirstPlayerController()->bShowMouseCursor = false;
}