World.h

#pragma once
 
#include "krpch.h"
 
#include "Object.h"
#include "SubClassOf.h"
 
namespace Karma
{
    class AActor;
    class FTransform;
    struct FActorSpawnParameters;
    class APawn;
    class ULevel;
    class UClass;
    class UGameInstance;
 
    /* Struct of optional parameters passed to SpawnActor function(s). */
    struct KARMA_API FActorSpawnParameters
    {
        FActorSpawnParameters();
 
        /* A name to assign as the Name of the Actor being spawned. If no value is specified, the name of the spawned Actor will be automatically generated using the form [Class]_[Number]. */
        std::string m_Name;
 
        /* An Actor to use as a template when spawning the new Actor. The spawned Actor will be initialized using the property values of the template Actor. If left NULL the class default object (CDO) will be used to initialize the spawned Actor. */
        AActor* m_Template;
 
        /* The Actor that spawned this Actor. (Can be left as NULL). */
        AActor* m_Owner;
 
        /* The APawn that is responsible for damage done by the spawned Actor. (Can be left as NULL). */
        APawn* m_Instigator;
 
        /* The ULevel to spawn the Actor in, i.e. the Outer of the Actor. If left as NULL the Outer of the Owner is used. If the Owner is NULL the persistent level is used. */
        ULevel* m_OverrideLevel;
 
#if WITH_EDITOR
        /* The UPackage to set the Actor in. If left as NULL the Package will not be set and the actor will be saved in the same package as the persistent level. */
        class   UPackage* OverridePackage;
 
        FGuid   OverrideActorGuid;
#endif
 
        /* The parent component to set the Actor in. */
        class   UChildActorComponent* m_OverrideParentComponent;
 
        // Need physics
        //ESpawnActorCollisionHandlingMethod SpawnCollisionHandlingOverride;
 
    private:
 
        //friend class UPackageMapClient;
 
        /* Is the actor remotely owned. This should only be set true by the package map when it is creating an actor on a client that was replicated from the server. */
        uint8_t m_bRemoteOwned : 1;
 
    public:
 
        /* Modes that SpawnActor can use the supplied name when it is not None. */
        enum class ESpawnActorNameMode : uint8_t
        {
            /* Fatal if unavailable, application will assert */
            Required_Fatal,
 
            /* Report an error return null if unavailable */
            Required_ErrorAndReturnNull,
 
            /* Return null if unavailable */
            Required_ReturnNull,
 
            /* If the supplied Name is already in use the generate an unused one using the supplied version as a base */
            Requested
        };
 
        /* In which way should SpawnActor should treat the supplied Name if not none. */
        ESpawnActorNameMode m_NameMode;
 
        /* Flags used to describe the spawned actor/object instance. */
        EObjectFlags m_ObjectFlags;
 
        /* Custom function allowing the caller to specific a function to execute post actor construction but before other systems see this actor spawn. */
        // maybe later
        //TFunction<void(AActor*)> CustomPreSpawnInitalization;
 
        bool IsRemoteOwned() const { return m_bRemoteOwned; }
 
        /* Determines whether spawning will not fail if certain conditions are not met. If true, spawning will not fail because the class being spawned is `bStatic=true` or because the class of the template Actor is not the same as the class of the Actor being spawned. */
        uint8_t m_bNoFail : 1;
 
        /* Determines whether the construction script will be run. If true, the construction script will not be run on the spawned Actor. Only applicable if the Actor is being spawned from a Blueprint. */
        uint8_t m_bDeferConstruction : 1;
    };
 
    class KARMA_API UWorld : public UObject
    {
        DECLARE_KARMA_CLASS(UWorld, UObject)
 
    public:
        UWorld();
 
        AActor* SpawnActor(UClass* Class, FTransform const* Transform, const FActorSpawnParameters& SpawnParameters = FActorSpawnParameters());
 
        template< class T >
        T* SpawnActor(UClass* Class, const FActorSpawnParameters& SpawnParameters = FActorSpawnParameters())
        {
            return CastChecked<T>(SpawnActor(Class, nullptr, SpawnParameters), ECastCheckedType::NullAllowed);
        }
 
        ULevel* GetPersistentLevel() const { return m_PersistentLevel; }
 
        inline void SetGameInstance(UGameInstance* NewGI)
        {
            m_OwningGameInstance = NewGI;
        }
 
    private:
//#if WITH_EDITORONLY_DATA
        ULevel*                             m_CurrentLevel;
//#endif
 
        ULevel*                             m_PersistentLevel;
 
 
        UGameInstance*                      m_OwningGameInstance;
 
        // Time variables
        double m_TimeSeconds;
 
        double m_UnpausedTimeSeconds;
 
        double m_RealTimeSeconds;
 
        double m_AudioTimeSeconds;
 
        float m_DeltaRealTimeSeconds;
 
        float m_DeltaTimeSeconds;
 
        double m_PauseDelay;
 
        bool m_bIsPaused;
 
    public:
        uint8_t m_bIsTearingDown : 1;
 
        //double m_TimeSeconds;
 
        uint8_t m_bActorsInitialized : 1;
 
        uint8_t m_bBegunPlay : 1;
 
        EWorldType::Type m_WorldType;
 
        //TEnumAsByte<ERHIFeatureLevel::Type> FeatureLevel;
 
        struct InitializationValues
        {
            InitializationValues()
                : bInitializeScenes(true)
                , bAllowAudioPlayback(true)
                , bRequiresHitProxies(true)
                , bCreatePhysicsScene(true)
                , bCreateNavigation(true)
                , bCreateAISystem(true)
                , bShouldSimulatePhysics(true)
                , bEnableTraceCollision(false)
                , bForceUseMovementComponentInNonGameWorld(false)
                , bTransactional(true)
                , bCreateFXSystem(true)
                , bCreateWorldPartition(false)
            {
            }
 
            uint32_t bInitializeScenes : 1;
 
            uint32_t bAllowAudioPlayback : 1;
 
            uint32_t bRequiresHitProxies : 1;
 
            uint32_t bCreatePhysicsScene : 1;
 
            uint32_t bCreateNavigation : 1;
 
            uint32_t bCreateAISystem : 1;
 
            uint32_t bShouldSimulatePhysics : 1;
 
            uint32_t bEnableTraceCollision : 1;
 
            uint32_t bForceUseMovementComponentInNonGameWorld : 1;
 
            uint32_t bTransactional : 1;
 
            uint32_t bCreateFXSystem : 1;
 
            uint32_t bCreateWorldPartition : 1;
 
            TSubclassOf<class AGameModeBase> DefaultGameMode;
 
            InitializationValues& InitializeScenes(const bool bInitialize) { bInitializeScenes = bInitialize; return *this; }
            InitializationValues& AllowAudioPlayback(const bool bAllow) { bAllowAudioPlayback = bAllow; return *this; }
            InitializationValues& RequiresHitProxies(const bool bRequires) { bRequiresHitProxies = bRequires; return *this; }
            InitializationValues& CreatePhysicsScene(const bool bCreate) { bCreatePhysicsScene = bCreate; return *this; }
            InitializationValues& CreateNavigation(const bool bCreate) { bCreateNavigation = bCreate; return *this; }
            InitializationValues& CreateAISystem(const bool bCreate) { bCreateAISystem = bCreate; return *this; }
            InitializationValues& ShouldSimulatePhysics(const bool bInShouldSimulatePhysics) { bShouldSimulatePhysics = bInShouldSimulatePhysics; return *this; }
            InitializationValues& EnableTraceCollision(const bool bInEnableTraceCollision) { bEnableTraceCollision = bInEnableTraceCollision; return *this; }
            InitializationValues& ForceUseMovementComponentInNonGameWorld(const bool bInForceUseMovementComponentInNonGameWorld) { bForceUseMovementComponentInNonGameWorld = bInForceUseMovementComponentInNonGameWorld; return *this; }
            InitializationValues& SetTransactional(const bool bInTransactional) { bTransactional = bInTransactional; return *this; }
            InitializationValues& CreateFXSystem(const bool bCreate) { bCreateFXSystem = bCreate; return *this; }
            InitializationValues& CreateWorldPartition(const bool bCreate) { bCreateWorldPartition = bCreate; return *this; }
            InitializationValues& SetDefaultGameMode(TSubclassOf<class AGameModeBase> GameMode) { DefaultGameMode = GameMode; return *this; }
        };
 
        void Tick(/*ELevelTick TickType,*/ float DeltaSeconds);
 
    public:
        // UWorld inlines:
 
        FORCEINLINE double GetTimeSeconds() const
        {
            return m_TimeSeconds;
        }
 
        FORCEINLINE ULevel* GetCurrentLevel() const
        {
            return m_CurrentLevel;
        }
 
    public:
        bool AreActorsInitialized() const;
 
        //void InitializeNewWorld(const InitializationValues IVS = InitializationValues(), bool bInSkipInitWorld = false);
 
        bool HasBegunPlay() const;
 
        static UWorld* CreateWorld(const EWorldType::Type InWorldType, bool bInformEngineOfWorld, const std::string& WorldName = "NoName", UPackage* InWorldPackage = NULL, bool bAddToRoot = true,/* ERHIFeatureLevel::Type InFeatureLevel = ERHIFeatureLevel::Num, const InitializationValues* InIVS = nullptr,*/ bool bInSkipInitWorld = false);
 
        void InitializeNewWorld(const InitializationValues IVS = InitializationValues(), bool bInSkipInitWorld = false);
 
        void InitializeActorsForPlay(const FURL& InURL, bool bResetTime = true/*, FRegisterComponentContext* Context = nullptr*/);
 
        void ModifyLevel(ULevel* Level) const;
 
        bool IsGameWorld() const;
 
        void RemoveActor( AActor* Actor, bool bShouldModifyLevel ) const;
 
        bool ShivaActor(AActor* Actor, bool bNetForce = false, bool bShouldModifyLevel = true);
 
        void AddOnActorSpawnedHandler() const;
        void RemoveOnActorSpawnedHander() const {}
 
        /*mutable FOnActorSpawned*/ void OnActorSpawned();
    };
}