> Tickable object

USCTickableObject

Available in: C++ and Blueprint. Abstract, Blueprintable, BlueprintType. Module StillCookingCore, header Objects/SCTickableObject.h. Blueprint category StillCooking|Tickable.

A base class for a UObject that ticks once per frame. It is abstract: you derive from it — in C++, or as a Blueprint child — and put your logic in the Tick event. Ticking does not start in the constructor; it starts when the owner calls Initialize(). The owner takes on two obligations the class does not: holding the object, which never roots itself, and calling Shutdown() before dropping it.

C++. A minimal subclass overrides ReceiveTick_Implementation. The engine-facing interface (IsTickable, GetTickableTickType, GetTickableGameObjectWorld, BeginDestroy, PostInitProperties) is protected; the engine reaches it through base pointers, and a consumer does not call it. IsTickable() is final — it holds the dead-world guard, and a subclass gates its own ticking with EnableTick() / DisableTick() instead of overriding it. GetWorld() is public and returns the cached world after Initialize(); before that it walks the outer chain.

UCLASS()
class UMyTicker : public USCTickableObject
{
    GENERATED_BODY()

protected:
    virtual void ReceiveTick_Implementation(float DeltaTime) override
    {
        // once per frame while initialized and enabled
    }
};

UCLASS()
class AMyActor : public AActor
{
    GENERATED_BODY()

    UPROPERTY()
    TObjectPtr<UMyTicker> Ticker;

    virtual void BeginPlay() override
    {
        Super::BeginPlay();
        Ticker = NewObject<UMyTicker>(this);   // the actor's outer chain reaches the world
        Ticker->Initialize();
    }

    virtual void EndPlay(const EEndPlayReason::Type Reason) override
    {
        if (Ticker) { Ticker->Shutdown(); }
        Super::EndPlay(Reason);
    }
};

Lifecycle

Tick control

Properties

TickInterval is private in C++ and editable in a Blueprint child’s class defaults; at runtime, read it with GetTickInterval() and write it with SetTickInterval().

Set bStartTickingOnInitialize in class defaults, not on a live object. The object copies it into its tick intent once, while its properties are initialized during NewObject, and Initialize() applies that copy. Assigning the property in C++ after NewObject changes nothing until the next Shutdown() copies it again. To change the intent of an existing object, call EnableTick() or DisableTick().

The two engine gates

bTickWhenPaused and bTickInEditor feed the engine’s own tick dispatch, which checks them in a fixed order: editor first, then game world and not paused, then game world and paused and tick-when-paused. bTickInEditor is an or-branch, not a modifier — it bypasses the paused and game-world rules entirely.

The consequence: the engine’s editor flag, GIsEditor, is true for the whole editor process, including a PIE session. So an object with bTickInEditor = true keeps ticking through a PIE pause even with bTickWhenPaused = false. In a packaged build the flag is false, the branch never fires, and the same object obeys the pause and stops. Setting bTickInEditor to get editor-world ticking silently opts the object out of pause handling for the whole editor session.

Without bTickInEditor, an initialized and enabled object in an editor world stays silent.

Events

Messages

Three, each with the object’s name in front. Their exact wording, and what each one means:

Pitfalls

• Do not create the object in the Construction Script. Create it in BeginPlay.
• bTickInEditor changes pause behaviour in PIE — see above.
• IsTickable() and the rest of the engine-facing interface are protected. Code that calls them on this class does not compile; the engine reaches them through base pointers.
• TickInterval is private — read it with GetTickInterval().