🥮 mooncakes.io
README

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