[Перевод] Создаем разрушаемые объекты в Unreal Engine 4 и Blender

ADestroyable::ADestroyable()
{
    PrimaryActorTick.bCanEverTick = false; //отключаем Tick
    bDestroyed = false; 

    RootScene = CreateDefaultSubobject(TEXT("RootComp")); // корневая сцена, где все содержится
    RootScene->SetMobility(EComponentMobility::Static);
    RootComponent = RootScene;

    Mesh = CreateDefaultSubobject(TEXT("BaseMeshComp")); // базовая сетка
    Mesh->SetMobility(EComponentMobility::Static);
    Mesh->SetupAttachment(RootScene);

    Collision = CreateDefaultSubobject(TEXT("CollisionComp")); // столкновения, зависящие от пересечений объектов
    Collision->SetMobility(EComponentMobility::Static);
    Collision->SetupAttachment(Mesh);

    OverlapWithNearDestroyable = CreateDefaultSubobject(TEXT("OverlapWithNearDestroyableComp")); // столкновения, ищущие разрушаемые объекты поблизости
    OverlapWithNearDestroyable->SetMobility(EComponentMobility::Static);
    OverlapWithNearDestroyable->SetupAttachment(Mesh);

    Force = CreateDefaultSubobject(TEXT("RadialForceComp")); // составляющая силы для добавления импульса при разрушении
    Force->SetMobility(EComponentMobility::Static);
    Force->SetupAttachment(RootScene);
    Force->Radius = 100.f;
    Force->bImpulseVelChange = true;
    Force->AddCollisionChannelToAffect(ECC_WorldDynamic);

    /* установка столкновений */
    Mesh->SetCollisionObjectType(ECC_WorldDynamic);
    Mesh->SetCollisionEnabled(ECollisionEnabled::QueryAndPhysics);
    Mesh->SetCollisionResponseToAllChannels(ECR_Block);
    Mesh->SetCollisionResponseToChannel(ECC_Visibility, ECR_Ignore);
    Mesh->SetCollisionResponseToChannel(ECC_Camera, ECR_Ignore);
    Mesh->SetCollisionResponseToChannel(ECC_CameraFadeOverlap, ECR_Overlap);
    Mesh->SetCollisionResponseToChannel(ECC_Interaction, ECR_Ignore);
    Mesh->SetCanEverAffectNavigation(false);

    Collision->SetBoxExtent(FVector(50.f, 50.f, 50.f));
    Collision->SetCollisionObjectType(ECC_WorldDynamic);
    Collision->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
    Collision->SetCollisionResponseToAllChannels(ECR_Ignore);
    Collision->SetCollisionResponseToChannel(ECC_Melee, ECR_Overlap);
    Collision->SetCollisionResponseToChannel(ECC_Pawn, ECR_Overlap);
    Collision->SetCollisionResponseToChannel(ECC_Projectile, ECR_Overlap);
    Collision->SetCanEverAffectNavigation(false); 

    Collision->OnComponentBeginOverlap.AddDynamic(this, &ADestroyable::OnBeginOverlap);
    Collision->OnComponentEndOverlap.AddDynamic(this, &ADestroyable::OnEndOverlap);

    OverlapWithNearDestroyable->SetBoxExtent(FVector(40.f, 40.f, 40.f));
    OverlapWithNearDestroyable->SetCollisionObjectType(ECC_WorldDynamic);
    OverlapWithNearDestroyable->SetCollisionEnabled(ECollisionEnabled::NoCollision); // отключение столкновений, включающихся на один кадр в начале разрушения
    OverlapWithNearDestroyable->SetCollisionResponseToAllChannels(ECR_Ignore);
    OverlapWithNearDestroyable->SetCollisionResponseToChannel(ECC_WorldDynamic, ECR_Overlap);
    OverlapWithNearDestroyable->CanCharacterStepUp(false);
    OverlapWithNearDestroyable->SetCanEverAffectNavigation(false); 
}

void ADestroyable::ConfigureBreakablesOnStart()
{
    Mesh->SetCullDistance(BaseMeshMaxDrawDistance); // кастомная отрисовка расстояний для нашей базовой сетки

    for (UStaticMeshComponent* Comp : GetBreakableComponents()) // выбираем все части 
    {
        Comp->SetCollisionEnabled(ECollisionEnabled::NoCollision); // отключаем столкновения
        Comp->SetCollisionResponseToAllChannels(ECR_Ignore); // отключаем все
        Comp->SetCollisionResponseToChannel(ECC_WorldStatic, ECR_Block);
        Comp->SetMobility(EComponentMobility::Static); // не забываем делать статичным то, что не движется
        Comp->SetHiddenInGame(true); // скрываем части перед разрушением, до него у нас должна отображаться базовая сетка
    }
}

TArray ADestroyable::GetBreakableComponents()
{
    if (BreakableComponents.Num() == 0) // есть ли у нас что-то в кэше?
    {
        TInlineComponentArray ComponentsByClass; //сохраняем все статичные компоненты сетки
        GetComponents(ComponentsByClass);

        TArray ComponentsByTag; // храним все части с тэгом «dest»
        ComponentsByTag.Reserve(ComponentsByClass.Num());
        for (UStaticMeshComponent* Component : ComponentsByClass)
        {
            if (Component->ComponentHasTag(TEXT("dest")))
            {
                ComponentsByTag.Push(Component);
            }
        }
        BreakableComponents = ComponentsByTag; // храним данные для дальнейшего использования
    }
    return BreakableComponents;
}

void ADestroyable::ShowBreakables(FVector DealerLocation, bool ByOtherDestroyable /*= false*/)
{
    float ImpulseStrength = ByOtherDestroyable ? -500.f : -1000.f; // установка мощности импульса
    FVector Impulse = (DealerLocation - GetActorLocation()).GetSafeNormal() * ImpulseStrength; // установка вектора импульса в зависимости от местоположения объекта, от которого он исходит    
for (UStaticMeshComponent* Comp : GetBreakableComponents()) // собираем все части 
    {
        Comp->SetMobility(EComponentMobility::Movable); //включение физики
        FBodyInstance* RootBI = Comp->GetBodyInstance(NAME_None, false);
        if (RootBI)
        {
            RootBI->bGenerateWakeEvents = true; // физика активируется на частях объекта

            if (PartsGenerateHitEvent)
            {
                RootBI->bNotifyRigidBodyCollision = true; // активация события OnComponentHit
                Comp->OnComponentHit.AddDynamic(this, &ADestroyable::OnPartHitCallback); // привязка к компоненту для создания на нем эффектов
            }
        }

        Comp->SetHiddenInGame(false); // показ частей объекта 
        Comp->SetCollisionEnabled(ECollisionEnabled::QueryAndPhysics); // включение столкновений
        Comp->SetSimulatePhysics(true); // включение физики
        Comp->AddImpulse(Impulse, NAME_None, true); // активация импульса 

        if (ByOtherDestroyable)
            Comp->AddAngularImpulseInRadians(Impulse * 5.f); //если разрушение ближайшего объекта вносит вклад в импульс, то учитываем его

        //остановка расстояния для прорисовки частей 
        Comp->SetCullDistance(PartsMaxDrawDistance);

        Comp->OnComponentSleep.AddDynamic(this, &ADestroyable::OnPartPutToSleep); // отключаем физику и делаем мобильность статичной
    }
}

void ADestroyable::Break(AActor* InBreakingActor, bool ByOtherDestroyable /*= false*/)
{
    if (bDestroyed) // объект уже разрушен, ничего больше делать не надо
        return;

    bDestroyed = true;
    Mesh->SetHiddenInGame(true); // скрыть базовую сетку
    Mesh->SetCollisionEnabled(ECollisionEnabled::NoCollision); // отключить столкновения с базовой сеткой
    Collision->SetCollisionEnabled(ECollisionEnabled::NoCollision); // отключить проверки столкновений по перекрытию
    OverlapWithNearDestroyable->SetCollisionEnabled(ECollisionEnabled::NoCollision); 
    ShowBreakables(InBreakingActor->GetActorLocation(), ByOtherDestroyable); // show parts 
    Force->bImpulseVelChange = !ByOtherDestroyable; // отладка компонента силы, если она сбилась другим разрушением
    Force->FireImpulse(); // активация радиальной силы

    /* проверка других разрушаемых объектов */
    OverlapWithNearDestroyable->SetCollisionEnabled(ECollisionEnabled::QueryOnly); // включение столкновений для проверки близлежащих объектов
    TArray OtherOverlapingDestroyables;
    OverlapWithNearDestroyable->GetOverlappingActors(OtherOverlapingDestroyables, ADestroyable::StaticClass()); // получение других объектов в боксе
    for (AActor* OtherActor : OtherOverlapingDestroyables)
    {
        if (OtherActor == this)
            continue;

        if (ADestroyable* OtherDest = Cast(OtherActor))
        {
            if (OtherDest->IsDestroyed()) // проверка, не разрушен ли объект
                continue;

            OtherDest->Break(this, true); // разрушение близлежащего объекта
        }
    }

    OverlapWithNearDestroyable->SetCollisionEnabled(ECollisionEnabled::NoCollision); // отключение столкновений

    GetWorld()->GetTimerManager().SetTimer(ForceSleepTimerHandle, this, &ADestroyable::ForceSleep, FORCESLEEPDELAY, false); // переход в состояние сна, если в физике не случилось никаких событий
    
    if(bDestroyAfterDelay)
        GetWorld()->GetTimerManager().SetTimer(DestroyAfterBreakTimerHandle, this, &ADestroyable::DestroyAfterBreaking, DESTROYACTORDELAY, false); // установка таймера для проверки, можно ли уничтожить всего актера

    OnBreakBP(InBreakingActor, ByOtherDestroyable); // blueprint отвечает за аудиовизуальные эффекты
}

void ADestroyable::OnPartPutToSleep(UPrimitiveComponent* InComp, FName InBoneName)
{
    InComp->SetSimulatePhysics(false); // отключение физики 
    InComp->SetCollisionEnabled(ECollisionEnabled::NoCollision); // отключение столкновений
    InComp->SetMobility(EComponentMobility::Static); // с этого момента сделать деталь статичной
    /* теперь деталь статична и не взаимодействует с миром */
}

void ADestroyable::DestroyAfterBreaking()
{
    if (IsPlayerNear()) // проверка того, находится ли игрок поблизости
    {
        //повторить проверку позже
        GetWorld()->GetTimerManager().SetTimer(DestroyAfterBreakTimerHandle, this, &ADestroyable::DestroyAfterBreaking, DESTROYACTORDELAY, false);
    }
    else
    {
        GetWorld()->GetTimerManager().ClearTimer(DestroyAfterBreakTimerHandle); // сброс таймера
        Destroy(); // разрушение актера сцены
    }
}

import unreal as ue

asset_registry = ue.AssetRegistryHelpers.get_asset_registry()
all_assets = asset_registry.get_assets_by_path('/Game/Blueprints/Actors/Destroyables', recursive=True) #здесь хранятся все blueprints разрушаемых объектов
for asset in all_assets:
    path = asset.object_path
    bp_gc = ue.EditorAssetLibrary.load_blueprint_class(path) #get blueprint class
    bp_cdo = ue.get_default_object(bp_gc) # get the Class Default Object (CDO) of the generated class
    if bp_cdo.mesh.static_mesh != None:
        ue.EditorStaticMeshLibrary.set_allow_cpu_access(bp_cdo.mesh.static_mesh, True) # sets allow cpu on static mesh