🥮 mooncakes.io
    Sign in

    Milky2018/mgstudio/core does not have a README file

    Tick

    source
    type Tick = Int

    ChangeTickWorld

    source
    pub(open) trait ChangeTickWorld {
      read_change_tick(self : Self) -> Int
      increment_change_tick(self : Self) -> Int
    }

    SpawnWorld

    source
    pub(open) trait SpawnWorld {
      spawn_empty(self : Self) -> Entity
      despawn(self : Self, entity : Entity) -> Unit raise EntityError
    }

    Minimal trait for worlds that can spawn/despawn entities.

    This is used by engine helpers that are generic over a generated World type, without depending on a concrete ecs_world package (avoids cycles).

    SystemContextWorld

    source
    pub(open) trait SystemContextWorld {
      get_system_context(self : Self) -> SystemContext
      set_system_context(self : Self, ctx : SystemContext) -> Unit
    }

    EntityError

    source
    pub(all) suberror EntityError {
      InvalidId(Int)
      NotSpawned(Entity)
      GenerationMismatch(Entity, Int)
    }

    ComponentStore

    source
    pub struct ComponentStore[T] {
      storage : SparseSet[T]
      ticks : Array[ComponentTicks]
    }

    ComponentStore::contains

    source
    fn[T] ComponentStore::contains(self : ComponentStore[T], entity : Entity) -> Bool

    ComponentStore::for_each

    source
    fn[T] ComponentStore::for_each(self : ComponentStore[T], f : (Entity, T) -> Unit) -> Unit

    ComponentStore::for_each_added

    source
    fn[T] ComponentStore::for_each_added(self : ComponentStore[T], system : SystemTicks, f : (Entity, T) -> Unit) -> Unit

    ComponentStore::for_each_changed

    source
    fn[T] ComponentStore::for_each_changed(self : ComponentStore[T], system : SystemTicks, f : (Entity, T) -> Unit) -> Unit

    ComponentStore::get

    source
    fn[T] ComponentStore::get(self : ComponentStore[T], entity : Entity) -> T?

    ComponentStore::get_ticks

    source
    fn[T] ComponentStore::get_ticks(self : ComponentStore[T], entity : Entity) -> ComponentTicks?

    ComponentStore::insert

    source
    fn[T] ComponentStore::insert(self : ComponentStore[T], entity : Entity, value : T, change_tick : Int) -> Unit

    ComponentStore::len

    source
    fn[T] ComponentStore::len(self : ComponentStore[T]) -> Int

    ComponentStore::new

    source
    fn[T] ComponentStore::new() -> ComponentStore[T]

    ComponentStore::remove

    source
    fn[T] ComponentStore::remove(self : ComponentStore[T], entity : Entity) -> T?

    ComponentStore::set

    source
    fn[T] ComponentStore::set(self : ComponentStore[T], entity : Entity, value : T, change_tick : Int) -> Bool

    ComponentTicks

    source
    pub struct ComponentTicks {
      added : Int
      changed : Int
    }

    ComponentTicks::is_added

    source
    fn ComponentTicks::is_added(self : ComponentTicks, system : SystemTicks) -> Bool

    ComponentTicks::is_changed

    source
    fn ComponentTicks::is_changed(self : ComponentTicks, system : SystemTicks) -> Bool

    ComponentTicks::new

    source
    fn ComponentTicks::new(change_tick : Int) -> ComponentTicks

    ComponentTicks::set_changed

    source
    fn ComponentTicks::set_changed(self : ComponentTicks, change_tick : Int) -> Unit

    Entities

    source
    type Entities

    Entities::despawn

    source
    fn Entities::despawn(self : Entities, entity : Entity) -> Unit raise EntityError

    Entities::is_alive

    source
    fn Entities::is_alive(self : Entities, entity : Entity) -> Bool

    Entities::len

    source
    fn Entities::len(self : Entities) -> Int

    Entities::new

    source
    fn Entities::new() -> Entities

    Entities::spawn

    source
    fn Entities::spawn(self : Entities) -> Entity

    Entity

    source
    pub struct Entity {
      id : Int
      generation : Int
    }

    Entity::is_placeholder

    source
    fn Entity::is_placeholder(self : Entity) -> Bool

    Entity::new

    source
    fn Entity::new(id : Int, generation : Int) -> Entity

    Entity::placeholder

    source
    fn Entity::placeholder() -> Entity

    Resource

    source
    pub struct Resource[T] {
      cell : Ref[T]?
      ticks : ComponentTicks
    }

    Resource::get

    source
    fn[T] Resource::get(self : Resource[T]) -> T?

    Resource::get_ref

    source
    fn[T] Resource::get_ref(self : Resource[T]) -> Ref[T]?

    Resource::get_ref_mut

    source
    fn[T] Resource::get_ref_mut(self : Resource[T], change_tick : Int) -> Ref[T]?

    Resource::insert

    source
    fn[T] Resource::insert(self : Resource[T], value : T, change_tick : Int) -> Unit

    Resource::is_present

    source
    fn[T] Resource::is_present(self : Resource[T]) -> Bool

    Resource::new

    source
    fn[T] Resource::new() -> Resource[T]

    Resource::remove

    source
    fn[T] Resource::remove(self : Resource[T]) -> T?

    Resource::ticks

    source
    fn[T] Resource::ticks(self : Resource[T]) -> ComponentTicks

    SparseSet

    source
    type SparseSet[T]

    SparseSet::contains

    source
    fn[T] SparseSet::contains(self : SparseSet[T], entity : Entity) -> Bool

    SparseSet::entity_at

    source
    fn[T] SparseSet::entity_at(self : SparseSet[T], dense_index : Int) -> Entity

    SparseSet::get

    source
    fn[T] SparseSet::get(self : SparseSet[T], entity : Entity) -> T?

    SparseSet::index_of

    source
    fn[T] SparseSet::index_of(self : SparseSet[T], entity : Entity) -> Int?

    SparseSet::insert

    source
    fn[T] SparseSet::insert(self : SparseSet[T], entity : Entity, value : T) -> Unit

    SparseSet::is_empty

    source
    fn[T] SparseSet::is_empty(self : SparseSet[T]) -> Bool

    SparseSet::len

    source
    fn[T] SparseSet::len(self : SparseSet[T]) -> Int

    SparseSet::new

    source
    fn[T] SparseSet::new() -> SparseSet[T]

    SparseSet::remove

    source
    fn[T] SparseSet::remove(self : SparseSet[T], entity : Entity) -> T?

    SparseSet::set

    source
    fn[T] SparseSet::set(self : SparseSet[T], entity : Entity, value : T) -> Bool

    SparseSet::value_at

    source
    fn[T] SparseSet::value_at(self : SparseSet[T], dense_index : Int) -> T

    SystemContext

    source
    pub struct SystemContext {
      last_run : Int
      this_run : Int
    }

    SystemContext::new

    source

    SystemContext::set

    source
    fn SystemContext::set(self : SystemContext, system : SystemTicks) -> Unit

    SystemContext::ticks

    source

    SystemTicks

    source
    pub struct SystemTicks {
      last_run : Int
      this_run : Int
    }

    SystemTicks::new

    source
    fn SystemTicks::new(last_run : Int, this_run : Int) -> SystemTicks

    World

    source
    type World

    World::despawn

    source
    fn World::despawn(self : World, entity : Entity) -> Unit raise EntityError

    World::is_alive

    source
    fn World::is_alive(self : World, entity : Entity) -> Bool

    World::new

    source
    fn World::new() -> World

    World::spawn_empty

    source
    fn World::spawn_empty(self : World) -> Entity

    query2

    source
    fn[A, B] query2(a : ComponentStore[A], b : ComponentStore[B], f : (Entity, A, B) -> Unit) -> Unit

    query2_changed_a

    source
    fn[A, B] query2_changed_a(a : ComponentStore[A], b : ComponentStore[B], system : SystemTicks, f : (Entity, A, B) -> Unit) -> Unit

    with_host_bytes_id

    source
    fn[T] with_host_bytes_id(data : Bytes, f : (Int) -> T) -> T

    with_host_string_id

    source
    fn[T] with_host_string_id(text : String, f : (Int) -> T) -> T

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io