Subscribable Utils

Module — 3 files

These files compile together (same module folder).

file_1.verse

# Registers `Callback` to `Subscribable` with `Context` passed as an additional argument.
(Subscribable:subscribable(payload) where payload:type).SubscribeWith<public>(
    Callback:tuple(payload, context) -> void,
    Context:context where context:type
)<transacts>:cancelable =
    Wrapper := wrapper_sub(payload, context):
        Callback := Callback,
        Context := Context
    return Subscribable.Subscribe(Wrapper.InvokeCallback)

# Registers `Callback` to parameterless `Subscribable` with `Context` passed as the only argument.
(Subscribable:subscribable(tuple())).SubscribeEmptyWith<public>(
    Callback:context -> void,
    Context:context where context:type
)<transacts>:cancelable =
    Wrapper := wrapper_sub_empty(context):
        Callback := Callback,
        Context := Context
    return Subscribable.Subscribe(Wrapper.InvokeCallback)

# Registers a suspending `Callback` to `Subscribable`. Each signal spawns a new task.
(Subscribable:subscribable(payload) where payload:type).SubscribeSuspends<public>(
    Callback:type{_(:payload)<suspends>:void}
)<transacts>:cancelable =
    Wrapper:wrapper_sub_suspends_basic(payload) = wrapper_sub_suspends_basic(payload):
        Callback := Callback
    return Subscribable.Subscribe(Wrapper.InvokeCallback)

# Registers a suspending `Callback` to `Subscribable` with `Context` passed as an additional argument. Each signal spawns a new task.
(Subscribable:subscribable(payload) where payload:type).SubscribeSuspendsWith<public>(
    Callback:type{_(:tuple(payload, context))<suspends>:void},
    Context:context where context:type
)<transacts>:cancelable =
    Wrapper:wrapper_sub_suspends(payload, context) = wrapper_sub_suspends(payload, context):
        Callback := Callback,
        Context := Context
    return Subscribable.Subscribe(Wrapper.InvokeCallback)

# Registers a suspending `Callback` to parameterless `Subscribable` with `Context` passed as the only argument. Each signal spawns a new task.
(Subscribable:subscribable(tuple())).SubscribeEmptySuspendsWith<public>(
    Callback:type{_(:context)<suspends>:void},
    Context:context where context:type
)<transacts>:cancelable =
    Wrapper := wrapper_sub_empty_suspends(context):
        Callback := Callback
        Context := Context
    return Subscribable.Subscribe(Wrapper.InvokeCallback)

# ─────────────────────────────────────────────────────────────
# Wrappers

wrapper_sub<internal>(payload:type, context:type) := class:
    Callback:tuple(payload, context) -> void
    Context:context
    InvokeCallback(Payload:payload):void = Callback(Payload, Context)

wrapper_sub_empty<internal>(context:type) := class:
    Callback:context -> void
    Context:context
    InvokeCallback():void = Callback(Context)

wrapper_sub_suspends_basic<internal>(payload:type) := class:
    Callback:type{_(:payload)<suspends>:void}
    InvokeCallback(Payload:payload):void = spawn{Callback(Payload)}

wrapper_sub_suspends<internal>(payload:type, context:type) := class:
    Callback:type{_(:tuple(payload, context))<suspends>:void}
    Context:context
    InvokeCallback(Payload:payload):void = spawn{Callback(Payload, Context)}

wrapper_sub_empty_suspends<internal>(context:type) := class:
    Callback:type{_(:context)<suspends>:void}
    Context:context
    InvokeCallback():void = spawn{Callback(Context)}

file_2.verse

subscribes<public> := interface:

    var Subscriptions<private>:[]cancelable = array{}

    AddSubscription<final><public>(InSubscription:cancelable):void =
        set Subscriptions += array{InSubscription}

    AddSubscriptions<final><public>(InSubscriptions:[]cancelable):void =
        set Subscriptions += InSubscriptions

    CancelSubscriptions<final><public>():void =
        for (Subscription : Subscriptions):
            Subscription.Cancel()
        set Subscriptions = array{}

player_manager_component.verse

player_manager_component := class<final_super>(component, subscribes):

    OnSimulate<override>()<suspends>:void =
        if (Playspace := Entity.GetPlayspaceForEntity[]):
            for (Player : Playspace.GetPlayers()):
                spawn. OnPlayerAdded(Player)
                    
            AddSubscriptions of array:
                Playspace.PlayerAddedEvent().SubscribeSuspends(OnPlayerAdded)
                Playspace.PlayerRemovedEvent().Subscribe(OnPlayerRemoved)
    
    OnEndSimulation<override>():void =
        CancelSubscriptions()
    
    OnPlayerAdded(Player:player)<suspends>:void =
        Sleep(Inf)

    OnPlayerRemoved(Player:player):void =
        {}

# ─────────────────────────────────────────────────────────────

npc_manager_component := class<final_super>(component, subscribes):

    @editable
    NPCSpawners:[]npc_spawner_device = array{}

    OnSimulate<override>()<suspends>:void =
        AddSubscriptions of:
            for (Index -> Spawner : NPCSpawners):
                SpawnerTags := Spawner.GetTags()
                
                # 1 additional argument
                # Spawner.SpawnedEvent.SubscribeWith(OnNPCSpawned1, Index)

                # 2 additional arguments
                # Use a tuple to pass multiple arguments as context.
                Spawner.SpawnedEvent.SubscribeWith(OnNPCSpawned2, (Index, SpawnerTags))
    
    OnEndSimulation<override>():void =
        CancelSubscriptions()
    
    OnNPCSpawned1(SpawnedNPC:agent, SpawnerIndex:int):void =
        {}

    # You can destructure tuple parameters directly in the callback parameter list.
    OnNPCSpawned2(SpawnedNPC:agent, (SpawnerIndex:int, SpawnerTags:tag_view)):void =
        {}

Copy-paste each file above is always free.

Subscribable Utils

Comments