インターフェース
で「できること」を約束する

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "Interactable.h"
#include "Door.generated.h"

UCLASS()
class MYGAME_API ADoor : public AActor, public IInteractable
{
    GENERATED_BODY()

public:
    // _Implementation を付けて override する
    virtual void Interact_Implementation(AActor* Interactor) override;
    virtual FText GetInteractionPrompt_Implementation() const override;

protected:
    UPROPERTY(VisibleAnywhere, Category = "Door")
    bool bIsOpen = false;

    UPROPERTY(EditAnywhere, Category = "Door")
    float OpenYaw = 90.f;
};

#include "Door.h"

void ADoor::Interact_Implementation(AActor* Interactor)
{
    bIsOpen = !bIsOpen;
    SetActorRotation(FRotator(0.f, bIsOpen ? OpenYaw : 0.f, 0.f));

    UE_LOG(LogTemp, Log, TEXT("%s opened by %s"),
        *GetName(), *GetNameSafe(Interactor));
}

FText ADoor::GetInteractionPrompt_Implementation() const
{
    return bIsOpen
        ? NSLOCTEXT("Door", "Close", "閉める")
        : NSLOCTEXT("Door", "Open",  "開ける");
}

UINTERFACE(MinimalAPI, BlueprintType)
class UDamageable : public UInterface
{
    GENERATED_BODY()
};

class MYGAME_API IDamageable
{
    GENERATED_BODY()

public:
    UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category = "Combat")
    void ApplyDamage(float Amount, AActor* Causer);

    // 戻り値があっても同じ書き方で使える
    UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category = "Combat")
    bool IsAlive() const;

    // BP に実装を強制したい（C++ 既定を持たない）場合
    UFUNCTION(BlueprintImplementableEvent, Category = "Combat")
    void OnDamageFeedback(float Amount);
};

void AEnemyCharacter::ApplyDamage_Implementation(float Amount, AActor* Causer)
{
    if (!IsAlive_Implementation())
    {
        return;
    }

    Health = FMath::Max(0.f, Health - Amount);
    OnDamageFeedback(Amount);   // BP で実装された演出を呼ぶ

    if (Health <= 0.f)
    {
        Die();
    }
}

bool AEnemyCharacter::IsAlive_Implementation() const
{
    return Health > 0.f;
}

// 呼び出し側（弾丸など）
void AProjectile::OnHit(AActor* Other)
{
    if (Other && Other->Implements<UDamageable>())
    {
        const bool bAlive = IDamageable::Execute_IsAlive(Other);
        if (bAlive)
        {
            IDamageable::Execute_ApplyDamage(Other, Damage, GetOwner());
        }
    }
}

// エディタで「ダメージを受けられるもの」だけ挿せるピンになる
UPROPERTY(EditInstanceOnly, Category = "Combat")
TScriptInterface<IDamageable> DefaultTarget;

void ATurret::Fire()
{
    if (!DefaultTarget)   // UObject 側が有効かを見てくれる
    {
        return;
    }

    // C++ 実装だけを呼ぶ（BP 実装は走らない）
    DefaultTarget->ApplyDamage_Implementation(10.f, this);

    // BP 実装も含めて正しく呼ぶならこちら
    IDamageable::Execute_ApplyDamage(DefaultTarget.GetObject(), 10.f, this);
}

// 性質ごとに 1 枚。名前は形容詞にすると迷いません

UINTERFACE(MinimalAPI, BlueprintType)
class UEquippable : public UInterface { GENERATED_BODY() };

class MYGAME_API IEquippable
{
    GENERATED_BODY()
public:
    UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category = "Item")
    EEquipSlot GetEquipSlot() const;

    UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category = "Item")
    void OnEquipped(APawn* Owner);
};

// --- 使える ---
UINTERFACE(MinimalAPI, BlueprintType)
class UConsumable : public UInterface { GENERATED_BODY() };

class MYGAME_API IConsumable
{
    GENERATED_BODY()
public:
    UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category = "Item")
    void Consume(APawn* User);
};

// --- 売れる ---
UINTERFACE(MinimalAPI, BlueprintType)
class USellable : public UInterface { GENERATED_BODY() };

class MYGAME_API ISellable
{
    GENERATED_BODY()
public:
    UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category = "Item")
    int32 GetSellPrice() const;
};

// IStackable, IQuestItem も同じ形で並べる

// インベントリは AActor* / UObject* のまま持てばよい
UPROPERTY()
TArray<TObjectPtr<AItemBase>> Items;

// カテゴリ = インターフェースで絞り込む（テンプレートで共通化）
template<typename TInterface>
TArray<AItemBase*> UInventoryComponent::FilterByCategory() const
{
    TArray<AItemBase*> Result;
    for (AItemBase* Item : Items)
    {
        if (Item && Item->Implements<TInterface>())
        {
            Result.Add(Item);
        }
    }
    return Result;
}

// 装備タブを開いたとき
void UInventoryComponent::ShowEquipTab()
{
    for (AItemBase* Item : FilterByCategory<UEquippable>())
    {
        const EEquipSlot Slot = IEquippable::Execute_GetEquipSlot(Item);
        AddRow(Item, Slot);
    }
}

// 売却総額。ISellable を実装したものだけが加算される
int32 UInventoryComponent::GetTotalSellValue() const
{
    int32 Total = 0;
    for (AItemBase* Item : Items)
    {
        if (Item && Item->Implements<USellable>())
        {
            Total += ISellable::Execute_GetSellPrice(Item);
        }
    }
    return Total;   // 鍵は売れないので自然に除外される
}

// BP から呼びたいときは UClass* を受ける版を用意する
UFUNCTION(BlueprintCallable, Category = "Inventory",
    meta = (DeterminesOutputType = "Category"))
TArray<AItemBase*> FilterByInterface(TSubclassOf<UInterface> Category) const;

// 親は AItemBase（表示名やアイコンなど、全アイテム共通のものだけ）
// カテゴリは継承ではなくインターフェースで足す

UCLASS()
class AWeaponItem : public AItemBase,
                    public IEquippable, public ISellable
{
    GENERATED_BODY()
public:
    virtual EEquipSlot GetEquipSlot_Implementation() const override
        { return EEquipSlot::MainHand; }

    virtual void OnEquipped_Implementation(APawn* Owner) override;

    virtual int32 GetSellPrice_Implementation() const override
        { return BasePrice * (1.f - Wear); }
};

UCLASS()
class APotionItem : public AItemBase,
                    public IConsumable, public ISellable, public IStackable
{
    GENERATED_BODY()
public:
    virtual void Consume_Implementation(APawn* User) override;
    virtual int32 GetSellPrice_Implementation() const override { return 25; }
    virtual int32 GetMaxStack_Implementation() const override { return 99; }
};

UCLASS()
class AKeyItem : public AItemBase, public IQuestItem
{
    GENERATED_BODY()
    // ISellable を実装しない = 売れない。判定コードは要らない
};

// 魔法の剣を足したいとき（装備できて、使えて、売れる）
UCLASS()
class AEnchantedSword : public AItemBase,
                        public IEquippable, public IConsumable, public ISellable
{
    GENERATED_BODY()
    // 既存クラスの継承ツリーには一切触らない
};

// enum で分類した場合
UENUM(BlueprintType)
enum class EItemCategory : uint8 { Weapon, Armor, Potion, Quest };

void UInventoryComponent::Use(AItemBase* Item)
{
    switch (Item->Category)
    {
    case EItemCategory::Potion: Item->Drink(); break;
    case EItemCategory::Weapon: Item->Equip(); break;
    // 「装備できて飲める剣」を追加した瞬間に破綻する
    // カテゴリを足すたび、全ての switch を探して直す
    }
}