Add prewarm for states

[cyber-yanus]

I have several states that are launched in parallel and work relatively independently of each other.

I don't care about the order of their activation, but I do care about the order of their initialization, because at the moment of initialization we load resources that are displayed in MainCanvas. And I care about the order of these resources in the hierarchy.
I propose to create a prewarm method within StateMachine, which will simply call InitializeSafe();

[bazyleu]

Thanks for reaching out and sharing your questions and suggestions regarding UniState.
Below are some suggestions and clarifications that might help you.

---

1 Parallel Execute calls in the same state machine are not supported

A single IStateMachine may own only one active state chain.
Launching several Execute<TState>() calls on the same instance (even via UniTask.WhenAll) not recommended and with verstion 1.4.0 and above, will raise AlreadyExecutingException.
See API Details → State Machine → State-Machine Specific Exceptions for the exact wording.

---

2 Recommended structure

• Convert the three “independent” pieces into SubStates of one CompositeState.
• Pass shared data through a single payload object so all SubStates receive it automatically.

public sealed class GameplayPayload
{
    public InventoryStatePayload Inventory;
    public EvidenceStatePayload Evidence;
    public ActorsStatePayload Actors;
}

public sealed class GameplayRootState : DefaultCompositeState<GameplayPayload> { }

public sealed class InventoryState   : SubStateBase<GameplayRootState, GameplayPayload> { }
public sealed class EvidenceState    : SubStateBase<GameplayRootState, GameplayPayload> { }
public sealed class ActorsState      : SubStateBase<GameplayRootState, GameplayPayload> { }

---

3 Guaranteeing initialisation order

Option A - dedicated “pre-warm” state

Create a lightweight state that performs the loading in the required order, then transitions to the composite state:

public sealed class GameplayPrewarmState : StateBase<GameplayPayload>
{
    public override async UniTask<StateTransitionInfo> Execute(CancellationToken t)
    {
        await LoadInventory(t);
        await LoadEvidence(t);
        await LoadActors(t);
        return Transition.GoTo<GameplayRootState, GameplayPayload>(Payload);
    }
}

The entry-point now starts with:

await stateMachine.Execute<GameplayPrewarmState>(payload, token);

Option B - synchronisation inside SubStates

Use a shared UniTaskCompletionSource (or any awaitable primitive, in this example InitGate) that the first SubState resolves:

public sealed class InventoryState : SubStateBase<GameplayRootState, GameplayPayload>
{
    private readonly InitGate _initGate;

    InventoryState(InitGate _initGate)
    {
        _initGate = initGate
    }

    public override async UniTask Initialize(CancellationToken t)
    {
        await LoadInventory(t);
        _initGate.Resolve();
    }
}

public sealed class EvidenceState : SubStateBase<GameplayRootState, GameplayPayload>
{
    private readonly InitGate _initGate;

    EvidenceState (InitGate _initGate)
    {
        _initGate = initGate
    }

    public override async UniTask Initialize(CancellationToken t)
    {
        await _initGate.WaitForResolve();
        await LoadEvidence(t);
    }
}

Any SubState that must run after another simply awaits _initGate.WaitForResolve().

---

Summary

• Do not invoke Execute() in parallel on the same state machine.
• Move the three States as SubStates of a CompositeState.
• Control initialisation order either with a preliminary state or with shared awaitable primitive.