데이터 바인딩과 HUD 시스템

#pragma once

#include "CoreMinimal.h"
#include "Blueprint/UserWidget.h"
#include "MyPlayerHUD.generated.h"

// 필요한 UMG 위젯 클래스 포워드 선언
class UProgressBar;
class UTextBlock;

UCLASS()
class MYPROJECT_API UMyPlayerHUD : public UUserWidget
{
    GENERATED_BODY()

public:
    // UMG 디자이너에서 위젯 이름과 정확히 일치하는 이름으로 IsVariable 체크된 위젯을 만드세요.
    UPROPERTY(meta = (BindWidget))
    UProgressBar* HealthProgressBar; // 체력 바

    UPROPERTY(meta = (BindWidget))
    UTextBlock* AmmoCountText; // 탄약 수 텍스트

    // HUD를 업데이트할 C++ 함수 (플레이어 컨트롤러에서 호출)
    UFUNCTION(BlueprintCallable, Category = "HUD")
    void UpdateHealth(float CurrentHealth, float MaxHealth);

    UFUNCTION(BlueprintCallable, Category = "HUD")
    void UpdateAmmo(int32 CurrentAmmo, int32 MaxAmmo);

protected:
    virtual void NativeConstruct() override; // 화면 구성 시 임시 표시 설정
};

#include "MyPlayerHUD.h"
#include "Components/ProgressBar.h" // UProgressBar 헤더
#include "Components/TextBlock.h"   // UTextBlock 헤더

void UMyPlayerHUD::NativeConstruct()
{
    Super::NativeConstruct();

    // 임시 표시 설정 (캐릭터의 현재값은 컨트롤러에서 전달)
    if (HealthProgressBar)
    {
        HealthProgressBar->SetPercent(1.0f); // 현재값을 받기 전 임시 표시
    }
    if (AmmoCountText)
    {
        AmmoCountText->SetText(FText::FromString(TEXT("Ammo: 0/0"))); // 임시 텍스트
    }
}

void UMyPlayerHUD::UpdateHealth(float CurrentHealth, float MaxHealth)
{
    if (HealthProgressBar)
    {
        // 체력 비율 계산 및 설정 (0.0 ~ 1.0)
        const float Percent = MaxHealth > 0.0f ? FMath::Clamp(CurrentHealth / MaxHealth, 0.0f, 1.0f) : 0.0f;
        HealthProgressBar->SetPercent(Percent);
    }
}

void UMyPlayerHUD::UpdateAmmo(int32 CurrentAmmo, int32 MaxAmmo)
{
    if (AmmoCountText)
    {
        // 탄약 텍스트 업데이트
        FText AmmoDisplay = FText::Format(FText::FromString(TEXT("Ammo: {0}/{1}")),
                                        FText::AsNumber(CurrentAmmo),
                                        FText::AsNumber(MaxAmmo));
        AmmoCountText->SetText(AmmoDisplay);
    }
}

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/PlayerController.h"
#include "MyPlayerController.generated.h"

class UMyPlayerHUD; // 우리가 만든 HUD 위젯 C++ 클래스 선언

UCLASS()
class MYPROJECT_API AMyPlayerController : public APlayerController
{
    GENERATED_BODY()

public:
    AMyPlayerController();

protected:
    virtual void BeginPlay() override;
    virtual void OnPossess(APawn* InPawn) override;

    // 현재 소유한 캐릭터의 값을 HUD에 복사
    void SyncHUDFromPawn();

    // 블루프린트에서 할당할 HUD 위젯 블루프린트 클래스
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "UI")
    TSubclassOf<UMyPlayerHUD> PlayerHUDClass; // UMyPlayerHUD를 상속받는 블루프린트만 할당 가능

    // 생성된 HUD 위젯 인스턴스를 유지하는 참조
    UPROPERTY()
    UMyPlayerHUD* PlayerHUD; // 캐스팅이 필요 없는 UMyPlayerHUD 타입으로 저장

public:
    // 캐릭터의 체력 업데이트를 HUD에 알리는 함수 (캐릭터에서 호출)
    UFUNCTION(BlueprintCallable, Category = "UI")
    void OnHealthChanged(float CurrentHealth, float MaxHealth);

    // 캐릭터의 탄약 업데이트를 HUD에 알리는 함수 (캐릭터에서 호출)
    UFUNCTION(BlueprintCallable, Category = "UI")
    void OnAmmoChanged(int32 CurrentAmmo, int32 MaxAmmo);
};

#include "MyPlayerController.h"
#include "MyPlayerHUD.h" // 우리가 만든 HUD 위젯 C++ 클래스 헤더 포함
#include "MyCharacter.h"

AMyPlayerController::AMyPlayerController()
{
    // ... 기존 생성자 코드 ...
}

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

    // 로컬 컨트롤러에서만 HUD 생성
    if (!IsLocalController()) return;

    // HUD 위젯 생성 및 화면에 추가
    if (PlayerHUDClass)
    {
        PlayerHUD = CreateWidget<UMyPlayerHUD>(this, PlayerHUDClass);
        if (PlayerHUD)
        {
            PlayerHUD->AddToViewport();
            SyncHUDFromPawn();
            UE_LOG(LogTemp, Warning, TEXT("Player HUD created and added to viewport."));
        }
        else
        {
            UE_LOG(LogTemp, Error, TEXT("Failed to create Player HUD."));
        }
    }
    else
    {
        UE_LOG(LogTemp, Warning, TEXT("PlayerHUDClass is not set in PlayerController."));
    }
}

void AMyPlayerController::OnPossess(APawn* InPawn)
{
    Super::OnPossess(InPawn);
    SyncHUDFromPawn();
}

void AMyPlayerController::SyncHUDFromPawn()
{
    if (!IsLocalController() || !IsValid(PlayerHUD)) return;

    const AMyCharacter* Character = Cast<AMyCharacter>(GetPawn());
    if (!IsValid(Character)) return;

    PlayerHUD->UpdateHealth(Character->GetCurrentHealth(), Character->GetMaxHealth());
    PlayerHUD->UpdateAmmo(Character->GetCurrentAmmo(), Character->GetMaxAmmo());
}

void AMyPlayerController::OnHealthChanged(float CurrentHealth, float MaxHealth)
{
    if (PlayerHUD)
    {
        PlayerHUD->UpdateHealth(CurrentHealth, MaxHealth);
    }
}

void AMyPlayerController::OnAmmoChanged(int32 CurrentAmmo, int32 MaxAmmo)
{
    if (PlayerHUD)
    {
        PlayerHUD->UpdateAmmo(CurrentAmmo, MaxAmmo);
    }
}

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "MyCharacter.generated.h"

UCLASS()
class MYPROJECT_API AMyCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    AMyCharacter();

protected:
    virtual void BeginPlay() override;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
    float MaxHealth = 100.0f;

    UPROPERTY(VisibleAnywhere, BlueprintReadWrite, Category = "Stats")
    float CurrentHealth; // 현재 체력

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Combat")
    int32 MaxAmmo = 30;

    UPROPERTY(VisibleAnywhere, BlueprintReadWrite, Category = "Combat")
    int32 CurrentAmmo; // 현재 탄약

    // AActor에서 상속받은 데미지 처리 함수를 캐릭터에서 오버라이드
    virtual float TakeDamage(float DamageAmount, struct FDamageEvent const& DamageEvent, AController* EventInstigator, AActor* DamageCauser) override;

    // 탄약을 발사하는 예시 함수
    UFUNCTION(BlueprintCallable, Category = "Combat")
    void Fire();

public:
    // 아래 대안의 블루프린트 바인딩에서도 읽을 수 있는 getter
    UFUNCTION(BlueprintPure, Category = "Stats")
    float GetCurrentHealth() const { return CurrentHealth; }
    UFUNCTION(BlueprintPure, Category = "Stats")
    float GetMaxHealth() const { return MaxHealth; }
    UFUNCTION(BlueprintPure, Category = "Combat")
    int32 GetCurrentAmmo() const { return CurrentAmmo; }
    UFUNCTION(BlueprintPure, Category = "Combat")
    int32 GetMaxAmmo() const { return MaxAmmo; }
};

#include "MyCharacter.h"
#include "MyPlayerController.h" // 플레이어 컨트롤러 헤더
#include "GameFramework/PlayerController.h" // APlayerController 기본 헤더

AMyCharacter::AMyCharacter()
{
    PrimaryActorTick.bCanEverTick = true;
    CurrentHealth = MaxHealth; // 초기 체력 설정
    CurrentAmmo = MaxAmmo;     // 초기 탄약 설정
}

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

    // 블루프린트/인스턴스의 최대값이 적용된 뒤 현재값 초기화
    CurrentHealth = MaxHealth;
    CurrentAmmo = MaxAmmo;

    // 게임 시작 시 HUD에 초기 체력/탄약 정보 전달
    AMyPlayerController* PC = Cast<AMyPlayerController>(GetController());
    if (PC)
    {
        PC->OnHealthChanged(CurrentHealth, MaxHealth);
        PC->OnAmmoChanged(CurrentAmmo, MaxAmmo);
    }
}

float AMyCharacter::TakeDamage(float DamageAmount, FDamageEvent const& DamageEvent, AController* EventInstigator, AActor* DamageCauser)
{
    float ActualDamage = Super::TakeDamage(DamageAmount, DamageEvent, EventInstigator, DamageCauser);

    CurrentHealth = FMath::Clamp(CurrentHealth - ActualDamage, 0.0f, MaxHealth);
    UE_LOG(LogTemp, Warning, TEXT("Character took %f damage. Current Health: %f"), ActualDamage, CurrentHealth);

    // 체력 변경 시 HUD에 알림
    AMyPlayerController* PC = Cast<AMyPlayerController>(GetController());
    if (PC)
    {
        PC->OnHealthChanged(CurrentHealth, MaxHealth);
    }

    if (CurrentHealth <= 0)
    {
        UE_LOG(LogTemp, Warning, TEXT("Character Died!"));
        // 사망 처리 로직
    }
    return ActualDamage;
}

void AMyCharacter::Fire()
{
    if (CurrentAmmo > 0)
    {
        CurrentAmmo--;
        UE_LOG(LogTemp, Warning, TEXT("Fired! Current Ammo: %d"), CurrentAmmo);

        // 탄약 변경 시 HUD에 알림
        AMyPlayerController* PC = Cast<AMyPlayerController>(GetController());
        if (PC)
        {
            PC->OnAmmoChanged(CurrentAmmo, MaxAmmo);
        }
        // ... 총알 발사 로직 ...
    }
    else
    {
        UE_LOG(LogTemp, Warning, TEXT("No Ammo!"));
    }
}