🥮 mooncakes.io
    Sign in

    KKKIIO/selene/event does not have a README file

    EventDomain

    source
    pub(all) enum EventDomain {
      Frame
      Fixed
      Render
    } derive(Eq, 
    Debug    )

    EventReader

    source
    pub(all) struct EventReader[T] {
      last_seen_by_world : Map[UInt, Int]
      marker : T?
    }

    EventReader::EventReader

    source
    fn[T] EventReader::EventReader() -> EventReader[T]

    EventReader::read

    source
    fn[T] EventReader::read(self : EventReader[T], events : Events[T]) -> Array[T]

    EventWorldStore

    source
    type EventWorldStore[T]

    EventWriter

    source
    pub(all) struct EventWriter[T] {
      events : Events[T]
    }

    EventWriter::EventWriter

    source
    fn[T] EventWriter::EventWriter(events : Events[T]) -> EventWriter[T]

    EventWriter::send

    source
    fn[T] EventWriter::send(self : EventWriter[T], event : T) -> Unit

    EventWriter::trigger

    source
    fn[T] EventWriter::trigger(self : EventWriter[T], event : T, target? : 
    Entity    ?) -> Unit

    Events

    source
    pub struct Events[T] {
      id : UInt
      domain : EventDomain
      stores : Map[UInt, EventWorldStore[T]]
      marker : T?
    }

    Events::Events

    source
    fn[T] Events::Events(domain? : EventDomain) -> Events[T]

    Events::clear

    source
    fn[T] Events::clear(self : Events[T]) -> Unit

    Events::dispatch_observers

    source
    fn[T] Events::dispatch_observers(self : Events[T]) -> Unit

    Events::observe_entity

    source
    fn[T] Events::observe_entity(self : Events[T], entity : 
    Entity    , callback : (Trigger[T]) -> Unit) -> ObserverHandle

    Events::observe_global

    source
    fn[T] Events::observe_global(self : Events[T], callback : (Trigger[T]) -> Unit) -> ObserverHandle

    Events::read

    source
    fn[T] Events::read(self : Events[T], reader : EventReader[T]) -> Array[T]

    Events::register_to_world

    source
    fn[T] Events::register_to_world(self : Events[T], world : 
    World    ) -> Unit

    Events::send

    source
    fn[T] Events::send(self : Events[T], event : T) -> Unit

    Events::trigger

    source
    fn[T] Events::trigger(self : Events[T], event : T, target : 
    Entity    ?) -> Unit

    Events::unobserve

    source
    fn[T] Events::unobserve(self : Events[T], handle : ObserverHandle) -> Unit

    Events::update

    source
    fn[T] Events::update(self : Events[T]) -> Unit

    Events::writer

    source
    fn[T] Events::writer(self : Events[T]) -> EventWriter[T]

    ObserverHandle

    source
    pub(all) struct ObserverHandle(Int) derive(Eq, Hash, 
    Debug    )

    Trigger

    source
    pub(all) struct Trigger[T] {
      event : T
      target : 
    Entity    ?
    }

    event_fixed_update_system

    source
    fn event_fixed_update_system(_delta : Double) -> Unit

    event_frame_update_system

    source
    fn event_frame_update_system(_delta : Double) -> Unit

    event_observer_dispatch_system

    source
    fn event_observer_dispatch_system(_delta : Double) -> Unit

    event_render_update_system

    source
    fn event_render_update_system(_delta : Double) -> Unit

    observe_entity

    source
    fn[T] observe_entity(events : Events[T], entity : 
    Entity    , callback : (Trigger[T]) -> Unit) -> ObserverHandle

    observe_global

    source
    fn[T] observe_global(events : Events[T], callback : (Trigger[T]) -> Unit) -> ObserverHandle

    read

    source
    fn[T] read(reader : EventReader[T], events : Events[T]) -> Array[T]

    send

    source
    fn[T] send(events : Events[T], event : T) -> Unit

    trigger

    source
    fn[T] trigger(events : Events[T], event : T, target? : 
    Entity    ?) -> Unit

    unobserve

    source
    fn[T] unobserve(events : Events[T], handle : ObserverHandle) -> Unit

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io