AGate.cpp

이 파일의 문서화 페이지로 가기

// Copyright (c) 2025 Doppleddiggong. All rights reserved. Unauthorized copying, modification, or distribution of this file, via any medium is strictly prohibited. Proprietary and confidential.
 
#include "AGate.h"
 
#include "UBroadcastManager.h"
 
#include "Components/BoxComponent.h"
#include "Components/StaticMeshComponent.h"
#include "GameFramework/Pawn.h"
#include "Onepiece/Onepiece.h"
 
AGate::AGate()
{
    RootComp = CreateDefaultSubobject<USceneComponent>(TEXT("Root"));
    RootComponent = RootComp;
    
    BoxCollision = CreateDefaultSubobject<UBoxComponent>(TEXT("BoxCollision"));
    BoxCollision->SetupAttachment(RootComponent);
 
    BoxCollision->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
    BoxCollision->SetCollisionObjectType(ECollisionChannel::ECC_WorldDynamic);
    BoxCollision->SetCollisionResponseToAllChannels(ECollisionResponse::ECR_Ignore);
    BoxCollision->SetCollisionResponseToChannel(ECollisionChannel::ECC_Pawn, ECollisionResponse::ECR_Overlap);
 
    BoxCollision->OnComponentBeginOverlap.AddDynamic(this, &AGate::OnOverlapBegin);
    BoxCollision->OnComponentEndOverlap.AddDynamic(this, &AGate::OnOverlapEnd);
 
    Door_Left = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Door_Left"));
    Door_Left->SetupAttachment(RootComponent);
 
    Door_Right = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Door_Right"));
    Door_Right->SetupAttachment(RootComponent);
 
    bIsOpen = false;
    GateID = -1;
 
    PrimaryActorTick.bCanEverTick = false;
}
 
void AGate::BeginPlay()
{
    Super::BeginPlay();
 
    if (auto EventManager = UBroadcastManager::Get(this))
    {
        EventManager->OnDoorMessage.AddDynamic(this, &AGate::OnDoorMessage);
    }
}
 
void AGate::OnDoorMessage(const int32 InGateID, const bool Open, AActor* EventInstigator)
{
    if ( InGateID != this->GateID)
    {
        // 나한테 명령한거 아님
        return;
    }
 
    if ( Open == this->bIsOpen)
    {
        // 내가 또 해야하는거 아님
        return;
    }
 
    if (Open)
    {
        OpenDoor();
    }
    else
    {
        CloseDoor();
    }
}
 
void AGate::OpenDoor()
{
    if (bIsOpen == true)
        return;
 
    bIsOpen = true;
    PlayOpenDoorAnimation();
}
 
void AGate::CloseDoor()
{
    if (bIsOpen == false)
        return;
    
    bIsOpen = false;
    PlayCloseDoorAnimation();
}
 
bool AGate::IsPlayerActor(const AActor* OtherActor) const
{
    if ( OtherActor == nullptr)
        return false;
 
    if ( OtherActor == this)
        return false;
 
    if ( OtherActor->ActorHasTag(GameTags::Player) == false)
        return false;
 
    return true;
}
 
void AGate::OnOverlapBegin(UPrimitiveComponent* OverlappedComp, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult)
{
    if (IsPlayerActor(OtherActor))
    {
        if ( auto Pawn = Cast<APawn>(OtherActor) )
        {
            if ( OverlappingPawns.Contains(Pawn) == false )
                OverlappingPawns.Add(Pawn);
       }
        
        OpenDoor();
    }
}
 
void AGate::OnOverlapEnd(UPrimitiveComponent* OverlappedComp, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
    if (IsPlayerActor(OtherActor))
    {
        if ( auto Pawn = Cast<APawn>(OtherActor) )
            OverlappingPawns.Remove(Pawn);
 
        if (OverlappingPawns.Num() == 0)
            CloseDoor();
    }
}