gizgame/game
The productive layer of gizgame: typed components over the World, one Game builder, and one context that systems and drawing share. It adds no second store: every value lives in the World's columns, its snapshot and its replay.
import * as Game from "gizgame/game";Types
Component
class Component<T> { name: string; id: i64 = -1; fields: Vec<Field>; failure: string; private initial: T; private template: bytes; private slots: Vec<Vec<Leaf>>; private marker: bool; constructor(name: string, initial: T, marker: bool = false) { const template = Memory.flatten<T>(initial); const layout = marker ? { fields: [], slots: [], failure: "" }: shape(Memory.describe<T>(), name); this.name = name; this.initial = initial; this.template = template; this.marker = marker; this.fields = layout.fields; this.slots = layout.slots; this.failure = layout.failure; } of(value: T): Data { return { component: this.id, fields: this.marker ? []: this.encode(value) }; } on(): Data { return this.of(this.initial); } value(): T { return this.initial; } encode(value: T): Vec<bytes> { const words = Memory.flatten<T>(value); let out: Vec<bytes> = []; for (const slot of this.slots) { let field = b""; for (const leaf of slot) { const at = leaf.word*8; if (leaf.kind === "f32") { field+ = words.slice(at, at+4); } else if (leaf.kind === "bool") { field+ = words.slice(at, at+1); } else if (leaf.kind === "entity") { const index = words.readU64LE(at); field+ = u64Bytes(index === 18446744073709551615u ? 0u: index+1u); field+ = words.slice(at+16, at+24); } else { field+ = words.slice(at, at+8); } } out.push(field); } return out; } decode(fields: Vec<bytes>): T { if (this.marker) { return this.initial; } let words = this.template; for (const index of range(0, this.slots.length)) { const field = fields[index]; let offset: i64 = 0; for (const leaf of this.slots[index]) { const at = leaf.word*8; if (leaf.kind === "f32") { words.copyFrom(at, field, offset, 4); offset+ = 4; } else if (leaf.kind === "bool") { words.copyFrom(at, field, offset, 1); offset+ = 1; } else if (leaf.kind === "entity") { const stored = field.readU64LE(offset); words.copyFrom(at, u64Bytes(stored === 0u ? 18446744073709551615u: stored-1u), 0, 8); words.copyFrom(at+16, field, offset+8, 8); offset+ = 16; } else { words.copyFrom(at, field, offset, 8); offset+ = 8; } } } return Memory.unflatten<T>(words); } }A typed component: a record type T stored in the World's columns. Its value is T; no bytes reach game code.
Opaque: create and use it through this module's functions.
Mark
type Mark = { on: bool; }A component with no data, which only marks an entity.
on:bool
Pose2D
type Pose2D = { x: f64; y: f64; angle: f64; }Where an entity stands in 2D: logical units, and radians from +X toward +Y.
x:f64y:f64angle:f64
Pose3D
type Pose3D = { x: f64; y: f64; z: f64; yaw: f64; pitch: f64; roll: f64; }Where an entity stands in 3D: Y up; yaw turns about Y, pitch about X, roll about Z, in radians.
x:f64y:f64z:f64yaw:f64pitch:f64roll:f64
Pointer
type Pointer = { x: f64; y: f64; width: f64; height: f64; held: bool; pressed: bool; seen: bool; }The pointer in surface pixels, the surface's size, its main button, and whether it has moved over the surface yet.
x:f64y:f64width:f64height:f64held:boolpressed:boolseen:bool
Stick
type Stick = { x: f64; y: f64; }A stick's direction, each axis in [-1, 1], +Y down as on the screen.
x:f64y:f64
StickKeys
type StickKeys = { left: Vec<string>; right: Vec<string>; up: Vec<string>; down: Vec<string>; pad: i64; }The keys and gamepad axes of a stick. PAD is the gamepad's stick: 0 for the left (axes 0 and 1), 1 for the right.
left:Vec<string>right:Vec<string>up:Vec<string>down:Vec<string>pad:i64
Screen
type Screen = { width: i64; height: i64; alpha: f64; measure: bool; }What to draw: the surface's size, the fraction toward the next tick, and whether the host measures the GPU.
width:i64height:i64alpha:f64measure:bool
Game
class Game { world: World; dt: f64; tick: i64 = 0; alpha: f64 = 1.0; simulation: Simulation | undefined = undefined; private hz: f64; private catchUp: i64; private seed: i64; private failure: string = ""; private rules: Vec<Rule> = []; private setups: Vec<Rule> = []; private actions: Vec<Action> = []; private sticks: Vec<Axis> = []; private sounds: Vec<Cue> = []; private defaults: Vec<Data> = []; private holder: Entity = absent(); private sticksId: i64 = -1; private cuesId: i64 = -1; private heard: Vec<u64> = []; private files = new Map<string, bytes>(); constructor(hz: f64 = 60.0, seed: i64 = 1, catchUp: i64 = 5) { const world = new World(); this.world = world; this.hz = hz; this.dt = 1.0/hz; this.catchUp = catchUp; this.seed = seed; this.use(Transform2D).use(Before2D).use(Transform3D).use(Before3D).use(Engine); } private fail(message: string): void { if (this.failure === "") { this.failure = message; } } use<T>(c: Component<T>): Game { if (c.failure !== "") { this.fail(c.failure); return this; } try { const id = this.world.register({ name: c.name, fields: c.fields }); if (c.id> = 0 && c.id !== id) { throw `Component ${c.name } has another ID in another Game: register in one order`; } c.id = id; } catch (error: string) { this.fail(error); } return this; } resource<T>(c: Component<T>): Game { this.use(c); if (c.id> = 0) { this.defaults.push(c.on()); } return this; } action(name: string, codes: Vec<string>): Game { if (this.actions.length> = 64 || this.actions.some(a => a.name === name)) { this.fail(`Invalid or duplicate action ${name }`); } this.actions.push({ name, codes }); return this; } stick(name: string, keys: StickKeys): Game { if (this.sticks.length> = STICKS/2 || this.sticks.some(s => s.name === name)) { this.fail(`Invalid or duplicate stick ${name }`); } this.sticks.push({ name, keys }); return this; } sound(name: string, gain: f64 = 1.0): Game { this.sounds.push({ name, gain }); return this; } setup(run: (game: Game) => void throws string): Game { this.setups.push({ name: "setup", run }); return this; } system(name: string, run: (game: Game) => void throws string): Game { if (name === "" || name.startsWith("gizgame.") || this.rules.some(r => r.name === name)) { this.fail(`Invalid or duplicate system ${name }`); } this.rules.push({ name, run }); return this; } start(): void throws string { if (this.simulation !== undefined) { return; } if (this.failure !== "") { throw this.failure; } this.sticksId = this.world.register({ name: "gizgame.Sticks", fields: [{ name: "axes", kind: "f64", lanes: STICKS }] }); this.cuesId = this.world.register({ name: "gizgame.Cues", fields: [{ name: "counts", kind: "u64", lanes: Math.maxI64(1, this.sounds.length) }] }); let controls = Engine.value(); controls.dice = u64(Math.maxI64(1, this.seed%4294967296)); let zeros = b""; for (const at of range(0, STICKS)) { writeU64LE(zeros, 0u); } let counts = b""; for (const at of range(0, Math.maxI64(1, this.sounds.length))) { writeU64LE(counts, 0u); } this.holder = this.world.create([Engine.of(controls), { component: this.sticksId, fields: [zeros] }, { component: this.cuesId, fields: [counts] }, ...this.defaults]); let all: Vec<i64> = []; for (const id of range(0, this.world.schema().length)) { all.push(id); } let systems: Vec<System> = [{ name: "gizgame.input", reads: all, writes: all, after: [], incremental: false, structural: true, run: (world: World, tick: i64, seconds: f64, inputs: Vec<Input>): void throws string => { this.enter(tick); this.remember(); this.control(inputs); } }]; let last = "gizgame.input"; for (const rule of this.rules) { systems.push({ name: rule.name, reads: all, writes: all, after: [last], incremental: false, structural: true, run: (world: World, tick: i64, seconds: f64, inputs: Vec<Input>): void throws string => { this.enter(tick); rule.run(this); } }); last = rule.name; } for (const rule of this.setups) { rule.run(this); } this.simulation = new Simulation(this.world, systems, this.hz, this.catchUp); } private enter(tick: i64): void { this.tick = tick; this.alpha = 1.0; } initialize(input: bytes): Screen throws string { this.start(); const options = hostFrame(input); return { width: options.field("width").integer(), height: options.field("height").integer(), alpha: 1.0, measure: false }; } frame(input: bytes): Screen throws string { this.start(); const event = hostFrame(input); const simulation = this.simulation!; simulation.input({ tick: simulation.clock.tick(), sequence: simulation.nextSequence(), payload: input }); const result = simulation.frame(event.field("now").numberOr(0.0), event.field("resumed").boolean()); this.tick = simulation.clock.tick(); this.alpha = result.alpha; return { width: event.field("width").integer(), height: event.field("height").integer(), alpha: result.alpha, measure: event.field("measureGPU").boolean() }; } snapshot(): bytes throws string { this.start(); return this.simulation!.snapshot(); } restore(state: bytes): bytes throws string { this.start(); this.simulation!.restore(state); this.holder = this.first(Engine)!; this.heard = []; this.tick = this.simulation!.clock.tick(); return b""; } cues(): bytes throws string { this.start(); const counts = this.world.read(this.holder, this.cuesId, 0); let out: Vec<string> = []; let now: Vec<u64> = []; for (const at of range(0, this.sounds.length)) { now.push(counts.readU64LE(at*8)); if (this.heard.length> 0 && now[at]> this.heard[at]) { out.push(`{"sound":${quote(this.sounds[at].name) }, "gain": ${ this.sounds[at].gain } }`); } } this.heard = now; return utf8(`[${out.join(",") }]`); } receive(input: bytes): bytes throws string { const end = input.indexOf(b"\n", 0); if (end <1) { throw "A file is NAME, a newline and the bytes"; } this.files.set(string(input.slice(0, end)), input.slice(end+1)); return b""; } file(name: string): bytes throws string { const found = this.files.get(name); if (found === undefined) { throw `The host gave no file ${name }: is it in the assets lock?`; } return found!; } restart(): void throws string { for (const entity of this.world.entities()) { if (!same(entity, this.holder)) { this.world.destroy(entity); } } for (const value of this.defaults) { for (const at of range(0, value.fields.length)) { this.world.write(this.holder, value.component, at, value.fields[at]); } } for (const rule of this.setups) { rule.run(this); } } time(): f64 { return f64(this.tick)*this.dt; } spawn(data: Vec<Data>): Entity throws string { let all = data; for (const item of data) { if (item.component === Transform2D.id && !data.some(d => d.component === Before2D.id)) { all.push({ component: Before2D.id, fields: item.fields }); } if (item.component === Transform3D.id && !data.some(d => d.component === Before3D.id)) { all.push({ component: Before3D.id, fields: item.fields }); } } return this.world.create(all); } despawn(entity: Entity): void throws string { if (this.world.alive(entity)) { this.world.destroy(entity); } } alive(entity: Entity): bool { return this.world.alive(entity); } has<T>(entity: Entity, c: Component<T>): bool throws string { return this.world.has(entity, c.id); } read<T>(entity: Entity, c: Component<T>): T throws string { if (c.fields.length === 0) { if (!this.world.has(entity, c.id)) { throw `Entity has no ${c.name }`; } return c.value(); } let fields: Vec<bytes> = []; for (const at of range(0, c.fields.length)) { fields.push(this.world.read(entity, c.id, at)); } return c.decode(fields); } write<T>(entity: Entity, c: Component<T>, value: T): void throws string { const fields = c.encode(value); for (const at of range(0, fields.length)) { this.world.write(entity, c.id, at, fields[at]); } } insert<T>(entity: Entity, c: Component<T>, value: T): void throws string { this.world.replace(entity, [...this.world.data(entity).filter(d => d.component !== c.id), c.of(value)]); } remove<T>(entity: Entity, c: Component<T>): void throws string { this.world.replace(entity, this.world.data(entity).filter(d => d.component !== c.id)); } each<T>(c: Component<T>): Vec<Entity> throws string { let out: Vec<Entity> = []; this.world.query([c.id], [], (entities: Vec<Entity>, columns: Vec<ColumnView>): void throws string => { for (const e of entities) { out.push(e); } }); return out; } first<T>(c: Component<T>): Entity | undefined throws string { const all = this.each(c); return all.length> 0 ? all[0]: undefined; } count<T>(c: Component<T>): i64 throws string { let total: i64 = 0; this.world.query([c.id], [], (entities: Vec<Entity>, columns: Vec<ColumnView>): void throws string => { total+ = entities.length; }); return total; } fetch<T>(c: Component<T>): T throws string { return this.read(this.holder, c); } put<T>(c: Component<T>, value: T): void throws string { this.write(this.holder, c, value); } pose2D(entity: Entity): Pose2D throws string { const now = this.read(entity, Transform2D); if (this.alpha> = 1.0) { return now; } const was = this.read(entity, Before2D); const a = this.alpha; return { x: was.x+(now.x-was.x)*a, y: was.y+(now.y-was.y)*a, angle: angleBetween(was.angle, now.angle, a) }; } pose3D(entity: Entity): Pose3D throws string { const now = this.read(entity, Transform3D); if (this.alpha> = 1.0) { return now; } const was = this.read(entity, Before3D); const a = this.alpha; return { x: was.x+(now.x-was.x)*a, y: was.y+(now.y-was.y)*a, z: was.z+(now.z-was.z)*a, yaw: angleBetween(was.yaw, now.yaw, a), pitch: angleBetween(was.pitch, now.pitch, a), roll: angleBetween(was.roll, now.roll, a) }; } teleport2D(entity: Entity, pose: Pose2D): void throws string { this.write(entity, Transform2D, pose); this.write(entity, Before2D, pose); } teleport3D(entity: Entity, pose: Pose3D): void throws string { this.write(entity, Transform3D, pose); this.write(entity, Before3D, pose); } private controls(): Controls throws string { return this.read(this.holder, Engine); } random(): f64 throws string { let state = this.controls(); let x = state.dice; const mask = 4294967295u; x = x ^ ((x <<13u) & mask); x = x ^ (x>> 17u); x = x ^ ((x <<5u) & mask); state.dice = x; this.write(this.holder, Engine, state); return f64(x-1u)/4294967295.0; } between(low: f64, high: f64): f64 throws string { return low+(high-low)*this.random(); } chance(p: f64): bool throws string { return this.random() <p; } private index(name: string): i64 throws string { const at = this.actions.findIndex(a => a.name === name); if (at <0) { throw `Unknown action ${name }`; } return at; } held(name: string): bool throws string { return (this.controls().held>> u64(this.index(name)) & 1u) === 1u; } pressed(name: string): bool throws string { const state = this.controls(); const bit = 1u <<u64(this.index(name)); return (state.held & bit) !== 0u && (state.was & bit) === 0u; } axes(name: string): Stick throws string { const at = this.sticks.findIndex(s => s.name === name); if (at <0) { throw `Unknown stick ${name }`; } const values = this.world.read(this.holder, this.sticksId, 0); return { x: values.readF64LE(at*16), y: values.readF64LE(at*16+8) }; } pointer(): Pointer throws string { const state = this.controls(); const bit = this.actions.findIndex(a => a.codes.includes("Mouse")); return { x: state.x, y: state.y, width: state.width, height: state.height, held: state.buttons !== 0u, seen: state.seen, pressed: bit> = 0 && this.pressed(this.actions[bit].name) }; } play(name: string): void throws string { const at = this.sounds.findIndex(s => s.name === name); if (at <0) { throw `Unknown sound ${name }`; } let counts = this.world.read(this.holder, this.cuesId, 0); counts.copyFrom(at*8, u64Bytes(counts.readU64LE(at*8)+1u), 0, 8); this.world.write(this.holder, this.cuesId, 0, counts); } private control(inputs: Vec<Input>): void throws string { let state = this.controls(); state.was = state.held; if (inputs.length === 0) { this.write(this.holder, Engine, state); return; } let clicked = false; let tapped: Vec<string> = []; for (const input of inputs) { const host = hostFrame(input.payload); state.width = host.field("width").numberOr(1.0); state.height = host.field("height").numberOr(1.0); for (const event of host.field("events").list()) { const kind = event.field("kind").text(); if (kind === "blur") { state.buttons = 0u; continue; } if (kind === "keydown") { tapped.push(event.field("code").text()); continue; } if (!["pointerdown", "pointermove", "pointerup"].includes(kind)) { continue; } state.x = event.field("x").numberOr(0.0)*state.width; state.y = event.field("y").numberOr(0.0)*state.height; state.seen = true; state.buttons = u64(Math.maxI64(0, event.field("buttons").integer())); if (kind === "pointerdown") { clicked = true; } } } const newest = hostFrame(inputs[inputs.length-1].payload); let codes = [...newest.field("keys").list().map(key => key.text()), ...tapped]; const pads = newest.field("gamepads").list(); let sticks: Vec<f64> = []; if (pads.length> 0) { const buttons = pads[0].field("buttons").list(); for (const at of range(0, buttons.length)) { if (buttons[at].field("pressed").boolean() || buttons[at].field("value").numberOr(0.0)> 0.5) { codes.push(`Pad${at }`); } } sticks = pads[0].field("axes").list().map(value => value.numberOr(0.0)); } if (state.buttons !== 0u || clicked) { codes.push("Mouse"); } let held: u64 = 0u; for (const at of range(0, this.actions.length)) { if (this.actions[at].codes.some(code => codes.includes(code))) { held = held | (1u <<u64(at)); } } state.held = held; this.write(this.holder, Engine, state); let axes = b""; for (const at of range(0, STICKS/2)) { let x = 0.0; let y = 0.0; if (at <this.sticks.length) { const keys = this.sticks[at].keys; x = axis(codes, keys.left, keys.right); y = axis(codes, keys.up, keys.down); const lane = keys.pad*2; if (lane+1 <sticks.length) { const px = sticks[lane]; const py = sticks[lane+1]; if (px*px+py*py> 0.0225) { x+ = px; y+ = py; } } const length = Math.sqrt(x*x+y*y); if (length> 1.0) { x/ = length; y/ = length; } } writeF64LE(axes, x); writeF64LE(axes, y); } this.world.write(this.holder, this.sticksId, 0, axes); } private remember(): void throws string { for (const entity of this.each(Transform2D)) { for (const at of range(0, Transform2D.fields.length)) { this.world.write(entity, Before2D.id, at, this.world.read(entity, Transform2D.id, at)); } } for (const entity of this.each(Transform3D)) { for (const at of range(0, Transform3D.fields.length)) { this.world.write(entity, Before3D.id, at, this.world.read(entity, Transform3D.id, at)); } } } }A game: its components, resources, input actions, sounds and systems, run in fixed ticks over one World. Systems and drawing receive the Game itself: typed reads and writes, spawning, queries, input, random numbers and sound cues.
world:Ref<M186.World>dt:f64— The seconds of one tick.tick:i64— The running tick in a system; the next tick in drawing.alpha:f64— The fraction toward the next tick: 1 in a system, the frame's interpolation in drawing.simulation:_gizlang_sdk_core.Option<Ref<M184.Simulation>>hz:f64catchUp:i64seed:i64failure:stringrules:Vec<M181.Rule>setups:Vec<M181.Rule>actions:Vec<M181.Action>sticks:Vec<M181.Axis>sounds:Vec<M181.Cue>defaults:Vec<M186.Data>holder:M186.EntitysticksId:i64cuesId:i64heard:Vec<u64>files:_gizlang_sdk_collections.Map<string, bytes>
Functions
constructor
constructor(name: string, initial: T, marker: bool = false)NAME is the stable schema name in snapshots; INITIAL is the value of on() and the shape of every value.
component
function component<T>(name: string, initial: T): Component<T>A component of record type T, its schema NAME and its INITIAL value.
tag
function tag(name: string): Component<Mark>A tag: a component that only marks, such as Player or Enemy.
Effects: fail, read, write, alloc.
wasd
function wasd(): StickKeysWASD and the arrow keys, and the gamepad's left stick.
Effects: fail, alloc.
pad
function pad(stick: i64): StickKeysOnly the gamepad's stick PAD.
Effects: fail, alloc.
constructor
constructor(hz: f64 = 60.0, seed: i64 = 1, catchUp: i64 = 5)HZ fixed ticks a second, SEED for random(), and at most CATCHUP ticks in one host frame.
Effects: fail, read, write, console, io, alloc.
Methods
Component.of
of(value: T): DataVALUE as an entity's data, for spawn.
Component.on
on(): DataThe initial value as an entity's data: a tag's only form.
Component.value
value(): TThe default value.
Component.encode
encode(value: T): Vec<bytes>Each World field's little-endian bytes, cut from the value's flattened words without a per-type writer.
Component.decode
decode(fields: Vec<bytes>): TThe value of FIELDS, written into a copy of the initial value's words.
Game.use
use<T>(c: Component<T>): GameRegisters component C. Register every component before start; the order is the snapshot's schema.
Game.resource
resource<T>(c: Component<T>): GameRegisters C as a resource: one value of the whole game, starting at its initial value.
Game.action
action(name: string, codes: Vec<string>): GameAn action held while any of CODES is: keys ("KeyR", "Space"), "Mouse", or gamepad buttons ("Pad0"). At most 64.
Effects: fail, read, write, alloc.
Game.stick
stick(name: string, keys: StickKeys): GameA two-axis stick from KEYS and a gamepad stick. At most four.
Effects: fail, read, write, alloc.
Game.sound
sound(name: string, gain: f64 = 1.0): GameA sound the host plays at GAIN when a system calls play(NAME).
Effects: fail, read, write, alloc.
Game.setup
setup(run: (game: Game) => void throws string): GameRUN once at start and at each restart, to spawn the scene.
Effects: fail, read, write, alloc.
Game.system
system(name: string, run: (game: Game) => void throws string): GameA system: RUN every tick, after the systems added before it.
Effects: fail, read, write, alloc.
Game.start
start(): void throws stringBuilds the World once: registration errors surface here.
Effects: fail, read, write, console, io, alloc.
Game.initialize
initialize(input: bytes): Screen throws stringThe host's first call: builds the game and draws its first frame.
Effects: fail, read, write, console, io, alloc.
Game.frame
frame(input: bytes): Screen throws stringThe host's call each frame: queues its input, runs the fixed ticks it covers, and says what to draw.
Effects: fail, read, write, console, io, alloc.
Game.snapshot
snapshot(): bytes throws stringThe whole game state: World, tick and queued input.
Effects: fail, read, write, console, io, alloc.
Game.restore
restore(state: bytes): bytes throws stringReplaces the state with a snapshot of this game; a snapshot of another schema or rate is refused first.
Effects: fail, read, write, console, io, alloc.
Game.cues
cues(): bytes throws stringThe sounds since the last call, as a host plays them: [{"sound","gain"}]. None right after a start or a restore.
Effects: fail, read, write, console, io, alloc.
Game.receive
receive(input: bytes): bytes throws stringThe host's call for each file before initialize: NAME, a newline and the bytes (gizapp/play, <giz-surface files>). Files are the game's assets, not its state: no snapshot holds them.
Effects: fail, write, alloc.
Game.file
file(name: string): bytes throws stringThe bytes of the file NAME the host gave.
Effects: fail, read, alloc.
Game.restart
restart(): void throws stringEnds every entity, puts each resource back to its initial value and runs setup again.
Effects: fail, read, write, console, io, alloc.
Game.time
time(): f64Seconds of simulation since tick zero.
Effects: fail, read.
Game.spawn
spawn(data: Vec<Data>): Entity throws stringA new entity with DATA, such as [Transform2D.of(pose), Enemy.on()]. A pose starts with no motion to interpolate.
Effects: fail, read, write, console, io, alloc.
Game.despawn
despawn(entity: Entity): void throws stringEnds ENTITY. Ending an entity that already ended does nothing, so two hits in one tick need no check.
Effects: fail, read, write, alloc.
Game.alive
alive(entity: Entity): boolWhether ENTITY still exists.
Effects: fail, read.
Game.has
has<T>(entity: Entity, c: Component<T>): bool throws stringWhether ENTITY has C.
Game.read
read<T>(entity: Entity, c: Component<T>): T throws stringC's value on ENTITY.
Game.write
write<T>(entity: Entity, c: Component<T>, value: T): void throws stringWrites C's VALUE on ENTITY.
Game.insert
insert<T>(entity: Entity, c: Component<T>, value: T): void throws stringAdds C with VALUE to ENTITY, or replaces its value.
Game.remove
remove<T>(entity: Entity, c: Component<T>): void throws stringTakes C off ENTITY.
Game.each
each<T>(c: Component<T>): Vec<Entity> throws stringThe entities with C, in the World's order. Changing them while iterating is safe: the list is a copy.
Game.first
first<T>(c: Component<T>): Entity | undefined throws stringThe first entity with C, if any.
Game.count
count<T>(c: Component<T>): i64 throws stringHow many entities have C.
Game.fetch
fetch<T>(c: Component<T>): T throws stringThe value of resource C.
Game.put
put<T>(c: Component<T>, value: T): void throws stringWrites resource C.
Game.pose2D
pose2D(entity: Entity): Pose2D throws stringENTITY's 2D pose, interpolated toward the current tick by alpha.
Effects: fail, read, write, console, io, alloc.
Game.pose3D
pose3D(entity: Entity): Pose3D throws stringENTITY's 3D pose, interpolated toward the current tick by alpha.
Effects: fail, read, write, console, io, alloc.
Game.teleport2D
teleport2D(entity: Entity, pose: Pose2D): void throws stringMoves ENTITY to POSE with no interpolation from where it was, as for a wrap or a respawn.
Effects: fail, read, write, console, io, alloc.
Game.teleport3D
teleport3D(entity: Entity, pose: Pose3D): void throws stringThe 3D form of teleport2D.
Effects: fail, read, write, console, io, alloc.
Game.random
random(): f64 throws stringA number in [0, 1) from the World's own generator, so a replay draws the same numbers.
Effects: fail, read, write, console, io, alloc.
Game.between
between(low: f64, high: f64): f64 throws stringA number in [LOW, HIGH).
Effects: fail, read, write, console, io, alloc.
Game.chance
chance(p: f64): bool throws stringTrue with probability P.
Effects: fail, read, write, console, io, alloc.
Game.held
held(name: string): bool throws stringWhether action NAME is held in this tick.
Effects: fail, read, write, console, io, alloc.
Game.pressed
pressed(name: string): bool throws stringWhether action NAME began in this tick.
Effects: fail, read, write, console, io, alloc.
Game.axes
axes(name: string): Stick throws stringStick NAME's direction; its length is at most 1.
Effects: fail, read, alloc.
Game.pointer
pointer(): Pointer throws stringThe pointer in surface pixels.
Effects: fail, read, write, console, io, alloc.
Game.play
play(name: string): void throws stringPlays sound NAME once at this tick. Sounds are World counters, so a replay sounds alike and a load is silent.
Effects: fail, read, write, alloc.
Constants
Transform2D
const Transform2D = component<Pose2D>("gizgame.Transform2D", { x: 0.0, y: 0.0, angle: 0.0 })The 2D pose. The Game keeps the pose of the last tick beside it, so drawing interpolates without game code.
Transform3D
const Transform3D = component<Pose3D>("gizgame.Transform3D", { x: 0.0, y: 0.0, z: 0.0, yaw: 0.0, pitch: 0.0, roll: 0.0 })The 3D pose, interpolated in the same way.