USaveLoadBPLib Class Reference

#include <SaveLoadBPLib.h>

Inheritance diagram for USaveLoadBPLib:

Static Public Member Functions
static bool	SaveGame (const UObject *WorldContextObject)
static bool	SaveLoadAllComponents (AActor *Actor, const bool bSave=true)
static bool	SaveLoadActor (AActor *Actor, const bool bSave=true)
static bool	LoadPlayer (APlayerState *PlayerState)
static bool	SavePlayer (APlayerState *PlayerState)
static bool	SaveActor (AActor *Actor)
static bool	LoadActor (AActor *Actor)
static bool	SaveAllComponents (AActor *Actor)
static bool	LoadAllComponents (AActor *Actor)
static bool	SaveGameState (const UObject *WorldContextObject, const bool bSave=true)
static bool	SaveGameMode (const UObject *WorldContextObject, const bool bSave=true)
static bool	SaveGameInstance (const UObject *WorldContextObject, const bool bSave=true)
static bool	LoadGame (const UObject *WorldContextObject)

Member Function Documentation

LoadActor()

bool USaveLoadBPLib::LoadActor ( AActor * Actor )

static

{
    return SaveLoadActor(Actor, false);
}

LoadAllComponents()

bool USaveLoadBPLib::LoadAllComponents ( AActor * Actor )

static

Finds All components with the ISaveLoad Interface and loads, Also loads the actor if implements interface

{
    return SaveLoadAllComponents(Actor, false);
}

LoadGame()

bool USaveLoadBPLib::LoadGame ( const UObject * WorldContextObject )

static

{
    if (WorldContextObject == nullptr){UE_LOG(LogSaveLoad, Error, TEXT("WorldContextObject Nullptr"))return false;}
    SaveGameState(WorldContextObject, false);
    SaveGameMode(WorldContextObject, false);
    SaveGameInstance(WorldContextObject, false);
    return true;
}

LoadPlayer()

bool USaveLoadBPLib::LoadPlayer ( APlayerState * PlayerState )

static

{
    if (PlayerState == nullptr){return false;}
    LoadAllComponents(PlayerState);
    LoadActor(PlayerState);
    if (PlayerState->GetPawn() == nullptr){return false;}
    LoadAllComponents(PlayerState->GetPawn());
    LoadActor(PlayerState->GetPawn());
    if (PlayerState->GetOwningController() == nullptr){return false;}
    LoadAllComponents(PlayerState->GetOwningController());
    LoadActor(PlayerState->GetOwningController());
    return true;
}

SaveActor()

bool USaveLoadBPLib::SaveActor ( AActor * Actor )

static

{
    return SaveLoadActor(Actor, true);
}

SaveAllComponents()

bool USaveLoadBPLib::SaveAllComponents ( AActor * Actor )

static

Finds All components with the ISaveLoad Interface and Saves, Also saves the actor if implements interface

{
    return SaveLoadAllComponents(Actor, true);
}

SaveGame()

bool USaveLoadBPLib::SaveGame ( const UObject * WorldContextObject )

static

{
    if (WorldContextObject == nullptr){UE_LOG(LogSaveLoad, Error, TEXT("WorldContextObject Nullptr"))return false;}
    SaveGameState(WorldContextObject);
    SaveGameMode(WorldContextObject);
    SaveGameInstance(WorldContextObject);
    return true;
}

SaveGameInstance()

bool USaveLoadBPLib::SaveGameInstance ( const UObject * WorldContextObject, const bool bSave = true )

static

{
    UGameInstance* GameInstance = WorldContextObject->GetWorld()->GetGameInstance();
    if(GameInstance != nullptr)
    {
        ISaveLoad* SaveGameInstance = Cast<ISaveLoad>(GameInstance);
        if(SaveGameInstance != nullptr)
        {
            if(bSave)
            {
                return SaveGameInstance->SaveGame();
            }
            return SaveGameInstance->LoadGame();
        }
        UE_LOG(LogSaveLoad, Error, TEXT("USaveLoadBPLib::SaveGameInstance GameInstance Doesn't Implement SaveLoad"));
        return false;
    }
    UE_LOG(LogSaveLoad, Warning, TEXT("USaveLoadBPLib::SaveGameInstance GameInstance"));
    return false;
}

SaveGameMode()

bool USaveLoadBPLib::SaveGameMode ( const UObject * WorldContextObject, const bool bSave = true )

static

{
    AGameModeBase* GameMode = UGameplayStatics::GetGameMode(WorldContextObject);
    if(GameMode != nullptr)
    {
        ISaveLoad* SaveGameMode = Cast<ISaveLoad>(GameMode);
        if(SaveGameMode != nullptr)
        {
            if(bSave)
            {
                return SaveGameMode->SaveGame();
            }
            return SaveGameMode->LoadGame();
        }
        UE_LOG(LogSaveLoad, Error, TEXT("USaveLoadBPLib::SaveGameMode Game Mode Doesn't Implement SaveLoad"));
        return false;
    }
    UE_LOG(LogSaveLoad, Warning, TEXT("USaveLoadBPLib::SaveGameMode GameMode"));
    return false;
 
}

SaveGameState()

bool USaveLoadBPLib::SaveGameState ( const UObject * WorldContextObject, const bool bSave = true )

static

{
    AGameStateBase* GameStateBase = UGameplayStatics::GetGameState(WorldContextObject);
    if(GameStateBase != nullptr)
    {
        ISaveLoad* SaveGameState = Cast<ISaveLoad>(GameStateBase);
        if(SaveGameState != nullptr)
        {
            if(bSave)
            {
                return SaveGameState->SaveGame();
            }
            return SaveGameState->LoadGame();
        }
        UE_LOG(LogSaveLoad, Error, TEXT("USaveLoadBPLib::SaveGameState Game State Doesn't Implement SaveLoad"));
        return false;
    }
    UE_LOG(LogSaveLoad, Warning, TEXT("USaveLoadBPLib::SaveGameState GameStateBase"));
    return false;
}

SaveLoadActor()

bool USaveLoadBPLib::SaveLoadActor ( AActor * Actor, const bool bSave = true )

static

{
    if(Actor == nullptr){UE_LOG(LogSaveLoad, Error, TEXT("USaveLoadBPLib::SaveLoadActor Error Saving Actor")); return false;}
    ISaveLoad* SaveActor = Cast<ISaveLoad>(Actor);
    if(SaveActor == nullptr){return false;}
    if(bSave)
    {
        SaveActor->SaveGame();
    }
    else
    {
        SaveActor->LoadGame();
    }
    return true;
}

SaveLoadAllComponents()

bool USaveLoadBPLib::SaveLoadAllComponents ( AActor * Actor, const bool bSave = true )

static

{
    if(Actor == nullptr){UE_LOG(LogSaveLoad, Error, TEXT("USaveLoadBPLib::SaveLoadAllComponents Error Saving Actor")); return false;}
    TArray<UActorComponent*> Components = Actor->GetComponentsByInterface(USaveLoad::StaticClass());
    bool bSuccess = false;
    bool bAllPassed = true;
    for(const auto& Component :Components)
    {
        ISaveLoad* SaveComponent = Cast<ISaveLoad>(Component);
        if (SaveComponent != nullptr)
        {
            if (bSave)
            {
                bSuccess = SaveComponent->SaveGame();
            }
            else
            {
                bSuccess = SaveComponent->LoadGame();
            }
            if (bSuccess == false)
            {
                bAllPassed = false;
                UE_LOG(LogSaveLoad, Error, TEXT("Error Saving Component: %s"), *Component->GetReadableName());
            }
        }
    }
    return bAllPassed;
}

SavePlayer()

bool USaveLoadBPLib::SavePlayer ( APlayerState * PlayerState )

static

{
    if (PlayerState == nullptr){return false;}
    SaveAllComponents(PlayerState);
    SaveActor(PlayerState);
    if (PlayerState->GetPawn() == nullptr){return false;}
    SaveAllComponents(PlayerState->GetPawn());
    SaveActor(PlayerState->GetPawn());
    if (PlayerState->GetOwningController() == nullptr){return false;}
    SaveAllComponents(PlayerState->GetOwningController());
    SaveActor(PlayerState->GetOwningController());
    return true;
}

---

The documentation for this class was generated from the following files:

• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/BaseHelpers/Source/BaseHelpers/Public/BPLib/SaveLoadBPLib.h
• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/BaseHelpers/Source/BaseHelpers/Private/BPLib/SaveLoadBPLib.cpp