/* ============================================================================ * ludic-highlight.js — the Ludic syntax highlighter + docs interactions. * * GENERATED FILE — do not edit by hand. The symbol tables below (keywords, * types, phases, namespace methods + their parameter labels, builtins, * annotations, namespaces, one-line tips, per-item page targets and hover-card * data) are produced by tools/docgen/gen.py from the per-symbol source files in * docs/language/**. Add a symbol there and it is recognized, colored, tipped, * linked and card-previewed here automatically. * * In any code sample: every keyword/type/builtin/annotation links to its own * page; `Screen.fill_rectangle` links `Screen` → the namespace page and * `fill_rectangle` → the method page, separately; a named argument like * `width:` links to that parameter on the method's page; `Color.Charcoal` * links `Color` and `Charcoal` separately. Hovering any of them shows a summary * card pulled from the real API data. * ========================================================================== */ (function (global) { "use strict"; const S = {"keywords": {"program": "kw-program", "property": "kw-property", "model": "kw-model", "handler": "kw-handler", "phase": "kw-phase", "const": "kw-const", "var": "kw-var", "let": "kw-let", "function": "kw-function", "fn": "kw-fn", "prefab": "kw-prefab", "return": "kw-return", "entry": "kw-entry", "import": "kw-import", "public": "kw-public", "extern": "kw-extern", "new": "kw-new", "namespace": "kw-namespace", "enum": "kw-enum", "ui": "kw-ui", "spawn": "kw-spawn", "despawn": "kw-despawn", "query": "kw-query", "self": "kw-self", "enable": "kw-enable", "disable": "kw-disable", "attach": "kw-attach", "detach": "kw-detach", "if": "kw-if", "else": "kw-if", "while": "kw-while", "for": "kw-for", "in": "kw-in", "match": "kw-match", "machine": "kw-machine", "state": "kw-state", "become": "kw-become", "break": "kw-break", "continue": "kw-continue", "where": "kw-where", "try": "kw-try", "scene": "kw-scene", "layer": "kw-layer", "on": "kw-on", "enter": "kw-enter", "exit": "kw-exit", "start": "kw-start", "event": "kw-event", "emit": "kw-emit", "cancel": "kw-cancel", "cancellable": "kw-cancellable", "test": "kw-test"}, "types": {"int": "type-int", "fixed": "type-fixed", "long": "type-long", "bool": "type-bool", "float": "type-float", "string": "type-string", "double": "type-double", "entity": "type-entity", "pointer": "type-pointer", "words": "type-words", "byte": "type-byte", "fixeds": "type-fixeds", "countdown": "type-countdown", "floats": "type-floats", "doubles": "type-floats", "pointers": "type-pointers", "Vector": "type-vector", "IVec2": "type-ivec2", "Rect": "type-rect", "void": "type-void"}, "phases": {"Start": "phase-start", "Input": "phase-input", "FixedUpdate": "phase-fixedupdate", "Update": "phase-update", "LateUpdate": "phase-lateupdate", "Render": "phase-render", "Overlay": "phase-overlay"}, "builtins": {"world_attach_dyn": {"id": "fn-world_attach_dyn", "params": ["target", "property"]}, "world_count": {"id": "fn-world_count", "params": []}, "world_detach_dyn": {"id": "fn-world_detach_dyn", "params": ["target", "property"]}, "world_field_id": {"id": "fn-world_field_id", "params": ["property", "name"]}, "world_get": {"id": "fn-world_get", "params": ["target", "property", "field"]}, "world_has": {"id": "fn-world_has", "params": ["target", "property"]}, "world_kind": {"id": "fn-world_kind", "params": ["target"]}, "world_load": {"id": "fn-world_load", "params": ["buf", "len"]}, "world_model_id": {"id": "fn-world_model_id", "params": ["name"]}, "world_prop_id": {"id": "fn-world_prop_id", "params": ["name"]}, "world_query_next": {"id": "fn-world_query_next", "params": ["property", "cursor"]}, "world_register_prop": {"id": "fn-world_register_prop", "params": ["name", "fields"]}, "world_save": {"id": "fn-world_save", "params": ["buf"]}, "world_set": {"id": "fn-world_set", "params": ["target", "property", "field", "value"]}, "world_size": {"id": "fn-world_size", "params": []}, "world_spawn": {"id": "fn-world_spawn", "params": ["model"]}, "print": {"id": "fn-print", "params": ["x"]}, "string": {"id": "fn-string", "params": ["x"]}, "quit": {"id": "fn-quit", "params": []}, "save": {"id": "fn-save", "params": []}, "load": {"id": "fn-load", "params": []}, "len": {"id": "fn-len", "params": ["x"]}, "push": {"id": "fn-push", "params": ["slice", "x"]}, "abs": {"id": "fn-abs", "params": ["a"]}, "clamp": {"id": "fn-clamp", "params": ["v", "lo", "hi"]}, "panic": {"id": "fn-panic", "params": ["msg"]}, "assert": {"id": "fn-assert", "params": ["cond", "msg"]}, "ok": {"id": "fn-ok", "params": ["v"]}, "err": {"id": "fn-err", "params": ["msg"]}, "is_ok": {"id": "fn-is_ok", "params": ["r"]}, "is_err": {"id": "fn-is_err", "params": ["r"]}, "some": {"id": "fn-some", "params": ["v"]}, "none": {"id": "fn-none", "params": []}, "is_some": {"id": "fn-is_some", "params": ["o"]}, "is_none": {"id": "fn-is_none", "params": ["o"]}, "unwrap_or": {"id": "fn-unwrap_or", "params": ["o", "fallback"]}, "exit": {"id": "fn-exit", "params": ["code"]}, "run": {"id": "fn-run", "params": ["cmd"]}, "getenv": {"id": "fn-getenv", "params": ["name"]}, "read_char": {"id": "fn-read_char", "params": []}, "arg": {"id": "fn-arg", "params": ["i"]}, "arg_count": {"id": "fn-arg_count", "params": []}, "bytes": {"id": "fn-bytes", "params": ["n"]}, "file_stderr": {"id": "fn-file_stderr", "params": []}, "file_stdout": {"id": "fn-file_stdout", "params": []}, "file_write": {"id": "fn-file_write", "params": ["handle", "buf", "len"]}, "fixed": {"id": "fn-fixed", "params": ["x"]}, "floor": {"id": "fn-floor", "params": ["x"]}, "max": {"id": "fn-max", "params": ["a", "b"]}, "min": {"id": "fn-min", "params": ["a", "b"]}, "ui_build": {"id": "fn-ui_build", "params": []}, "words": {"id": "fn-words", "params": ["n"]}, "float": {"id": "fn-float", "params": ["x"]}, "double": {"id": "fn-float", "params": ["x"]}, "int": {"id": "fn-int", "params": ["x"]}, "long": {"id": "fn-int", "params": ["x"]}, "float_bits": {"id": "fn-float_bits", "params": ["x"]}, "float_from_bits": {"id": "fn-float_bits", "params": ["x"]}, "double_bits": {"id": "fn-float_bits", "params": ["x"]}, "double_from_bits": {"id": "fn-float_bits", "params": ["x"]}}, "nsmethods": {"Screen.clear": {"id": "screen-clear", "params": ["color"]}, "Screen.fill_rectangle": {"id": "screen-fill_rectangle", "params": ["x", "y", "width", "height", "color"]}, "Screen.draw_rectangle": {"id": "screen-draw_rectangle", "params": ["x", "y", "width", "height", "color"]}, "Screen.put_pixel": {"id": "screen-put_pixel", "params": ["x", "y", "color"]}, "Screen.draw_text": {"id": "screen-draw_text", "params": ["x", "y", "text", "color", "scale"]}, "Screen.draw_number": {"id": "screen-draw_number", "params": ["x", "y", "value", "color", "scale"]}, "Screen.show": {"id": "screen-show", "params": []}, "Screen.width": {"id": "screen-width", "params": []}, "Screen.height": {"id": "screen-height", "params": []}, "Screen.status": {"id": "screen-status", "params": ["text"]}, "Screen.line": {"id": "screen-line", "params": []}, "Screen.circle": {"id": "screen-circle", "params": []}, "Screen.fill_circle": {"id": "screen-fill_circle", "params": []}, "Screen.triangle": {"id": "screen-triangle", "params": []}, "Screen.fill_triangle": {"id": "screen-fill_triangle", "params": []}, "Screen.sprite": {"id": "screen-sprite", "params": []}, "Screen.sprite_scaled": {"id": "screen-sprite_scaled", "params": []}, "Screen.oval": {"id": "screen-oval", "params": []}, "Screen.camera": {"id": "screen-camera", "params": []}, "Screen.clip": {"id": "screen-clip", "params": []}, "Screen.clip_reset": {"id": "screen-clip_reset", "params": []}, "Screen.blend_mode": {"id": "screen-blend_mode", "params": []}, "Screen.measure_text": {"id": "screen-measure_text", "params": []}, "Screen.pixel": {"id": "screen-pixel", "params": []}, "Screen.bar": {"id": "screen-bar", "params": []}, "Clock.now": {"id": "clock-now", "params": []}, "Clock.set": {"id": "clock-set", "params": []}, "Clock.advance": {"id": "clock-advance", "params": []}, "Clock.reset": {"id": "clock-reset", "params": []}, "Collision.rects": {"id": "collision-rects", "params": []}, "Collision.point_rect": {"id": "collision-point_rect", "params": []}, "Collision.circles": {"id": "collision-circles", "params": []}, "Collision.rect_circle": {"id": "collision-rect_circle", "params": []}, "Color.rgb": {"id": "color-rgb", "params": []}, "Color.rgba": {"id": "color-rgba", "params": []}, "Color.lerp": {"id": "color-lerp", "params": []}, "Color.darken": {"id": "color-darken", "params": []}, "Color.lighten": {"id": "color-lighten", "params": []}, "Color.with_alpha": {"id": "color-with_alpha", "params": []}, "Crypto.sha256": {"id": "crypto-sha256", "params": ["s"]}, "Crypto.hmac_sha256": {"id": "crypto-hmac_sha256", "params": ["key", "msg"]}, "Crypto.verify_hmac": {"id": "crypto-verify_hmac", "params": ["key", "msg", "mac"]}, "Crypto.hex": {"id": "crypto-hex", "params": ["s"]}, "Crypto.ct_equal": {"id": "crypto-ct_equal", "params": ["a", "b"]}, "Crypto.random_bytes": {"id": "crypto-random_bytes", "params": ["n"]}, "Crypto.random_hex": {"id": "crypto-random_hex", "params": ["n"]}, "Crypto.random_u32": {"id": "crypto-random_u32", "params": []}, "Crypto.base64": {"id": "crypto-base64", "params": ["s"]}, "Date.new": {"id": "date-new", "params": []}, "Date.year": {"id": "date-year", "params": []}, "Date.month": {"id": "date-month", "params": []}, "Date.day": {"id": "date-day", "params": []}, "Date.weekday": {"id": "date-weekday", "params": []}, "Date.is_leap": {"id": "date-is_leap", "params": []}, "Date.days_in_month": {"id": "date-days_in_month", "params": []}, "Date.to_epoch": {"id": "date-to_epoch", "params": []}, "Date.add_days": {"id": "date-add_days", "params": []}, "Date.diff_days": {"id": "date-diff_days", "params": []}, "DateTime.from": {"id": "datetime-from", "params": []}, "DateTime.date": {"id": "datetime-date", "params": []}, "DateTime.add": {"id": "datetime-add", "params": []}, "DateTime.year": {"id": "datetime-year", "params": []}, "DateTime.month": {"id": "datetime-month", "params": []}, "DateTime.day": {"id": "datetime-day", "params": []}, "DateTime.weekday": {"id": "datetime-weekday", "params": []}, "DateTime.hour": {"id": "datetime-hour", "params": []}, "DateTime.minute": {"id": "datetime-minute", "params": []}, "DateTime.second": {"id": "datetime-second", "params": []}, "DateTime.format": {"id": "datetime-format", "params": []}, "DateTime.parse": {"id": "datetime-parse", "params": []}, "Duration.seconds": {"id": "duration-seconds", "params": []}, "Duration.minutes": {"id": "duration-minutes", "params": []}, "Duration.hours": {"id": "duration-hours", "params": []}, "Duration.days": {"id": "duration-days", "params": []}, "Duration.as_seconds": {"id": "duration-as_seconds", "params": []}, "Duration.as_minutes": {"id": "duration-as_minutes", "params": []}, "Duration.as_hours": {"id": "duration-as_hours", "params": []}, "Duration.as_days": {"id": "duration-as_days", "params": []}, "Ease.in": {"id": "ease-in", "params": []}, "Ease.out": {"id": "ease-out", "params": []}, "Ease.in_out": {"id": "ease-in_out", "params": []}, "Ease.back": {"id": "ease-back", "params": []}, "Ease.bounce": {"id": "ease-bounce", "params": []}, "Ease.elastic": {"id": "ease-elastic", "params": []}, "Fs.exists": {"id": "fs-exists", "params": ["p"]}, "Fs.is_dir": {"id": "fs-is_dir", "params": ["p"]}, "Fs.read_text": {"id": "fs-read_text", "params": ["p"]}, "Fs.write_text": {"id": "fs-write_text", "params": ["p", "s"]}, "Fs.append_text": {"id": "fs-append_text", "params": ["p", "s"]}, "Fs.remove": {"id": "fs-remove", "params": ["p"]}, "Fs.size": {"id": "fs-size", "params": ["p"]}, "Fs.mkdir": {"id": "fs-mkdir", "params": ["p"]}, "Fs.copy": {"id": "fs-copy", "params": ["src", "dst"]}, "Fs.list": {"id": "fs-list", "params": ["dir"]}, "Hash.of": {"id": "hash-of", "params": ["s"]}, "Hash.fnv1a": {"id": "hash-fnv1a", "params": ["s"]}, "Hash.crc32": {"id": "hash-crc32", "params": ["s"]}, "Hash.mix": {"id": "hash-mix", "params": ["x"]}, "Hash.combine": {"id": "hash-combine", "params": []}, "Hash.of64": {"id": "hash-of64", "params": ["s"]}, "Hash.fnv1a_64": {"id": "hash-fnv1a_64", "params": ["s"]}, "Hash.mix64": {"id": "hash-mix64", "params": ["x"]}, "Input.key": {"id": "input-key", "params": []}, "Input.bind": {"id": "input-bind", "params": []}, "Input.rebind": {"id": "input-rebind", "params": []}, "Input.poll": {"id": "input-poll", "params": []}, "Input.down": {"id": "input-down", "params": []}, "Input.pressed": {"id": "input-pressed", "params": []}, "Input.record": {"id": "input-record", "params": []}, "Input.replay": {"id": "input-replay", "params": []}, "Input.key_down": {"id": "input-key_down", "params": []}, "Input.key_pressed": {"id": "input-key_pressed", "params": []}, "Input.key_released": {"id": "input-key_released", "params": []}, "Input.key_label": {"id": "input-key_label", "params": []}, "Input.press": {"id": "input-press", "params": []}, "Input.release": {"id": "input-release", "params": []}, "Input.axis": {"id": "input-axis", "params": []}, "Input.axis_i": {"id": "input-axis_i", "params": []}, "Input.vector": {"id": "input-vector", "params": []}, "Input.strength": {"id": "input-strength", "params": []}, "Input.mouse_x": {"id": "input-mouse_x", "params": []}, "Input.mouse_y": {"id": "input-mouse_y", "params": []}, "Input.mouse_dx": {"id": "input-mouse_dx", "params": []}, "Input.mouse_dy": {"id": "input-mouse_dy", "params": []}, "Input.mouse_down": {"id": "input-mouse_down", "params": []}, "Input.wheel": {"id": "input-wheel", "params": []}, "Input.set_mouse": {"id": "input-set_mouse", "params": []}, "Input.pad_connected": {"id": "input-pad_connected", "params": []}, "Input.pad_button": {"id": "input-pad_button", "params": []}, "Input.pad_axis": {"id": "input-pad_axis", "params": []}, "Input.set_pad": {"id": "input-set_pad", "params": []}, "Input.touch_count": {"id": "input-touch_count", "params": []}, "Input.touch_x": {"id": "input-touch_x", "params": []}, "Input.touch_y": {"id": "input-touch_y", "params": []}, "Input.set_touch": {"id": "input-set_touch", "params": []}, "Input.action": {"id": "input-action", "params": []}, "Input.bind_pad": {"id": "input-bind_pad", "params": []}, "Input.active": {"id": "input-active", "params": []}, "Input.just_pressed": {"id": "input-just_pressed", "params": []}, "Input.just_released": {"id": "input-just_released", "params": []}, "Input.cursor_mode": {"id": "input-cursor_mode", "params": []}, "Input.move_i": {"id": "input-move_i", "params": []}, "List.len": {"id": "list-len", "params": ["s"]}, "List.push": {"id": "list-push", "params": ["s", "v"]}, "List.clear": {"id": "list-clear", "params": ["s"]}, "List.first": {"id": "list-first", "params": ["s"]}, "List.last": {"id": "list-last", "params": ["s"]}, "List.pop": {"id": "list-pop", "params": ["s"]}, "List.swap": {"id": "list-swap", "params": ["s", "i", "j"]}, "List.contains": {"id": "list-contains", "params": ["s", "v"]}, "List.index_of": {"id": "list-index_of", "params": ["s", "v"]}, "List.reverse": {"id": "list-reverse", "params": ["s"]}, "List.insert": {"id": "list-insert", "params": []}, "List.remove_at": {"id": "list-remove_at", "params": []}, "List.remove": {"id": "list-remove", "params": []}, "List.sort": {"id": "list-sort", "params": []}, "List.sort_by": {"id": "list-sort_by", "params": []}, "List.sort_desc_by": {"id": "list-sort_desc_by", "params": []}, "List.sort_with": {"id": "list-sort_with", "params": []}, "List.sample": {"id": "list-sample", "params": []}, "Log.trace": {"id": "log-trace", "params": ["msg"]}, "Log.debug": {"id": "log-debug", "params": ["msg"]}, "Log.info": {"id": "log-info", "params": ["msg"]}, "Log.warn": {"id": "log-warn", "params": ["msg"]}, "Log.error": {"id": "log-error", "params": ["msg"]}, "Log.set_level": {"id": "log-set_level", "params": ["n"]}, "Log.level": {"id": "log-level", "params": []}, "Math.min": {"id": "math-min", "params": ["a", "b"]}, "Math.max": {"id": "math-max", "params": ["a", "b"]}, "Math.abs": {"id": "math-abs", "params": ["x"]}, "Math.clamp": {"id": "math-clamp", "params": ["v", "lo", "hi"]}, "Math.sign": {"id": "math-sign", "params": ["x"]}, "Math.floor": {"id": "math-floor", "params": ["x"]}, "Math.ceil": {"id": "math-ceil", "params": ["x"]}, "Math.round": {"id": "math-round", "params": ["x"]}, "Math.lerp": {"id": "math-lerp", "params": ["a", "b", "t"]}, "Math.inverse_lerp": {"id": "math-inverse_lerp", "params": ["a", "b", "v"]}, "Math.remap": {"id": "math-remap", "params": ["v", "in0", "in1", "out0", "out1"]}, "Math.sqrt": {"id": "math-sqrt", "params": []}, "Math.sin": {"id": "math-sin", "params": []}, "Math.cos": {"id": "math-cos", "params": []}, "Math.tan": {"id": "math-tan", "params": []}, "Math.hypot": {"id": "math-hypot", "params": []}, "Math.dist": {"id": "math-dist", "params": []}, "Math.dist2": {"id": "math-dist2", "params": []}, "Math.deg_to_rad": {"id": "math-deg_to_rad", "params": []}, "Math.rad_to_deg": {"id": "math-rad_to_deg", "params": []}, "Math.posmod": {"id": "math-posmod", "params": []}, "Math.wrap": {"id": "math-wrap", "params": []}, "Math.ping_pong": {"id": "math-ping_pong", "params": []}, "Math.snapped": {"id": "math-snapped", "params": []}, "Math.move_toward": {"id": "math-move_toward", "params": []}, "Math.smoothstep": {"id": "math-smoothstep", "params": []}, "Math.atan2": {"id": "math-atan2", "params": []}, "Math.asin": {"id": "math-asin", "params": []}, "Math.acos": {"id": "math-acos", "params": []}, "Math.exp": {"id": "math-exp", "params": []}, "Math.log": {"id": "math-log", "params": []}, "Math.pow": {"id": "math-pow", "params": []}, "Memory.bytes": {"id": "memory-bytes", "params": []}, "Memory.words": {"id": "memory-words", "params": []}, "Memory.copy": {"id": "memory-copy", "params": []}, "Memory.fill": {"id": "memory-fill", "params": []}, "Memory.peek": {"id": "memory-peek", "params": []}, "Memory.poke": {"id": "memory-poke", "params": []}, "Mime.of": {"id": "mime-of", "params": ["path"]}, "Mime.sniff": {"id": "mime-sniff", "params": ["path"]}, "Network.send": {"id": "network-send", "params": []}, "Network.poll": {"id": "network-poll", "params": []}, "Network.serialize": {"id": "network-serialize", "params": []}, "Network.apply": {"id": "network-apply", "params": []}, "Network.owner": {"id": "network-owner", "params": []}, "Network.set_owner": {"id": "network-set_owner", "params": []}, "Network.is_server": {"id": "network-is_server", "params": []}, "Network.is_owner": {"id": "network-is_owner", "params": []}, "Network.local_id": {"id": "network-local_id", "params": []}, "Noise.value2": {"id": "noise-value2", "params": ["seed"]}, "Noise.perlin2": {"id": "noise-perlin2", "params": ["seed"]}, "Noise.simplex2": {"id": "noise-simplex2", "params": ["seed"]}, "Noise.fbm2": {"id": "noise-fbm2", "params": ["seed", "octaves"]}, "Noise.cellular2": {"id": "noise-cellular2", "params": ["seed"]}, "Noise.cellular2_id": {"id": "noise-cellular2_id", "params": ["seed"]}, "Noise.unit": {"id": "noise-unit", "params": ["n"]}, "Os.args": {"id": "os-args", "params": []}, "Os.arg_count": {"id": "os-arg_count", "params": []}, "Os.arg": {"id": "os-arg", "params": ["i"]}, "Os.env": {"id": "os-env", "params": ["name"]}, "Os.env_or": {"id": "os-env_or", "params": ["name", "fallback"]}, "Os.has_env": {"id": "os-has_env", "params": ["name"]}, "Os.set_env": {"id": "os-set_env", "params": ["name", "value"]}, "Os.unset_env": {"id": "os-unset_env", "params": ["name"]}, "Os.exit": {"id": "os-exit", "params": ["code"]}, "Os.platform": {"id": "os-platform", "params": []}, "Os.arch": {"id": "os-arch", "params": []}, "Os.stdout_write": {"id": "os-stdout_write", "params": ["s"]}, "Os.stderr_write": {"id": "os-stderr_write", "params": ["s"]}, "Os.save_dir": {"id": "os-save_dir", "params": ["app"]}, "Os.config_dir": {"id": "os-config_dir", "params": ["app"]}, "Os.cache_dir": {"id": "os-cache_dir", "params": ["app"]}, "Os.temp_dir": {"id": "os-temp_dir", "params": []}, "Os.pid": {"id": "os-pid", "params": []}, "Path.join": {"id": "path-join", "params": ["a", "b"]}, "Path.dir": {"id": "path-dir", "params": ["p"]}, "Path.base": {"id": "path-base", "params": ["p"]}, "Path.ext": {"id": "path-ext", "params": ["p"]}, "Path.stem": {"id": "path-stem", "params": ["p"]}, "Path.normalize": {"id": "path-normalize", "params": ["p"]}, "Save.write": {"id": "save-write", "params": []}, "Save.read": {"id": "save-read", "params": []}, "System.run": {"id": "system-run", "params": []}, "System.read_char": {"id": "system-read_char", "params": []}, "System.file_open": {"id": "system-file_open", "params": []}, "System.file_read": {"id": "system-file_read", "params": []}, "System.file_write": {"id": "system-file_write", "params": []}, "System.file_seek": {"id": "system-file_seek", "params": []}, "System.file_tell": {"id": "system-file_tell", "params": []}, "System.file_close": {"id": "system-file_close", "params": []}, "Text.length": {"id": "text-length", "params": ["s"]}, "Text.char_at": {"id": "text-char_at", "params": ["s", "i"]}, "Text.slice": {"id": "text-slice", "params": ["s", "a", "b"]}, "Text.starts_with": {"id": "text-starts_with", "params": ["s", "prefix"]}, "Text.ends_with": {"id": "text-ends_with", "params": ["s", "suffix"]}, "Text.contains": {"id": "text-contains", "params": ["s", "sub"]}, "Text.index_of": {"id": "text-index_of", "params": ["s", "sub"]}, "Text.equals": {"id": "text-equals", "params": ["a", "b"]}, "Text.concat": {"id": "text-concat", "params": ["a", "b"]}, "Text.to_int": {"id": "text-to_int", "params": ["s"]}, "Text.from_int": {"id": "text-from_int", "params": ["n"]}, "Text.upper": {"id": "text-upper", "params": []}, "Text.lower": {"id": "text-lower", "params": []}, "Text.trim": {"id": "text-trim", "params": []}, "Text.repeat": {"id": "text-repeat", "params": []}, "Text.pad_left": {"id": "text-pad_left", "params": []}, "Text.pad_right": {"id": "text-pad_right", "params": []}, "Text.split": {"id": "text-split", "params": []}, "Text.join": {"id": "text-join", "params": []}, "Text.replace": {"id": "text-replace", "params": []}, "Time.frame": {"id": "time-frame", "params": []}, "Time.delta": {"id": "time-delta", "params": []}, "Time.elapsed": {"id": "time-elapsed", "params": []}, "Time.now": {"id": "time-now", "params": []}, "Time.since": {"id": "time-since", "params": []}, "Unicode.len": {"id": "unicode-len", "params": ["s"]}, "Unicode.byte_len": {"id": "unicode-byte_len", "params": ["s"]}, "Unicode.is_valid_utf8": {"id": "unicode-is_valid_utf8", "params": ["s"]}, "Unicode.char_at": {"id": "unicode-char_at", "params": ["s", "i"]}, "Unicode.chars": {"id": "unicode-chars", "params": ["s"]}, "Unicode.upper": {"id": "unicode-upper", "params": ["s"]}, "Unicode.lower": {"id": "unicode-lower", "params": ["s"]}, "Unicode.truncate": {"id": "unicode-truncate", "params": ["s", "n"]}, "Unicode.grapheme_len": {"id": "unicode-grapheme_len", "params": ["s"]}, "Uuid.new": {"id": "uuid-new", "params": []}, "Uuid.v4": {"id": "uuid-v4", "params": []}, "Uuid.new_v7": {"id": "uuid-new_v7", "params": []}, "Uuid.v7": {"id": "uuid-v7", "params": []}, "Uuid.parse": {"id": "uuid-parse", "params": ["s"]}, "Uuid.is_valid": {"id": "uuid-is_valid", "params": ["s"]}, "Uuid.to_text": {"id": "uuid-to_text", "params": ["id"]}, "Uuid.equals": {"id": "uuid-equals", "params": []}, "Uuid.nil": {"id": "uuid-nil", "params": []}, "World.get": {"id": "world-get", "params": []}, "World.set": {"id": "world-set", "params": []}, "World.has": {"id": "world-has", "params": []}, "World.count": {"id": "world-count", "params": []}, "World.size": {"id": "world-size", "params": []}, "World.spawn": {"id": "world-spawn", "params": []}, "World.save": {"id": "world-save", "params": []}, "World.load": {"id": "world-load", "params": []}, "World.prop_id": {"id": "world-prop_id", "params": []}, "World.field_id": {"id": "world-field_id", "params": []}, "World.model_id": {"id": "world-model_id", "params": []}, "World.kind": {"id": "world-kind", "params": []}, "World.register_prop": {"id": "world-register_prop", "params": []}, "World.attach": {"id": "world-attach", "params": []}, "World.detach": {"id": "world-detach", "params": []}, "World.query_next": {"id": "world-query_next", "params": []}, "World.despawn": {"id": "world-despawn", "params": []}, "Audio.load": {"id": "audio-load", "params": []}, "Audio.play": {"id": "audio-play", "params": []}, "Audio.play_at": {"id": "audio-play_at", "params": []}, "Audio.play_sound": {"id": "audio-play_sound", "params": []}, "Audio.play_music": {"id": "audio-play_music", "params": []}, "Audio.stop": {"id": "audio-stop", "params": []}, "Audio.stop_music": {"id": "audio-stop_music", "params": []}, "Audio.stop_all": {"id": "audio-stop_all", "params": []}, "Audio.volume": {"id": "audio-volume", "params": []}, "Audio.pitch": {"id": "audio-pitch", "params": []}, "Audio.is_playing": {"id": "audio-is_playing", "params": []}, "Audio.define": {"id": "audio-define", "params": []}, "Audio.named": {"id": "audio-named", "params": []}, "Random.range": {"id": "random-range", "params": ["low", "high"]}, "Random.chance": {"id": "random-chance", "params": ["percent"]}, "Random.seed": {"id": "random-seed", "params": ["value"]}, "Random.value": {"id": "random-value", "params": []}, "Random.int": {"id": "random-int", "params": []}, "Random.sign": {"id": "random-sign", "params": []}, "Random.weighted": {"id": "random-weighted", "params": []}, "Vector.make": {"id": "vector-make", "params": []}, "Vector.zero": {"id": "vector-zero", "params": []}, "Vector.x": {"id": "vector-x", "params": []}, "Vector.y": {"id": "vector-y", "params": []}, "Vector.add": {"id": "vector-add", "params": []}, "Vector.sub": {"id": "vector-sub", "params": []}, "Vector.scale": {"id": "vector-scale", "params": []}, "Vector.dot": {"id": "vector-dot", "params": []}, "Vector.length": {"id": "vector-length", "params": []}, "Vector.distance": {"id": "vector-distance", "params": []}, "Vector.normalize": {"id": "vector-normalize", "params": []}, "Vector.lerp": {"id": "vector-lerp", "params": []}, "Vector.rotate": {"id": "vector-rotate", "params": []}, "Vector.angle": {"id": "vector-angle", "params": []}, "Vector.from_angle": {"id": "vector-from_angle", "params": []}, "Http.get": {"id": "http-get", "params": []}, "Http.post": {"id": "http-post", "params": []}, "Http.request": {"id": "http-request", "params": []}, "Http.open": {"id": "http-open", "params": []}, "Http.set": {"id": "http-set", "params": []}, "Http.body": {"id": "http-body", "params": []}, "Http.body_bytes": {"id": "http-body_bytes", "params": []}, "Http.send": {"id": "http-send", "params": []}, "Http.poll": {"id": "http-poll", "params": []}, "Http.status": {"id": "http-status", "params": []}, "Http.ok": {"id": "http-ok", "params": []}, "Http.text": {"id": "http-text", "params": []}, "Http.body_len": {"id": "http-body_len", "params": []}, "Http.header": {"id": "http-header", "params": []}, "Http.free": {"id": "http-free", "params": []}, "Http.parse": {"id": "http-parse", "params": []}, "Http.save_to": {"id": "http-save_to", "params": []}, "Http.received": {"id": "http-received", "params": []}, "Http.expected": {"id": "http-expected", "params": []}, "IVec2.make": {"id": "ivec2-make", "params": []}, "IVec2.zero": {"id": "ivec2-zero", "params": []}, "IVec2.x": {"id": "ivec2-x", "params": []}, "IVec2.y": {"id": "ivec2-y", "params": []}, "IVec2.add": {"id": "ivec2-add", "params": []}, "IVec2.sub": {"id": "ivec2-sub", "params": []}, "IVec2.scale": {"id": "ivec2-scale", "params": []}, "IVec2.dot": {"id": "ivec2-dot", "params": []}, "IVec2.equal": {"id": "ivec2-equal", "params": []}, "IVec2.manhattan": {"id": "ivec2-manhattan", "params": []}, "IVec2.to_vector": {"id": "ivec2-to_vector", "params": []}, "IVec2.distance2": {"id": "ivec2-distance2", "params": []}, "IVec2.within": {"id": "ivec2-within", "params": []}, "IVec2.heading": {"id": "ivec2-heading", "params": []}, "IVec2.along": {"id": "ivec2-along", "params": []}, "IVec2.step": {"id": "ivec2-step", "params": []}, "Map.size": {"id": "map-size", "params": ["width", "height"]}, "Map.row": {"id": "map-row", "params": ["y", "cells"]}, "Map.tile": {"id": "map-tile", "params": ["x", "y"]}, "Map.get": {"id": "map-get", "params": []}, "Map.set": {"id": "map-set", "params": []}, "Map.fill": {"id": "map-fill", "params": []}, "Map.rect": {"id": "map-rect", "params": []}, "Map.border": {"id": "map-border", "params": []}, "Map.random_cell": {"id": "map-random_cell", "params": []}, "Map.is_solid": {"id": "map-is_solid", "params": []}, "Map.is_solid_at": {"id": "map-is_solid_at", "params": []}, "Map.width": {"id": "map-width", "params": []}, "Map.height": {"id": "map-height", "params": []}, "Map.random_cell_far": {"id": "map-random_cell_far", "params": []}, "Map.to_tile": {"id": "map-to_tile", "params": []}, "Rect.make": {"id": "rect-make", "params": []}, "Rect.x": {"id": "rect-x", "params": []}, "Rect.y": {"id": "rect-y", "params": []}, "Rect.w": {"id": "rect-w", "params": []}, "Rect.h": {"id": "rect-h", "params": []}, "Rect.right": {"id": "rect-right", "params": []}, "Rect.bottom": {"id": "rect-bottom", "params": []}, "Rect.center": {"id": "rect-center", "params": []}, "Rect.contains": {"id": "rect-contains", "params": []}, "Rect.intersects": {"id": "rect-intersects", "params": []}, "Udp.open": {"id": "udp-open", "params": []}, "Udp.port": {"id": "udp-port", "params": []}, "Udp.send": {"id": "udp-send", "params": []}, "Udp.recv": {"id": "udp-recv", "params": []}, "Udp.from_ip": {"id": "udp-from_ip", "params": []}, "Udp.from_port": {"id": "udp-from_port", "params": []}, "Udp.close": {"id": "udp-close", "params": []}, "Udp.resolve": {"id": "udp-resolve", "params": []}, "Udp.local_ip": {"id": "udp-local_ip", "params": []}, "Udp.ip": {"id": "udp-ip", "params": []}, "Udp.ip_text": {"id": "udp-ip_text", "params": []}, "BigInt.from": {"id": "bigint-from", "params": []}, "BigInt.parse": {"id": "bigint-parse", "params": []}, "BigInt.add": {"id": "bigint-add", "params": []}, "BigInt.sub": {"id": "bigint-sub", "params": []}, "BigInt.mul": {"id": "bigint-mul", "params": []}, "BigInt.neg": {"id": "bigint-neg", "params": []}, "BigInt.pow": {"id": "bigint-pow", "params": []}, "BigInt.div": {"id": "bigint-div", "params": []}, "BigInt.mod": {"id": "bigint-mod", "params": []}, "BigInt.cmp": {"id": "bigint-cmp", "params": []}, "BigInt.eq": {"id": "bigint-eq", "params": []}, "BigInt.is_zero": {"id": "bigint-is_zero", "params": []}, "BigInt.to_int": {"id": "bigint-to_int", "params": []}, "BigInt.str": {"id": "bigint-str", "params": []}, "Process.spawn": {"id": "process-spawn", "params": []}, "Process.poll": {"id": "process-poll", "params": []}, "Process.kill": {"id": "process-kill", "params": []}, "Process.free": {"id": "process-free", "params": []}, "Decimal.from": {"id": "decimal-from", "params": []}, "Decimal.parse": {"id": "decimal-parse", "params": []}, "Decimal.add": {"id": "decimal-add", "params": []}, "Decimal.sub": {"id": "decimal-sub", "params": []}, "Decimal.mul": {"id": "decimal-mul", "params": []}, "Decimal.neg": {"id": "decimal-neg", "params": []}, "Decimal.cmp": {"id": "decimal-cmp", "params": []}, "Decimal.eq": {"id": "decimal-eq", "params": []}, "Decimal.scale": {"id": "decimal-scale", "params": []}, "Decimal.rescale": {"id": "decimal-rescale", "params": []}, "Decimal.str": {"id": "decimal-str", "params": []}, "Dict.new": {"id": "dict-new", "params": []}, "Dict.set": {"id": "dict-set", "params": []}, "Dict.get": {"id": "dict-get", "params": []}, "Dict.get_or": {"id": "dict-get_or", "params": []}, "Dict.has": {"id": "dict-has", "params": []}, "Dict.remove": {"id": "dict-remove", "params": []}, "Dict.size": {"id": "dict-size", "params": []}, "Dict.clear": {"id": "dict-clear", "params": []}, "Dict.keys": {"id": "dict-keys", "params": []}, "Set.new": {"id": "set-new", "params": []}, "Set.add": {"id": "set-add", "params": []}, "Set.has": {"id": "set-has", "params": []}, "Set.remove": {"id": "set-remove", "params": []}, "Set.size": {"id": "set-size", "params": []}, "Set.clear": {"id": "set-clear", "params": []}, "Set.members": {"id": "set-members", "params": []}, "Huge.from": {"id": "huge-from", "params": []}, "Huge.add": {"id": "huge-add", "params": []}, "Huge.sub": {"id": "huge-sub", "params": []}, "Huge.mul": {"id": "huge-mul", "params": []}, "Huge.neg": {"id": "huge-neg", "params": []}, "Huge.cmp": {"id": "huge-cmp", "params": []}, "Huge.sign": {"id": "huge-sign", "params": []}, "Huge.mantissa": {"id": "huge-mantissa", "params": []}, "Huge.exp": {"id": "huge-exp", "params": []}, "Huge.str": {"id": "huge-str", "params": []}, "Angle.from_degrees": {"id": "angle-from_degrees", "params": []}, "Angle.to_degrees": {"id": "angle-to_degrees", "params": []}, "Angle.wrap": {"id": "angle-wrap", "params": []}, "Angle.sin": {"id": "angle-sin", "params": []}, "Angle.cos": {"id": "angle-cos", "params": []}, "Angle.add": {"id": "angle-add", "params": []}, "Angle.diff": {"id": "angle-diff", "params": []}, "Angle.lerp": {"id": "angle-lerp", "params": []}, "Angle.diff_degrees": {"id": "angle-diff_degrees", "params": []}, "Percent.clamp": {"id": "percent-clamp", "params": []}, "Percent.of": {"id": "percent-of", "params": []}, "Percent.lerp": {"id": "percent-lerp", "params": []}, "Percent.apply": {"id": "percent-apply", "params": []}, "Regex.compile": {"id": "regex-compile", "params": ["pattern"]}, "Regex.valid": {"id": "regex-valid", "params": ["pattern"]}, "Regex.matches": {"id": "regex-matches", "params": ["text", "pattern"]}, "Regex.test": {"id": "regex-test", "params": ["text", "re"]}, "Regex.find": {"id": "regex-find", "params": ["text", "pattern"]}, "Regex.exec": {"id": "regex-exec", "params": ["text", "re"]}, "Regex.next": {"id": "regex-next", "params": ["text", "re", "from"]}, "Regex.replace": {"id": "regex-replace", "params": ["text", "pattern", "replacement"]}, "Regex.group": {"id": "regex-group", "params": ["match", "n"]}, "Regex.group_count": {"id": "regex-group_count", "params": ["match"]}, "Regex.start": {"id": "regex-start", "params": ["match", "n"]}, "Regex.end": {"id": "regex-end", "params": ["match", "n"]}, "Regex.ok": {"id": "regex-ok", "params": ["match"]}, "Grid.line": {"id": "grid-line", "params": []}, "Grid.blocked": {"id": "grid-blocked", "params": ["wall"]}, "Grid.line_of_sight": {"id": "grid-line_of_sight", "params": ["wall"]}, "Grid.flood": {"id": "grid-flood", "params": ["wall"]}, "Grid.a_star": {"id": "grid-a_star", "params": ["wall"]}, "Anim.frame": {"id": "anim-frame", "params": ["timer", "fps", "count"]}, "Anim.once": {"id": "anim-once", "params": ["timer", "fps", "count"]}, "Anim.pingpong": {"id": "anim-pingpong", "params": ["timer", "fps", "count"]}, "Anim.finished": {"id": "anim-finished", "params": ["timer", "fps", "count"]}, "Anim.duration": {"id": "anim-duration", "params": ["fps", "count"]}, "Anim.cell_x": {"id": "anim-cell_x", "params": ["frame", "cols", "cell_w"]}, "Anim.cell_y": {"id": "anim-cell_y", "params": ["frame", "cols", "cell_h"]}, "Anim.play": {"id": "anim-play", "params": ["entity", "clip"]}, "Anim.clip": {"id": "anim-clip", "params": ["name", "frames", "fps", "mode"]}, "Anim.on_frame": {"id": "anim-on_frame", "params": ["entity", "frame"]}, "Anim.fired": {"id": "anim-fired", "params": ["entity"]}, "Motion.to": {"id": "motion-to", "params": ["entity", "dur", "ease"]}, "Tween.progress": {"id": "tween-progress", "params": ["timer", "duration"]}, "Tween.loop": {"id": "tween-loop", "params": ["timer", "duration"]}, "Tween.yoyo": {"id": "tween-yoyo", "params": ["timer", "duration"]}, "Tween.done": {"id": "tween-done", "params": ["timer", "duration"]}, "Tween.ease": {"id": "tween-ease", "params": ["t", "mode"]}, "Tween.number": {"id": "tween-number", "params": ["from", "to", "t"]}, "Tween.round": {"id": "tween-round", "params": ["from", "to", "t"]}, "Tween.point": {"id": "tween-point", "params": ["from", "to", "t"]}, "Tween.tint": {"id": "tween-tint", "params": ["from", "to", "t"]}, "Tween.to": {"id": "tween-to", "params": ["dur", "ease"]}, "Tween.chain": {"id": "tween-chain", "params": ["handle", "to", "dur", "ease"]}, "Tween.delay": {"id": "tween-delay", "params": ["handle", "ticks"]}, "Tween.value": {"id": "tween-value", "params": ["handle"]}, "Tween.stop": {"id": "tween-stop", "params": ["handle"]}, "Tween.parallel": {"id": "tween-parallel", "params": []}, "Query.count": {"id": "query-count", "params": ["prop"]}, "Query.first": {"id": "query-first", "params": ["prop"]}, "Query.nearest": {"id": "query-nearest", "params": ["prop", "pos"]}, "Query.within": {"id": "query-within", "params": ["prop", "pos", "radius"]}, "Reflect.prop": {"id": "reflect-prop", "params": ["name"]}, "Reflect.field": {"id": "reflect-field", "params": ["prop", "name"]}, "Reflect.prop_count": {"id": "reflect-prop_count", "params": []}, "Reflect.prop_name": {"id": "reflect-prop_name", "params": ["index"]}, "Reflect.field_count": {"id": "reflect-field_count", "params": ["prop"]}, "Reflect.field_name": {"id": "reflect-field_name", "params": ["prop", "index"]}, "Reflect.field_type": {"id": "reflect-field_type", "params": ["prop", "index"]}, "Reflect.get": {"id": "reflect-get", "params": ["entity", "prop", "field"]}, "Reflect.set": {"id": "reflect-set", "params": ["entity", "prop", "field", "value"]}, "Reflect.has": {"id": "reflect-has", "params": ["entity", "prop"]}, "Reflect.kind": {"id": "reflect-kind", "params": ["entity"]}, "Reflect.model": {"id": "reflect-model", "params": ["name"]}, "Reflect.serialize": {"id": "reflect-serialize", "params": []}, "Reflect.apply": {"id": "reflect-apply", "params": []}, "Camera.set": {"id": "camera-set", "params": []}, "Camera.follow": {"id": "camera-follow", "params": ["lerp"]}, "Camera.shake": {"id": "camera-shake", "params": ["amount"]}, "Camera.zoom": {"id": "camera-zoom", "params": ["scale"]}, "Camera.shake_for": {"id": "camera-shake_for", "params": []}, "Light.ambient": {"id": "light-ambient", "params": ["color"]}, "Light.point": {"id": "light-point", "params": ["radius", "color", "energy"]}, "Light.occlude": {"id": "light-occlude", "params": []}, "Light.clear_occluders": {"id": "light-clear_occluders", "params": []}, "Light.spot": {"id": "light-spot", "params": ["radius", "color", "energy", "direction", "spread"]}, "Light.falloff": {"id": "light-falloff", "params": ["exponent"]}, "Light.soft": {"id": "light-soft", "params": ["radius"]}, "Light.gel": {"id": "light-gel", "params": ["color"]}, "Light.clear_gel": {"id": "light-clear_gel", "params": []}, "Light.normal": {"id": "light-normal", "params": []}, "Light.clear_normals": {"id": "light-clear_normals", "params": []}, "Light.height": {"id": "light-height", "params": ["height"]}, "Light.time_of_day": {"id": "light-time_of_day", "params": ["t"]}, "Sprite.sheet": {"id": "sprite-sheet", "params": []}, "Sprite.cell": {"id": "sprite-cell", "params": []}, "Sprite.cell_span": {"id": "sprite-cell_span", "params": []}, "Sprite.define": {"id": "sprite-define", "params": []}, "Sprite.named": {"id": "sprite-named", "params": []}, "Sprite.draw": {"id": "sprite-draw", "params": []}, "Sprite.draw_scaled": {"id": "sprite-draw_scaled", "params": []}, "Sprite.width": {"id": "sprite-width", "params": []}, "Sprite.height": {"id": "sprite-height", "params": []}, "Sprite.strip": {"id": "sprite-strip", "params": []}, "Sprite.draw_meter": {"id": "sprite-draw_meter", "params": []}, "Assets.image": {"id": "assets-image", "params": []}, "Assets.load": {"id": "assets-load", "params": []}, "Assets.get": {"id": "assets-get", "params": []}, "Assets.enqueue": {"id": "assets-enqueue", "params": []}, "Assets.pump": {"id": "assets-pump", "params": []}, "Assets.total": {"id": "assets-total", "params": []}, "Assets.loaded": {"id": "assets-loaded", "params": []}, "Assets.ready": {"id": "assets-ready", "params": []}, "Assets.font": {"id": "assets-font", "params": []}, "Assets.progress": {"id": "assets-progress", "params": []}, "Assets.enqueue_dir": {"id": "assets-enqueue_dir", "params": []}, "Pool.live": {"id": "pool-live", "params": []}, "Pool.free": {"id": "pool-free", "params": []}, "Pool.reserved": {"id": "pool-reserved", "params": []}, "Pool.capacity": {"id": "pool-capacity", "params": []}, "Value.null": {"id": "value-null", "params": []}, "Value.int": {"id": "value-int", "params": []}, "Value.fixed": {"id": "value-fixed", "params": []}, "Value.bool": {"id": "value-bool", "params": []}, "Value.str": {"id": "value-str", "params": []}, "Value.list": {"id": "value-list", "params": []}, "Value.object": {"id": "value-object", "params": []}, "Value.add": {"id": "value-add", "params": []}, "Value.put": {"id": "value-put", "params": []}, "Value.get": {"id": "value-get", "params": []}, "Value.has": {"id": "value-has", "params": []}, "Value.at": {"id": "value-at", "params": []}, "Value.key_at": {"id": "value-key_at", "params": []}, "Value.count": {"id": "value-count", "params": []}, "Value.kind": {"id": "value-kind", "params": []}, "Value.as_int": {"id": "value-as_int", "params": []}, "Value.as_str": {"id": "value-as_str", "params": []}, "Json.encode": {"id": "json-encode", "params": []}, "Json.parse": {"id": "json-parse", "params": []}, "Job.defer": {"id": "job-defer", "params": []}, "Job.run": {"id": "job-run", "params": []}, "Job.fulfill": {"id": "job-fulfill", "params": []}, "Job.fail": {"id": "job-fail", "params": []}, "Job.cancel": {"id": "job-cancel", "params": []}, "Job.pump": {"id": "job-pump", "params": []}, "Job.done": {"id": "job-done", "params": []}, "Job.ok": {"id": "job-ok", "params": []}, "Job.failed": {"id": "job-failed", "params": []}, "Job.cancelled": {"id": "job-cancelled", "params": []}, "Job.result": {"id": "job-result", "params": []}, "Job.error": {"id": "job-error", "params": []}, "Job.pending": {"id": "job-pending", "params": []}, "Job.free": {"id": "job-free", "params": []}, "Job.parallel_for": {"id": "job-parallel_for", "params": []}, "Job.is_worker": {"id": "job-is_worker", "params": []}, "Promise.all": {"id": "promise-all", "params": []}, "Promise.race": {"id": "promise-race", "params": []}, "Promise.count_done": {"id": "promise-count_done", "params": []}, "Promise.all_done": {"id": "promise-all_done", "params": []}, "Sync.mutex": {"id": "sync-mutex", "params": []}, "Sync.lock": {"id": "sync-lock", "params": []}, "Sync.unlock": {"id": "sync-unlock", "params": []}, "Sync.try_lock": {"id": "sync-try_lock", "params": []}, "Sync.atomic": {"id": "sync-atomic", "params": []}, "Sync.get": {"id": "sync-get", "params": []}, "Sync.set": {"id": "sync-set", "params": []}, "Sync.add": {"id": "sync-add", "params": []}, "Sync.cas": {"id": "sync-cas", "params": []}, "Sync.channel": {"id": "sync-channel", "params": []}, "Sync.send": {"id": "sync-send", "params": []}, "Sync.recv": {"id": "sync-recv", "params": []}, "Sync.can_recv": {"id": "sync-can_recv", "params": []}, "Sync.len": {"id": "sync-len", "params": []}, "Sync.cpu_count": {"id": "sync-cpu_count", "params": []}, "Xml.parse": {"id": "xml-parse", "params": []}, "Xml.tag": {"id": "xml-tag", "params": []}, "Xml.text": {"id": "xml-text", "params": []}, "Xml.attr": {"id": "xml-attr", "params": []}, "Xml.attr_int": {"id": "xml-attr_int", "params": []}, "Xml.has": {"id": "xml-has", "params": []}, "Xml.attr_count": {"id": "xml-attr_count", "params": []}, "Xml.child_count": {"id": "xml-child_count", "params": []}, "Xml.child": {"id": "xml-child", "params": []}, "Xml.find": {"id": "xml-find", "params": []}, "Xml.count": {"id": "xml-count", "params": []}, "Base64.decode": {"id": "base64-decode", "params": []}, "Base64.encode": {"id": "base64-encode", "params": []}, "Tiled.read": {"id": "tiled-read", "params": []}, "Tiled.read_tsx": {"id": "tiled-read_tsx", "params": []}, "Tiled.load": {"id": "tiled-load", "params": []}, "Tiled.gid": {"id": "tiled-gid", "params": []}, "Tiled.resolve": {"id": "tiled-resolve", "params": []}, "Tiled.width": {"id": "tiled-width", "params": []}, "Tiled.height": {"id": "tiled-height", "params": []}, "Tiled.layer_count": {"id": "tiled-layer_count", "params": []}, "Tiled.layer_name": {"id": "tiled-layer_name", "params": []}, "Tiled.draw": {"id": "tiled-draw", "params": []}, "Tiled.project": {"id": "tiled-project", "params": []}, "Tiled.tree": {"id": "tiled-tree", "params": []}, "Tiled.tile_prop": {"id": "tiled-tile_prop", "params": []}, "Tiled.collide": {"id": "tiled-collide", "params": []}, "Tiled.collision_kind": {"id": "tiled-collision_kind", "params": []}, "Tiled.tile_shapes": {"id": "tiled-tile_shapes", "params": []}, "Tiled.draw_anim": {"id": "tiled-draw_anim", "params": []}, "Tiled.frame_gid": {"id": "tiled-frame_gid", "params": []}, "Tiled.animated": {"id": "tiled-animated", "params": []}, "Tiled.object_count": {"id": "tiled-object_count", "params": []}, "Tiled.object": {"id": "tiled-object", "params": []}, "Tiled.object_shape": {"id": "tiled-object_shape", "params": []}, "Tiled.prop": {"id": "tiled-prop", "params": []}, "Tiled.prop_int": {"id": "tiled-prop_int", "params": []}, "Tiled.prop_type": {"id": "tiled-prop_type", "params": []}, "Tiled.load_types": {"id": "tiled-load_types", "params": []}, "Tiled.template": {"id": "tiled-template", "params": []}, "Tiled.spawn": {"id": "tiled-spawn", "params": []}, "Tiled.spawn_layer": {"id": "tiled-spawn_layer", "params": []}, "Tiled.cell_x": {"id": "tiled-cell_x", "params": []}, "Tiled.cell_y": {"id": "tiled-cell_y", "params": []}, "Tiled.layer_kind": {"id": "tiled-layer_kind", "params": []}, "Tiled.layer_opacity": {"id": "tiled-layer_opacity", "params": []}, "Tiled.layer_tint": {"id": "tiled-layer_tint", "params": []}, "Tiled.layer_offsetx": {"id": "tiled-layer_offsetx", "params": []}, "Tiled.layer_offsety": {"id": "tiled-layer_offsety", "params": []}, "Tiled.world": {"id": "tiled-world", "params": []}, "Tiled.world_count": {"id": "tiled-world_count", "params": []}, "Tiled.world_map": {"id": "tiled-world_map", "params": []}, "Ui.build": {"id": "ui-build", "params": []}, "Ui.open": {"id": "ui-open", "params": []}, "Ui.close": {"id": "ui-close", "params": []}, "Ui.tick": {"id": "ui-tick", "params": []}, "Ui.clicked": {"id": "ui-clicked", "params": []}, "Ui.set_text": {"id": "ui-set_text", "params": []}, "Ui.render": {"id": "ui-render", "params": []}, "File.open": {"id": "file-open", "params": []}, "File.read": {"id": "file-read", "params": []}, "File.write": {"id": "file-write", "params": []}, "File.seek": {"id": "file-seek", "params": []}, "File.tell": {"id": "file-tell", "params": []}, "File.close": {"id": "file-close", "params": []}, "Font.load": {"id": "font-load", "params": []}, "Fx.sparks": {"id": "fx-sparks", "params": []}, "Fx.number": {"id": "fx-number", "params": []}, "Fx.clear": {"id": "fx-clear", "params": []}, "Prefab.spawn": {"id": "prefab-spawn", "params": []}, "Prefab.spawn_at": {"id": "prefab-spawn_at", "params": []}, "App.splash_hide": {"id": "app-splash_hide", "params": []}, "App.set_icon": {"id": "app-set_icon", "params": ["path"]}, "App.window_hide": {"id": "app-window_hide", "params": []}, "App.window_show": {"id": "app-window_show", "params": []}}, "annotations": {"@Queries": "annot-queries", "@Computed": "annot-computed", "@On": "annot-on", "@export": "annot-export", "@Sync": "annot-sync", "@Handles": "annot-handles", "@OnAttach": "annot-onattach", "@OnDespawn": "annot-ondespawn", "@OnDetach": "annot-ondetach", "@OnDisable": "annot-ondisable", "@OnEnable": "annot-onenable", "@OnQuit": "annot-onquit", "@OnSpawn": "annot-onspawn", "@OnStart": "annot-onstart", "@Owned": "annot-owned", "@Predicted": "annot-predicted", "@Public": "annot-public", "@Reads": "annot-reads", "@Server": "annot-server", "@ToClients": "annot-toclients", "@ToServer": "annot-toserver", "@Writes": "annot-writes", "@EngineSystem": "annot-enginesystem", "@Namespace": "annot-namespace", "\"@ClearColor\"": "annot-clearcolor", "@System": "annot-system"}, "namespaces": {"Angle": "ns-angle", "Anim": "ns-anim", "App": "ns-app", "Assets": "ns-assets", "Audio": "ns-audio", "Base64": "ns-base64", "BigInt": "ns-bigint", "Camera": "ns-camera", "Clock": "ns-clock", "Collision": "ns-collision", "Color": "ns-color", "Crypto": "ns-crypto", "Date": "ns-date", "DateTime": "ns-datetime", "Decimal": "ns-decimal", "Dict": "ns-dict", "Duration": "ns-duration", "Ease": "ns-ease", "File": "ns-file", "Font": "ns-font", "Fs": "ns-fs", "Fx": "ns-fx", "Grid": "ns-grid", "Hash": "ns-hash", "Http": "ns-http", "Huge": "ns-huge", "IVec2": "ns-ivec2", "Input": "ns-input", "Job": "ns-job", "Json": "ns-json", "Light": "ns-light", "List": "ns-list", "Log": "ns-log", "Map": "ns-map", "Math": "ns-math", "Memory": "ns-memory", "Mime": "ns-mime", "Motion": "ns-motion", "Network": "ns-network", "Noise": "ns-noise", "Os": "ns-os", "Path": "ns-path", "Percent": "ns-percent", "Pool": "ns-pool", "Prefab": "ns-prefab", "Process": "ns-process", "Promise": "ns-promise", "Query": "ns-query", "Random": "ns-random", "Rect": "ns-rect", "Reflect": "ns-reflect", "Regex": "ns-regex", "Save": "ns-save", "Screen": "ns-screen", "Set": "ns-set", "Sprite": "ns-sprite", "Sync": "ns-sync", "System": "ns-system", "Text": "ns-text", "Tiled": "ns-tiled", "Time": "ns-time", "Tween": "ns-tween", "Udp": "ns-udp", "Ui": "ns-ui", "Unicode": "ns-unicode", "Uuid": "ns-uuid", "Value": "ns-value", "Vector": "ns-vector", "World": "ns-world", "Xml": "ns-xml"}, "tips": {"program": "The top-level unit — one program compiles to one native game.", "property": "A named record of typed fields — a per-model component, or a plain heap record.", "model": "A named kind of thing — a fixed bundle of properties you spawn by one name.", "handler": "A named block the engine runs each frame during phase P.", "phase": "Names which stage of the frame a handler runs in.", "const": "A compile-time constant, folded into the code with no storage.", "var": "A mutable binding — at program scope, your game's persistent named state.", "let": "An immutable binding — the default choice for a value that never changes.", "function": "A function — reusable logic called positionally or with named arguments.", "fn": "A top-level function named as a value - the entry point handed to Job.parallel_for.", "prefab": "A model with preset component fields — spawn it, override what varies.", "return": "Hand a value back from a function and stop running it.", "entry": "The program's main block — runs once, top to bottom.", "import": "Splice another Ludic file's declarations into this program.", "public": "Expose a declaration's lifecycle on the public event bus.", "extern": "Bind a name to an external native symbol — the seam for platform and library calls.", "new": "Allocate a property record or an empty slice on the heap.", "namespace": "Group functions into a Name.* namespace and control its public surface.", "enum": "A named set of integer constants — names for a magic-number space.", "ui": "Declare a retained widget tree as data; the engine lays it out and draws it.", "spawn": "Create a model instance carrying the listed properties, seeding their fields.", "despawn": "Remove a model instance from the world, firing any @OnDespawn hooks.", "query": "Match every model instance carrying all the listed properties.", "self": "The model instance currently bound by the enclosing query loop.", "enable": "Re-activate a disabled property, model, or handler — its data is intact.", "disable": "Deactivate a property, model, or handler without destroying its data.", "attach": "Structurally add a property to a live model instance, seeding its fields.", "detach": "Structurally remove a property from a live model instance.", "world_attach_dyn": "Attach a property to an instance by numeric id at runtime (dynamic ECS).", "world_count": "The total number of live model instances in the world.", "world_detach_dyn": "Detach a property from an instance by numeric id at runtime (dynamic ECS).", "world_field_id": "Resolve a field name within a property to its numeric index.", "world_get": "Read one field of a model instance by numeric id (reflection ABI).", "world_has": "Test whether a model instance currently carries a property.", "world_kind": "The model id of an instance — which kind of thing it is.", "world_load": "Restore the whole world from a serialized byte buffer.", "world_model_id": "Resolve a model's name to its stable numeric id.", "world_prop_id": "Resolve a property's name to its stable numeric id.", "world_query_next": "Step to the next instance carrying a property, walking the world by id.", "world_register_prop": "Register a brand-new property at runtime and get its id (dynamic ECS).", "world_save": "Serialize the whole world into a buffer; returns the number of bytes written.", "world_set": "Write one field of a model instance by numeric id (reflection ABI).", "world_size": "The number of live model instances in the world.", "world_spawn": "Spawn an instance of a model chosen by numeric id at runtime.", "if": "A branch — run one block when a condition holds, another when it doesn't.", "else": "A branch — run one block when a condition holds, another when it doesn't.", "while": "Loop as long as a condition holds, re-checking it before each pass.", "for": "Range loop — iterate the half-open range from a up to but not including b.", "in": "The part of a for loop that names what to iterate — a range or a query.", "match": "Multi-way branch on one value, matching one or more literals per arm.", "machine": "An explicit state machine over an int var — dispatches on the store's value.", "state": "One state of a machine — its body runs while the machine sits in it.", "become": "Transition to another state of the enclosing machine, or to another scene.", "break": "Leave the enclosing loop immediately.", "continue": "Skip to the next iteration of the loop.", "where": "Filter a query loop to entities that satisfy a condition.", "try": "Recover a fallible result as a value, with a fallback — no exceptions, no unwinding.", "scene": "A mutually-exclusive game state — a title screen, the overworld, a battle.", "layer": "A named group of handlers inside a scene; layers render in declaration order.", "on": "Scene lifecycle hooks that fire as a scene becomes active or is left.", "enter": "The scene-entry hook — runs once as a scene becomes active.", "exit": "Terminate the process immediately with a status code.", "start": "Marks the one scene the game begins in.", "event": "Declare a public event carrying a flat payload that listeners react to.", "emit": "Fire an event, running every listener; as an expression it yields the veto flag.", "cancel": "Inside a listener, veto the cancellable event being emitted.", "cancellable": "Marks an event whose listeners may veto it with cancel.", "Screen.clear": "Fill the whole framebuffer with one color to start a fresh frame.", "Screen.fill_rectangle": "Draw a solid, filled rectangle at a pixel position.", "Screen.draw_rectangle": "Draw a one-pixel-thick rectangle outline (not filled).", "Screen.put_pixel": "Set a single pixel at a pixel coordinate to one color.", "Screen.draw_text": "Draw a string with the built-in font at an integer scale.", "Screen.draw_number": "Draw an integer directly, with no string allocation or conversion.", "Screen.show": "Present the finished frame — copy everything drawn this frame to the window.", "Screen.width": "The framebuffer width in pixels.", "Screen.height": "The framebuffer height in pixels.", "Screen.status": "Set the persistent one-line status/HUD string shown by the runtime.", "Screen.line": "Draw a straight line between two points.", "Screen.circle": "Draw a circle outline.", "Screen.fill_circle": "Draw a filled disc.", "Screen.triangle": "Draw a triangle outline.", "Screen.fill_triangle": "Draw a filled triangle.", "Screen.sprite": "Blit a sprite at its natural size.", "Screen.sprite_scaled": "Blit a sprite at an integer scale.", "Screen.oval": "Draw an axis-aligned ellipse outline.", "Screen.camera": "Set the world-space camera offset for the draw path.", "Screen.clip": "Restrict drawing to a screen-space rectangle.", "Screen.clip_reset": "Lift the clip rectangle (draw to the whole screen again).", "Screen.blend_mode": "Choose replace or additive pixel blending.", "Screen.measure_text": "The pixel advance width of text in the built-in font.", "Screen.pixel": "Read a framebuffer pixel (0x00RRGGBB), or 0 if off-screen.", "Screen.bar": "A filled meter: value of max over a track.", "Clock.now": "The current simulated instant.", "Clock.set": "Set the clock to an instant.", "Clock.advance": "Move the clock forward by a Duration.", "Clock.reset": "Reset the clock to the epoch (0).", "Collision.rects": "Do two rectangles overlap?", "Collision.point_rect": "Is a point inside a rectangle?", "Collision.circles": "Do two circles overlap?", "Collision.rect_circle": "Does a rectangle overlap a circle?", "Color.rgb": "Build a color from red, green, blue.", "Color.rgba": "Build a color with an alpha byte.", "Color.lerp": "Blend between two colors.", "Color.darken": "Scale a color toward black.", "Color.lighten": "Scale a color toward white.", "Color.with_alpha": "Replace a color's alpha byte.", "Crypto.sha256": "SHA-256 of a string, as 64 hex characters.", "Crypto.hmac_sha256": "Sign a message with a shared secret key.", "Crypto.verify_hmac": "Constant-time check that a MAC matches.", "Crypto.hex": "Lowercase hex of a string's bytes.", "Crypto.ct_equal": "Constant-time string equality for secrets.", "Crypto.random_bytes": "n bytes from the OS CSPRNG, as a 2n-character hex string.", "Crypto.random_hex": "Alias for random_bytes — n secure bytes as a 2n-char hex string.", "Crypto.random_u32": "One CSPRNG-drawn 32-bit integer.", "Crypto.base64": "Standard base64 (RFC 4648) of a string's bytes.", "Date.new": "A calendar day as days-since-1970.", "Date.year": "The calendar year of a date.", "Date.month": "The month (1-12) of a date.", "Date.day": "The day of the month (1-31) of a date.", "Date.weekday": "Day of the week, 0=Sunday..6=Saturday.", "Date.is_leap": "True if the year is a leap year.", "Date.days_in_month": "Number of days in a given month.", "Date.to_epoch": "Midnight UTC of the day, as a DateTime.", "Date.add_days": "The date n days later (n may be negative).", "Date.diff_days": "Whole days from b to a (a - b).", "DateTime.from": "Build an instant from its calendar parts.", "DateTime.date": "The calendar day the instant falls on.", "DateTime.add": "The instant `span` seconds later.", "DateTime.year": "The calendar year of an instant.", "DateTime.month": "The month (1-12) of an instant.", "DateTime.day": "The day of the month (1-31) of an instant.", "DateTime.weekday": "Day of the week, 0=Sunday..6=Saturday.", "DateTime.hour": "The hour of day (0-23) of an instant.", "DateTime.minute": "The minute of the hour (0-59) of an instant.", "DateTime.second": "The second of the minute (0-59) of an instant.", "DateTime.format": "Render an instant as text using a token pattern.", "DateTime.parse": "Parse text into an instant; -1 on failure.", "Duration.seconds": "A span of n whole seconds.", "Duration.minutes": "A span of n minutes, in seconds.", "Duration.hours": "A span of n hours, in seconds.", "Duration.days": "A span of n days, in seconds.", "Duration.as_seconds": "The span in whole seconds.", "Duration.as_minutes": "The span in whole minutes.", "Duration.as_hours": "The span in whole hours.", "Duration.as_days": "The span in whole days.", "Ease.in": "Accelerate from rest (quadratic ease-in).", "Ease.out": "Decelerate to rest (quadratic ease-out).", "Ease.in_out": "Ease in and then out (smoothstep).", "Ease.back": "Ease in with a small backward anticipation.", "Ease.bounce": "Ease out with a settling bounce.", "Ease.elastic": "Ease out with a springy wobble.", "Fs.exists": "Does a path exist?", "Fs.is_dir": "Is a path a directory?", "Fs.read_text": "Read a whole file as a string.", "Fs.write_text": "Write a string to a file (atomically).", "Fs.append_text": "Append a string to a file.", "Fs.remove": "Delete a file.", "Fs.size": "File size in bytes.", "Fs.mkdir": "Create a directory and its parents.", "Fs.copy": "Copy a file byte-for-byte.", "Fs.list": "Directory entries, sorted.", "Hash.of": "The fast default string hash.", "Hash.fnv1a": "FNV-1a 32-bit, named explicitly.", "Hash.crc32": "CRC-32 checksum for corruption detection.", "Hash.mix": "Avalanche one integer into a well-scrambled value.", "Hash.combine": "Fold several ints into one deterministic seed.", "Hash.of64": "The fast default 64-bit string hash.", "Hash.fnv1a_64": "FNV-1a 64-bit, named explicitly.", "Hash.mix64": "Avalanche one 64-bit integer into a well-scrambled value.", "Input.key": "The key pressed this frame as a character code (0 when nothing is pressed).", "Input.bind": "Bind a physical key to a named action, so gameplay reads the action, not the key.", "Input.rebind": "Remap an action from one key to another at runtime (rebinding menus).", "Input.poll": "Advance one frame of input; the single per-frame read behind actions and replay.", "Input.down": "Is a named action held on the frame last polled?", "Input.pressed": "Did a named action go down this frame (a one-shot edge)?", "Input.record": "Start recording polled input each frame (for deterministic replay).", "Input.replay": "Replay recorded input; poll then reads the tape, not the device.", "Input.key_down": "Is a physical key held this frame?", "Input.key_pressed": "Did a key go down this frame (edge)?", "Input.key_released": "Did a key go up this frame (edge)?", "Input.key_label": "The name to show a player for a key - in their own keyboard layout.", "Input.press": "Inject a held key (AI, tutorial, testing, network).", "Input.release": "Release an injected key.", "Input.axis": "A -1..+1 axis from two keys.", "Input.axis_i": "A -1/0/1 directional intent as a plain int, no bool->int glue.", "Input.vector": "A normalized 2D vector from four keys.", "Input.strength": "0..1 strength of a named action.", "Input.mouse_x": "The mouse x position this frame.", "Input.mouse_y": "The mouse y position this frame.", "Input.mouse_dx": "Mouse x movement since the last poll.", "Input.mouse_dy": "Mouse y movement since the last poll.", "Input.mouse_down": "Is a mouse button held?", "Input.wheel": "Scroll-wheel delta this frame.", "Input.set_mouse": "Inject the mouse state (headless / AI / testing).", "Input.pad_connected": "Is a gamepad connected?", "Input.pad_button": "Is a gamepad button held?", "Input.pad_axis": "A gamepad analog axis, -1..+1.", "Input.set_pad": "Inject a gamepad's whole state.", "Input.touch_count": "How many touch points are active?", "Input.touch_x": "The x of a touch point.", "Input.touch_y": "The y of a touch point.", "Input.set_touch": "Inject a touch point.", "Input.action": "Register a default key binding for an action (kept if already bound).", "Input.bind_pad": "Also fire a named action from a gamepad button (device-agnostic).", "Input.active": "Is a named action active right now (any bound key held, or pad button down)?", "Input.just_pressed": "Did a named action go active this frame (the deterministic on-press)?", "Input.just_released": "Did a named action go inactive this frame (the on-release edge)?", "Input.cursor_mode": "Hide / lock / confine the OS mouse cursor to the window (windowed).", "Input.move_i": "The standard top-down movement intent, -1/0/1 per axis.", "List.len": "The number of elements in a slice.", "List.push": "Append an element to the end of a slice.", "List.clear": "Remove all elements, keeping capacity.", "List.first": "The first element of a slice.", "List.last": "The last element of a slice.", "List.pop": "Remove and return the last element.", "List.swap": "Exchange the elements at two indices.", "List.contains": "Whether a value appears in a slice.", "List.index_of": "The index of a value in a slice, or -1 if absent.", "List.reverse": "Reverse the order of a slice in place.", "List.insert": "Insert an element at an index, shifting the rest up.", "List.remove_at": "Remove the element at an index, shifting the rest down.", "List.remove": "Remove the first element equal to a value.", "List.sort": "Sort a slice in ascending order, in place.", "List.sort_by": "Sort a slice ascending by a key each element maps to.", "List.sort_desc_by": "Sort a slice descending by a key each element maps to.", "List.sort_with": "Sort a slice with a full two-argument comparator.", "List.sample": "Random picks from an int slice, distinct while it can.", "Log.trace": "Log at the trace level (0) — the most verbose.", "Log.debug": "Log at the debug level (1) — development detail.", "Log.info": "Log at the info level (2) — normal operation.", "Log.warn": "Log at the warn level (3) — something looks wrong.", "Log.error": "Log at the error level (4) — a failure.", "Log.set_level": "Show only messages at level n or above (0 = all).", "Log.level": "The current logging threshold.", "Math.min": "The smaller of two values.", "Math.max": "The larger of two values.", "Math.abs": "The magnitude of a value, dropping its sign.", "Math.clamp": "Constrain a value to the range [lo, hi].", "Math.sign": "The sign of a value as -1, 0, or 1.", "Math.floor": "Round a fixed value down to the nearest whole int.", "Math.ceil": "Round a fixed value up to the nearest whole int.", "Math.round": "Round a fixed value to the nearest whole int.", "Math.lerp": "Blend between two values by a 0..1 amount.", "Math.inverse_lerp": "Find where a value sits between two endpoints as a 0..1 fraction.", "Math.remap": "Rescale a value from one range into another.", "Math.sqrt": "The square root of a fixed value.", "Math.sin": "Sine of an angle in radians.", "Math.cos": "Cosine of an angle in radians.", "Math.tan": "Tangent of an angle in radians.", "Math.hypot": "Length of the vector (x, y).", "Math.dist": "Distance between two points.", "Math.dist2": "Squared distance between two points.", "Math.deg_to_rad": "Convert degrees to radians.", "Math.rad_to_deg": "Convert radians to degrees.", "Math.posmod": "Modulo that is always non-negative.", "Math.wrap": "Wrap a value into the range [lo, hi).", "Math.ping_pong": "Bounce a counter back and forth in [0, len].", "Math.snapped": "Round a value to the nearest multiple of step.", "Math.move_toward": "Step from one value toward another by at most delta.", "Math.smoothstep": "A smooth 0..1 ramp between two edges.", "Math.atan2": "The angle of the vector (x, y), in radians.", "Math.asin": "The arcsine of a value, in radians.", "Math.acos": "The arccosine of a value, in radians.", "Math.exp": "e raised to the power x.", "Math.log": "The natural logarithm of x.", "Math.pow": "base raised to a fixed exponent.", "Memory.bytes": "Allocate n bytes.", "Memory.words": "Allocate n 32-bit words.", "Memory.copy": "Copy n bytes between buffers.", "Memory.fill": "Set n bytes to a value.", "Memory.peek": "Read one byte.", "Memory.poke": "Write one byte.", "Mime.of": "MIME type from a file extension.", "Mime.sniff": "MIME type refined by magic bytes.", "Network.send": "Put a datagram on the wire.", "Network.poll": "Read an inbound datagram.", "Network.serialize": "Serialize an entity's synced state.", "Network.apply": "Apply serialized state to an entity.", "Network.owner": "The peer that owns an entity.", "Network.set_owner": "Assign ownership of an entity.", "Network.is_server": "Is this peer the server?", "Network.is_owner": "Does this peer own the entity?", "Network.local_id": "This peer's own id.", "Noise.value2": "2D value (lattice) noise, deterministic, in [-1, 1].", "Noise.perlin2": "2D Perlin gradient noise, deterministic, in [-1, 1].", "Noise.simplex2": "2D simplex noise, the organic default, in [-1, 1].", "Noise.fbm2": "Fractal Brownian motion — octaves of simplex, in [-1, 1].", "Noise.cellular2": "Worley (cellular) F1 distance to the nearest cell point.", "Noise.cellular2_id": "The id of the nearest Worley cell — stable per cell.", "Noise.unit": "Remap a [-1,1] noise sample to [0,1].", "Os.args": "Every command-line argument, as a list.", "Os.arg_count": "How many command-line arguments there are.", "Os.arg": "The i-th command-line argument.", "Os.env": "Read an environment variable (null if unset).", "Os.env_or": "Read an environment variable, or a fallback.", "Os.has_env": "Is an environment variable set?", "Os.set_env": "Set an environment variable.", "Os.unset_env": "Remove an environment variable.", "Os.exit": "Terminate the process with a status code.", "Os.platform": "The host platform id.", "Os.arch": "The host CPU architecture.", "Os.stdout_write": "Write a string to standard output.", "Os.stderr_write": "Write a string to standard error.", "Os.save_dir": "Per-user save directory for an app.", "Os.config_dir": "Per-user config directory for an app.", "Os.cache_dir": "Per-user cache directory for an app.", "Os.temp_dir": "The system temporary directory.", "Os.pid": "This process's id.", "Path.join": "Join two path segments with the separator.", "Path.dir": "The directory part of a path.", "Path.base": "The final component of a path.", "Path.ext": "The file extension, including the dot.", "Path.stem": "The final component without its extension.", "Path.normalize": "Collapse . / .. / duplicate separators.", "Save.write": "Save a snapshot of the world.", "Save.read": "Restore the saved snapshot.", "System.run": "Run a shell command.", "System.read_char": "Read one byte from standard input.", "System.file_open": "Open a file.", "System.file_read": "Read bytes from a file.", "System.file_write": "Write bytes to a file.", "System.file_seek": "Move a file's read/write position.", "System.file_tell": "The current file position.", "System.file_close": "Close a file.", "Text.length": "The number of bytes in a string.", "Text.char_at": "The byte value at an index, 0..255.", "Text.slice": "A substring covering bytes [a, b).", "Text.starts_with": "Whether a string begins with a given prefix.", "Text.ends_with": "Whether a string ends with a given suffix.", "Text.contains": "Whether a substring appears anywhere in a string.", "Text.index_of": "The byte index of a substring, or -1 if absent.", "Text.equals": "Whether two strings have identical bytes.", "Text.concat": "Join two strings into a new one.", "Text.to_int": "Parse a leading integer from a string.", "Text.from_int": "Render an integer as a string.", "Text.upper": "An uppercased copy of a string.", "Text.lower": "A lowercased copy of a string.", "Text.trim": "A copy with surrounding whitespace removed.", "Text.repeat": "A string repeated n times.", "Text.pad_left": "Pad with spaces on the left to a width.", "Text.pad_right": "Pad with spaces on the right to a width.", "Text.split": "Split a string on a separator into a list.", "Text.join": "Join a list of strings with a separator.", "Text.replace": "Replace every occurrence of a substring.", "Time.frame": "The number of frames elapsed since start.", "Time.delta": "Seconds per frame (a fixed 1/60).", "Time.elapsed": "Seconds since start (deterministic).", "Time.now": "Wall-clock seconds (non-deterministic).", "Time.since": "Seconds elapsed from a past instant to now (non-deterministic).", "Unicode.len": "Number of code points in a string (not bytes).", "Unicode.byte_len": "Number of bytes in a string.", "Unicode.is_valid_utf8": "Is a string well-formed UTF-8?", "Unicode.char_at": "The i-th code point of a string.", "Unicode.chars": "Every code point of a string, in order.", "Unicode.upper": "Uppercase a string.", "Unicode.lower": "Lowercase a string.", "Unicode.truncate": "First n code points of a string.", "Unicode.grapheme_len": "Number of user-perceived characters.", "Uuid.new": "A new random (v4) UUID as a canonical 36-char string.", "Uuid.v4": "Explicit alias for Uuid.new — a random (v4) UUID.", "Uuid.new_v7": "A new time-ordered (v7) UUID; sorts by creation time.", "Uuid.v7": "Explicit alias for Uuid.new_v7 — a time-ordered UUID.", "Uuid.parse": "Normalise an untrusted string to a lowercase UUID, or the nil UUID.", "Uuid.is_valid": "Is s a well-formed UUID string?", "Uuid.to_text": "The canonical text form of a UUID.", "Uuid.equals": "Case-insensitive UUID equality.", "Uuid.nil": "The all-zero UUID.", "World.get": "Read a component field by id.", "World.set": "Write a component field by id.", "World.has": "Does an entity have a component?", "World.count": "The number of live entities.", "World.size": "The serialized size of the world.", "World.spawn": "Spawn an entity of a model by id.", "World.save": "Serialize the world into a buffer.", "World.load": "Restore the world from a buffer.", "World.prop_id": "Look up a component's id by name.", "World.field_id": "Look up a field's id by name.", "World.model_id": "Look up a model's id by name.", "World.kind": "The model id of an entity.", "World.register_prop": "Register a new component at runtime.", "World.attach": "Attach a component to an entity at runtime.", "World.detach": "Detach a component from an entity at runtime.", "World.query_next": "Advance a reflective query.", "World.despawn": "Despawn an entity by id — runs its @OnDespawn hooks and frees the slot.", "Audio.load": "Load a sound file into a handle.", "Audio.play": "Fire a one-shot sound.", "Audio.play_at": "Fire a one-shot with its own gain, pitch and stereo position.", "Audio.play_sound": "Fire a one-shot sound (alias of play).", "Audio.play_music": "Loop a sound as background music.", "Audio.stop": "Stop one sound.", "Audio.stop_music": "Stop the music channel.", "Audio.stop_all": "Stop every sound.", "Audio.volume": "Set the master volume.", "Audio.pitch": "Set the playback rate / pitch.", "Audio.is_playing": "Is this sound playing?", "Audio.define": "Load a sound into the bank under a name.", "Audio.named": "The handle registered under a name, or 0.", "Random.range": "A random integer in the inclusive range [low, high].", "Random.chance": "Return true with the given percent probability.", "Random.seed": "Seed the random generator so runs are reproducible.", "Random.value": "A random fixed value in [0, 1).", "Random.int": "A random integer in [0, max).", "Random.sign": "A random +1 or -1.", "Random.weighted": "An index drawn in proportion to its weight.", "Vector.make": "Build a vector from x and y components.", "Vector.zero": "The zero vector, (0, 0).", "Vector.x": "The x component of a vector.", "Vector.y": "The y component of a vector.", "Vector.add": "Component-wise sum a + b.", "Vector.sub": "Component-wise difference a - b.", "Vector.scale": "Scale a vector by a scalar.", "Vector.dot": "The dot product of two vectors.", "Vector.length": "The length (magnitude) of a vector.", "Vector.distance": "The distance between two points.", "Vector.normalize": "A unit vector in the same direction.", "Vector.lerp": "Linear interpolation between two vectors.", "Vector.rotate": "Rotate a vector by an angle in radians.", "Vector.angle": "The angle of a vector in radians.", "Vector.from_angle": "A unit vector pointing at an angle.", "Http.get": "Start an async GET request.", "Http.post": "Start an async POST with a body.", "Http.request": "Start a request with any method.", "Http.open": "Open a request to configure before sending.", "Http.set": "Set a request header before sending.", "Http.body": "Set a string request body.", "Http.body_bytes": "Set a raw byte request body.", "Http.send": "Dispatch an opened request.", "Http.poll": "Poll a request; -1 pending, 0 error, else status.", "Http.status": "The response HTTP status code.", "Http.ok": "Was the response status 2xx?", "Http.text": "The response body as text.", "Http.body_len": "The response body length in bytes.", "Http.header": "A response header value (case-insensitive).", "Http.free": "Release a request's resources.", "Http.parse": "Parse a raw HTTP response into a handle.", "Http.save_to": "Stream the response body to a file.", "Http.received": "Body bytes received so far.", "Http.expected": "The body length the server announced, or -1.", "IVec2.make": "Build an integer vector from x and y components.", "IVec2.zero": "The origin cell, (0, 0).", "IVec2.x": "The x component of an integer vector.", "IVec2.y": "The y component of an integer vector.", "IVec2.add": "Component-wise sum of two integer vectors.", "IVec2.sub": "Component-wise difference of two integer vectors.", "IVec2.scale": "Multiply both components by an integer.", "IVec2.dot": "The dot product ax*bx + ay*by.", "IVec2.equal": "True when both components match.", "IVec2.manhattan": "Grid distance |dx| + |dy|.", "IVec2.to_vector": "Widen to a fixed-point Vector.", "IVec2.distance2": "The squared distance between two points.", "IVec2.within": "Are two points within a radius of each other?", "IVec2.heading": "The direction from one point to another, in degrees.", "IVec2.along": "The point a distance along a heading.", "IVec2.step": "A -1/0/1 unit step along a heading.", "Map.size": "Set the tilemap dimensions in cells before filling rows.", "Map.row": "Fill one row of the tilemap from a string of tile characters.", "Map.tile": "Read the tile character at a cell (out-of-bounds reads answer '#').", "Map.get": "The glyph at a cell ('#' outside the map).", "Map.set": "Write one cell in place.", "Map.fill": "Every cell becomes the glyph.", "Map.rect": "Fill a rectangle of cells.", "Map.border": "The outermost ring of cells.", "Map.random_cell": "A random cell holding the glyph (seeded RNG).", "Map.is_solid": "Is a cell solid, per the Solids config?", "Map.is_solid_at": "Is the cell under a pixel position solid?", "Map.width": "The map's width in cells.", "Map.height": "The map's height in cells.", "Map.random_cell_far": "A random cell with the glyph, at least a distance from a point.", "Map.to_tile": "The tile under a pixel position.", "Rect.make": "Build a rectangle from a corner and a size.", "Rect.x": "The left edge (x position).", "Rect.y": "The top edge (y position).", "Rect.w": "The width.", "Rect.h": "The height.", "Rect.right": "The right edge, x + w.", "Rect.bottom": "The bottom edge, y + h.", "Rect.center": "The center point as a Vector.", "Rect.contains": "True when the point is inside.", "Rect.intersects": "True when two rectangles overlap.", "Udp.open": "Open a socket on a port.", "Udp.port": "The port a socket is bound to.", "Udp.send": "Send one datagram.", "Udp.recv": "Read the next waiting datagram.", "Udp.from_ip": "The sender of the last datagram read.", "Udp.from_port": "The sender's port.", "Udp.close": "Close a socket.", "Udp.resolve": "Look a host name up.", "Udp.local_ip": "This machine's address.", "Udp.ip": "Parse a dotted address.", "Udp.ip_text": "Format an address.", "BigInt.from": "Turn a plain int into a BigInt.", "BigInt.parse": "Parse decimal text into a BigInt.", "BigInt.add": "Exact sum of two big integers.", "BigInt.sub": "Exact difference of two big integers.", "BigInt.mul": "Exact product of two big integers.", "BigInt.neg": "Negate a big integer.", "BigInt.pow": "Raise a big integer to an int power.", "BigInt.div": "Divide a big integer by an int (toward zero).", "BigInt.mod": "Remainder of a big integer divided by an int.", "BigInt.cmp": "Compare two big integers: -1, 0, or 1.", "BigInt.eq": "True when two big integers are equal.", "BigInt.is_zero": "True when a big integer is zero.", "BigInt.to_int": "Narrow a big integer to a plain int (clamped).", "BigInt.str": "Render a big integer as decimal text.", "Process.spawn": "Start a program; never blocks.", "Process.poll": "-1 while running, else the exit code.", "Process.kill": "End a running child.", "Process.free": "Let a process handle go.", "Decimal.from": "Turn a whole int into a Decimal.", "Decimal.parse": "Parse decimal text like \"19.99\".", "Decimal.add": "Exact sum of two decimals.", "Decimal.sub": "Exact difference of two decimals.", "Decimal.mul": "Exact product of two decimals.", "Decimal.neg": "Negate a decimal.", "Decimal.cmp": "Compare two decimals: -1, 0, or 1.", "Decimal.eq": "True when two decimals are equal in value.", "Decimal.scale": "The number of digits after the point.", "Decimal.rescale": "Change precision (truncates toward zero).", "Decimal.str": "Render a decimal as text.", "int": "Convert a number to a whole number, truncating toward zero.", "fixed": "Convert an int (or a float) into a Q16.16 fixed-point value.", "long": "Convert a number to a whole number, truncating toward zero.", "bool": "A truth value — the result of comparisons and of and / or / not.", "float": "Convert any number to a float (or double).", "string": "Convert an int, bool, or fixed value to text; a string passes through unchanged.", "double": "Convert any number to a float (or double).", "entity": "The id/handle of a spawned model instance, as returned by self().", "pointer": "A raw address into memory — a byte buffer from bytes(n), or an FFI handle.", "words": "Allocate a raw buffer of n 32-bit words, indexable with [i].", "byte": "A raw buffer indexed one byte at a time — each buffer[i] reads or writes a byte.", "fixeds": "A buffer of fixed-point values — f[i] reads and writes a fixed.", "countdown": "An int component field the engine steps toward 0 once per Update.", "floats": "A buffer of floats (or doubles) — v[i] reads and writes one.", "doubles": "A buffer of floats (or doubles) — v[i] reads and writes one.", "pointers": "A buffer of pointers — p[i] reads and writes a pointer.", "Vector": "A 2D vector — two fixed components (x, y), copied by value.", "IVec2": "An integer 2D vector — two int components (x, y), copied by value.", "Rect": "A rectangle — position (x, y) and size (w, h), copied by value.", "void": "The absence of a value — the return type of a function that returns nothing.", "Dict.new": "Create an empty string-keyed map.", "Dict.set": "Insert or update a key.", "Dict.get": "Look up a key (0 if absent).", "Dict.get_or": "Look up a key with an explicit default.", "Dict.has": "Is a key present?", "Dict.remove": "Delete a key.", "Dict.size": "How many keys are stored.", "Dict.clear": "Remove every key.", "Dict.keys": "Every key, as a slice of strings.", "and": "The boolean combinators, spelled as words — never && or || or a bare !.", "or": "The boolean combinators, spelled as words — never && or || or a bare !.", "not": "The boolean combinators, spelled as words — never && or || or a bare !.", "print": "Print an int or string followed by a newline — for headless tests and debugging.", "quit": "Stop the game loop cleanly after the current frame finishes.", "save": "Serialize the whole world — every model instance, property, and program var — in one call.", "load": "Restore the world from a snapshot previously written by save().", "len": "The number of elements in a slice, or the byte length of a string.", "push": "Append one element to the end of a growable slice.", "abs": "The absolute value of an integer (its magnitude, never negative).", "clamp": "Constrain a value to the inclusive range [lo, hi].", "panic": "Abort with a located error message instead of crashing.", "assert": "Abort with a located message when an invariant is false.", "ok": "Wrap a success payload in a result — the happy half of try/else.", "err": "Wrap a failure message in a result — the sad half, recovered by try/else.", "is_ok": "True when a result carries a success payload.", "is_err": "True when a result carries a failure.", "some": "Wrap a present value in an option.", "none": "The empty option — a missing value.", "is_some": "True when an option holds a value.", "is_none": "True when an option is empty.", "unwrap_or": "The option value, or a fallback if empty.", "run": "Run a string as a shell command.", "getenv": "Read an environment variable, returning empty when it is unset.", "read_char": "Read one byte from standard input, or -1 at end of input.", "arg": "The i-th command-line argument as a string.", "arg_count": "The number of command-line arguments, counting the program name.", "bytes": "Allocate a raw buffer of n bytes and return a pointer to it.", "file_stderr": "The standard-error stream handle for use with file_write.", "file_stdout": "The standard-output stream handle for use with file_write.", "file_write": "Write a run of raw bytes to a stream handle.", "floor": "Floor a fixed-point value down to the nearest integer.", "max": "The larger of two integers.", "min": "The smaller of two integers.", "ui_build": "Build the declared UI tree so it can be opened and rendered.", "float_bits": "A float's IEEE bit pattern as an int, and back.", "float_from_bits": "A float's IEEE bit pattern as an int, and back.", "double_bits": "A float's IEEE bit pattern as an int, and back.", "double_from_bits": "A float's IEEE bit pattern as an int, and back.", "Set.new": "Create an empty string set.", "Set.add": "Add a member (duplicates ignored).", "Set.has": "Is a member present?", "Set.remove": "Remove a member.", "Set.size": "How many members.", "Set.clear": "Remove every member.", "Set.members": "Every member, as a slice of strings.", "@Queries": "Declare the properties a handler operates on, binding their fields by name in the body.", "@Computed": "A derived field expanded inline wherever it is read, never stored.", "@On": "Register a compile-time listener that runs whenever an event is emitted.", "@export": "Expose a function as a native symbol so a host can call it.", "@Sync": "Mark fields as replicated and models as owned so the compiler generates networking.", "@Handles": "Declarative hint naming the event or subsystem a handler is responsible for.", "@OnAttach": "Run a handler when a property is structurally attached to a live instance.", "@OnDespawn": "Run a handler when a model instance is torn down, optionally knowing why.", "@OnDetach": "Run a handler when a property is structurally detached from a live instance.", "@OnDisable": "Run a handler when a property is paused (disabled) on an instance.", "@OnEnable": "Run a handler when a paused property is re-enabled on an instance.", "@OnQuit": "Run a handler once at shutdown, after the last frame.", "@OnSpawn": "Run a handler once each time an instance of a model is spawned.", "@OnStart": "Run a handler once at boot instead of assigning it a frame phase.", "@Owned": "Give a model a network owner slot so its instances can be assigned to a peer.", "@Predicted": "Run a control handler on the owning client speculatively and on the server authoritatively.", "@Public": "Promote a lifecycle hook to a public event other modules can listen for.", "@Reads": "Declare that a handler reads a property — an analysis and scheduling hint.", "@Server": "Run a handler only on the authority; clients receive the result via @Sync.", "@ToClients": "A remote event broadcast from the server to clients — a server→clients notification.", "@ToServer": "A remote event sent from a client to the server — a client→server request.", "@Writes": "Declare that a handler writes a property — an analysis and scheduling hint.", "@EngineSystem": "Register a package's engine-owned system so the frame loop runs it each phase.", "@Namespace": "Let a package provide a Name.method(…) namespace that dispatches to name_method.", "\"@ClearColor\"": "Declare a clear colour so the Render phase auto-clears + auto-presents for you.", "@System": "Register a prebuilt binary module's system with the host at load, per phase.", "Huge.from": "Turn an int into a Huge.", "Huge.add": "Sum of two big numbers.", "Huge.sub": "Difference of two big numbers.", "Huge.mul": "Product of two big numbers.", "Huge.neg": "Negate a big number.", "Huge.cmp": "Compare two big numbers: -1, 0, or 1.", "Huge.sign": "The sign: -1, 0, or 1.", "Huge.mantissa": "The mantissa in [1, 10).", "Huge.exp": "The base-10 exponent.", "Huge.str": "Render as scientific text like 1.23e45.", "Angle.from_degrees": "Degrees to a wrapped radian angle.", "Angle.to_degrees": "Radians back to degrees.", "Angle.wrap": "Normalize any radian value to [-pi, pi).", "Angle.sin": "Sine of an angle.", "Angle.cos": "Cosine of an angle.", "Angle.add": "Add two angles (wrapped).", "Angle.diff": "Shortest signed rotation from a to b.", "Angle.lerp": "Interpolate along the shortest arc.", "Angle.diff_degrees": "The signed difference between two headings in whole degrees.", "Percent.clamp": "Clamp any fixed into [0, 1].", "Percent.of": "Clamped ratio num / den.", "Percent.lerp": "Interpolate a..b by a clamped t.", "Percent.apply": "Scale a value by a clamped percent.", "Regex.compile": "Compile a pattern once for reuse; returns an error value (null) if it is invalid.", "Regex.valid": "True if the pattern is well-formed (compiles without error).", "Regex.matches": "True if the pattern matches anywhere in the text (a search).", "Regex.test": "Like matches, but reuses an already-compiled Regex.", "Regex.find": "The first match of the pattern in the text (a Match, or null if none).", "Regex.exec": "Like find, but with an already-compiled Regex.", "Regex.next": "The next match at or after byte offset from — the basis of a find-all loop.", "Regex.replace": "Replace every match; the replacement expands \\0..\\9 group references.", "Regex.group": "The text of capture group n (group 0 is the whole match); empty if unset.", "Regex.group_count": "How many capture groups the match's pattern has.", "Regex.start": "The start byte offset of group n, or -1 if it did not participate.", "Regex.end": "The end byte offset of group n, or -1 if it did not participate.", "Regex.ok": "True if the match succeeded (the Match is non-null).", "Grid.line": "Every cell a straight line from (x0,y0) to (x1,y1) crosses (Bresenham).", "Grid.blocked": "True if the cell is out of bounds or holds the wall tile.", "Grid.line_of_sight": "True if the straight line between two cells crosses no wall.", "Grid.flood": "Every passable cell reachable from (x,y), 4-connected, in BFS order.", "Grid.a_star": "The shortest 4-connected path between two cells (A*), or an empty list.", "Anim.frame": "The looping frame index for an elapsed timer at a given fps.", "Anim.once": "A non-looping frame index that clamps on the last frame.", "Anim.pingpong": "A frame index that bounces 0..count-1..0 and repeats.", "Anim.finished": "True once a one-shot clip has run past its last frame.", "Anim.duration": "Seconds for one full cycle of a clip: count / fps.", "Anim.cell_x": "The source x (pixels) of a frame on a grid spritesheet.", "Anim.cell_y": "The source y (pixels) of a frame on a grid spritesheet.", "Anim.play": "Start (or restart) a spritesheet clip on an entity in one call.", "Anim.clip": "Register a named spritesheet clip so Anim.play can play it by name.", "Anim.on_frame": "Arm a frame event — the engine flags the tick a clip lands on this frame.", "Anim.fired": "Did the entity's clip land on its armed frame event this tick?", "Motion.to": "Start a value tween on an entity's Motion component in one call.", "Tween.progress": "A one-shot 0..1 amount, clamped, for timer over duration.", "Tween.loop": "A repeating 0..1 sawtooth amount over duration.", "Tween.yoyo": "A repeating 0..1..0 triangle amount over duration.", "Tween.done": "True once a one-shot tween's timer reaches its duration.", "Tween.ease": "Shape a 0..1 amount through an easing curve chosen by a literal mode.", "Tween.number": "Linear blend of two fixeds by amount t.", "Tween.round": "Linear blend of two ints by amount t, rounded to the nearest int.", "Tween.point": "Component-wise blend of two Vectors by amount t.", "Tween.tint": "Per-channel blend of two colors by amount t.", "Tween.to": "Start a fluent, engine-advanced tween and return a handle.", "Tween.chain": "Append a tween segment that runs after the handle's current queue.", "Tween.delay": "Append a pause to a tween handle's sequence.", "Tween.value": "The current value of a fluent tween handle this frame.", "Tween.stop": "Stop and dispose a tween handle, freezing its value.", "Tween.parallel": "Are two tween handles both finished? — a parallel completion query.", "Query.count": "How many live entities carry a property.", "Query.first": "The lowest-id live entity carrying a property, or -1.", "Query.nearest": "The bearer of prop closest to a point, by squared distance.", "Query.within": "Every bearer of prop inside a radius of a point.", "Reflect.prop": "The property id for a property name, or -1 if unknown.", "Reflect.field": "The field id of a named field within a property, or -1.", "Reflect.prop_count": "How many properties the world schema defines.", "Reflect.prop_name": "The name of the property at an index (or \"\").", "Reflect.field_count": "How many fields a property has.", "Reflect.field_name": "The name of the field at an index within a property.", "Reflect.field_type": "The type name of the field at an index within a property.", "Reflect.get": "Read one field of an entity by (prop, field) id.", "Reflect.set": "Write one field of an entity by (prop, field) id.", "Reflect.has": "Does an entity carry a property?", "Reflect.kind": "The model id of an entity.", "Reflect.model": "The model id for a model name, or -1 if unknown.", "Reflect.serialize": "Walk an entity's components into a value tree.", "Reflect.apply": "Write a value tree's fields back into an entity.", "Camera.set": "Place the camera at a world-space offset.", "Camera.follow": "Ease the camera toward centring a target point.", "Camera.shake": "Jitter the camera by up to +/- amount pixels (seeded RNG).", "Camera.zoom": "Scale the whole view about the screen centre by a Q16.16 factor (1.0 = none).", "Camera.shake_for": "Shake for a number of frames, then stop, with no bookkeeping.", "Light.ambient": "Multiply the whole scene by a tint — the night/cave modulate.", "Light.point": "Add a radial glow that falls off with distance.", "Light.occlude": "Register a rectangle that blocks light — a hard shadow caster.", "Light.clear_occluders": "Forget every occluder — call once per frame before re-registering.", "Light.spot": "A cone / flashlight light aimed at a direction with a half-angle spread.", "Light.falloff": "Set the brightness-ramp exponent for later lights (1 linear, 2 quadratic…).", "Light.soft": "Soft shadows — an occluder edge fades through a penumbra of this radius.", "Light.gel": "A colour cookie — later lights gel from their centre colour to this rim colour.", "Light.clear_gel": "Clear the gel — later lights are a flat single colour again.", "Light.normal": "Stamp a surface normal over a rectangle so lights shade it by facing (N·L).", "Light.clear_normals": "Forget every stamped normal — call once per frame before re-stamping.", "Light.height": "Set the virtual height of lights above the surface, for normal-map shading.", "Light.time_of_day": "Set the ambient tint from a 0..1 time-of-day — a day/night cycle in one value.", "Sprite.sheet": "Load a spritesheet and remember its cell grid; returns a sheet handle.", "Sprite.cell": "One cell of a sheet, by grid coords; returns a sprite id.", "Sprite.cell_span": "A sprite spanning cols x rows cells (tall/wide art).", "Sprite.define": "Name a cell for later lookup; returns its sprite id.", "Sprite.named": "Look up a named sprite's id, or -1.", "Sprite.draw": "Blit an atlas sprite at (x, y) through the camera/zoom/clip.", "Sprite.draw_scaled": "Blit an atlas sprite scaled by an integer factor.", "Sprite.width": "The atlas sprite's width in pixels.", "Sprite.height": "The atlas sprite's height in pixels.", "Sprite.strip": "A run of animation frames as consecutive sprite ids.", "Sprite.draw_meter": "A value as a row of full / half / empty icons.", "Assets.image": "Load a whole image file as one sprite; returns its id.", "Assets.load": "Alias of Assets.image.", "Assets.get": "Look up a named sprite's id (alias of Sprite.named).", "Assets.enqueue": "Queue a named image file to preload later.", "Assets.pump": "Load up to max queued assets this frame; returns how many it loaded.", "Assets.total": "How many assets are enqueued.", "Assets.loaded": "How many enqueued assets have loaded so far.", "Assets.ready": "1 once every enqueued asset has loaded.", "Assets.font": "A font loaded through the preload queue, by name.", "Assets.progress": "Loading progress as a 0..100 percent.", "Assets.enqueue_dir": "Enqueue every file of a directory, named by its file name.", "test": "A named test block, run automatically with pass/fail reporting.", "Pool.live": "How many entities are currently alive.", "Pool.free": "How many freed slots are waiting to be reused.", "Pool.reserved": "High-water: how many slots have ever been allocated.", "Pool.capacity": "The maximum number of entities.", "Value.null": "An empty null node.", "Value.int": "Wrap an int in a value node.", "Value.fixed": "Wrap a fixed in a value node.", "Value.bool": "Wrap a bool in a value node.", "Value.str": "Wrap a string in a value node.", "Value.list": "An empty list node.", "Value.object": "An empty object node.", "Value.add": "Append an item to a list; returns the list.", "Value.put": "Set a key on an object; returns the object.", "Value.get": "Read a member of an object by key.", "Value.has": "Whether an object has a member.", "Value.at": "Read a list item by index.", "Value.key_at": "The key of an object member by position.", "Value.count": "Number of items/members in a list or object.", "Value.kind": "The node's kind tag.", "Value.as_int": "Read a scalar node as an int.", "Value.as_str": "Read a str node's text.", "Json.encode": "Serialize a value tree to compact JSON text.", "Json.parse": "Parse JSON text into a value tree.", "Job.defer": "A future you resolve yourself later.", "Job.run": "Start a background compute job.", "Job.fulfill": "Resolve a pending job with a value.", "Job.fail": "Resolve a pending job as failed.", "Job.cancel": "Cancel a job before it finishes.", "Job.pump": "Advance background jobs; collect results.", "Job.done": "Has the job resolved (any outcome)?", "Job.ok": "Did the job succeed?", "Job.failed": "Did the job fail?", "Job.cancelled": "Was the job cancelled?", "Job.result": "The success value of a done job.", "Job.error": "The error code of a failed job.", "Job.pending": "How many jobs are still unresolved.", "Job.free": "Release a job slot back to the pool.", "Job.parallel_for": "Run work(i, ctx) for every i in [0, count) across all cores; returns when every call is done.", "Job.is_worker": "True on a Job.parallel_for pool thread, false on the main thread.", "Promise.all": "Succeeds when every member succeeds.", "Promise.race": "Succeeds when the first member does.", "Promise.count_done": "How many members have resolved.", "Promise.all_done": "Have all members resolved?", "Sync.mutex": "Create a cooperative lock.", "Sync.lock": "Take the lock.", "Sync.unlock": "Release the lock.", "Sync.try_lock": "Take the lock only if it is free.", "Sync.atomic": "Create an atomic counter (starts at 0).", "Sync.get": "Read the counter.", "Sync.set": "Store a value in the counter.", "Sync.add": "Add to the counter; return the new value.", "Sync.cas": "Compare-and-set the counter.", "Sync.channel": "Create a bounded int FIFO channel.", "Sync.send": "Enqueue a value (false if full).", "Sync.recv": "Dequeue the oldest value.", "Sync.can_recv": "Is there a value waiting?", "Sync.len": "How many values are queued.", "Sync.cpu_count": "The machine's logical cores (1 to 64); Job.parallel_for uses one thread per core.", "Xml.parse": "Parse XML text into an element tree.", "Xml.tag": "The element's tag name.", "Xml.text": "The element's character data.", "Xml.attr": "An attribute's value by name.", "Xml.attr_int": "An attribute parsed as an integer.", "Xml.has": "Whether an attribute is present.", "Xml.attr_count": "How many attributes the element has.", "Xml.child_count": "How many child elements.", "Xml.child": "A child element by index.", "Xml.find": "The first child with a given tag.", "Xml.count": "How many children have a given tag.", "Base64.decode": "Decode standard base64 text to bytes.", "Base64.encode": "Encode bytes as standard base64 text.", "Tiled.read": "Read a map file into the intermediate value tree.", "Tiled.read_tsx": "Read a tileset file into a value object.", "Tiled.load": "Load a map file into the runtime map model.", "Tiled.gid": "The raw GID at a cell in a tile layer.", "Tiled.resolve": "Decode a GID into tileset, local id and flip flags.", "Tiled.width": "The map width in tiles.", "Tiled.height": "The map height in tiles.", "Tiled.layer_count": "How many layers the map has.", "Tiled.layer_name": "A layer's name by index.", "Tiled.draw": "Draw every visible tile layer.", "Tiled.project": "Project a collision layer to the byte tilemap.", "Tiled.tree": "The underlying intermediate value tree.", "Tiled.tile_prop": "Whether a GID's tile carries a bool property.", "Tiled.collide": "Drive collision from per-tile metadata.", "Tiled.collision_kind": "Classify a GID's collision from its tile metadata.", "Tiled.tile_shapes": "Whether a GID's tile has a collision shape.", "Tiled.draw_anim": "Draw with animated tiles advanced to a frame.", "Tiled.frame_gid": "The current GID of an animated tile at a frame.", "Tiled.animated": "Whether a GID's tile is animated.", "Tiled.object_count": "How many objects an object layer holds.", "Tiled.object": "An object on an object layer by index.", "Tiled.object_shape": "Classify an object's shape.", "Tiled.prop": "A custom property's value, with class-default fallback.", "Tiled.prop_int": "A custom property parsed as an integer.", "Tiled.prop_type": "A custom property's declared type.", "Tiled.load_types": "Load a project custom-type table.", "Tiled.template": "Read a template file into an object value.", "Tiled.spawn": "Spawn a Ludic entity from an object.", "Tiled.spawn_layer": "Spawn every object on a layer.", "Tiled.cell_x": "The screen x of a tile cell for the map orientation.", "Tiled.cell_y": "The screen y of a tile cell for the map orientation.", "Tiled.layer_kind": "A layer's kind.", "Tiled.layer_opacity": "A layer's opacity.", "Tiled.layer_tint": "A layer's tint colour.", "Tiled.layer_offsetx": "A layer's horizontal offset.", "Tiled.layer_offsety": "A layer's vertical offset.", "Tiled.world": "Read a .world file.", "Tiled.world_count": "How many maps a world stitches.", "Tiled.world_map": "A world member map by index.", "Ui.build": "Construct every declared ui block (loads skins, measures fonts).", "Ui.open": "Make one menu active and focus its first button.", "Ui.close": "Deactivate the menu: no menu is open.", "Ui.tick": "Advance navigation by one key (the frame loop does this for you).", "Ui.clicked": "Was this control activated this frame? (polled form of UiClicked)", "Ui.set_text": "Replace a label's or button's text.", "Ui.render": "Draw the active menu.", "File.open": "Open a file (fopen); null when it cannot be opened.", "File.read": "Read up to n bytes into a buffer; returns the bytes read.", "File.write": "Write n bytes from a buffer; returns the bytes written.", "File.seek": "Move the file cursor (0 start, 1 current, 2 end).", "File.tell": "The cursor position in bytes.", "File.close": "Close a handle from File.open.", "Font.load": "Load a TrueType font; returns a font handle.", "Fx.sparks": "A burst of sparks flying out of a point.", "Fx.number": "A number that floats up from a point and fades.", "Fx.clear": "Drop every spark and number at once.", "Prefab.spawn": "Spawn a prefab chosen by name at runtime; -1 if none has that name.", "Prefab.spawn_at": "Spawn a prefab by name and place it.", "App.splash_hide": "Dismiss the boot splash.", "App.set_icon": "Set the Dock icon from an image the game ships.", "App.window_hide": "Take the game's window off the screen.", "App.window_show": "Bring the game's window back.", "Start": "Runs once at boot, before the game loop — the place to set up initial state.", "Input": "The first per-frame phase — read the keyboard and record the player's intent.", "FixedUpdate": "The deterministic simulation step — physics and gameplay meant to be reproducible.", "Update": "The ordinary per-frame game-logic step, run after Input and FixedUpdate.", "LateUpdate": "Runs each frame after Update and before Render.", "Render": "The last per-frame phase — draw the world, then call Screen.show() once.", "Overlay": "The HUD pass — runs after Render and after every engine-owned drawing system."}, "cards": {"kw-program": {"name": "program", "sig": "program Name { … }", "tip": "The top-level unit — one program compiles to one native game.", "kind": "keyword", "page": "kw-program.html", "section": "Program structure"}, "kw-property": {"name": "property", "sig": "property Name { field: T = default, … }", "tip": "A named record of typed fields — a per-model component, or a plain heap record.", "kind": "keyword", "page": "kw-property.html", "section": "Program structure"}, "kw-model": {"name": "model", "sig": "model Name { PropA, PropB, … }", "tip": "A named kind of thing — a fixed bundle of properties you spawn by one name.", "kind": "keyword", "page": "kw-model.html", "section": "Program structure"}, "kw-handler": {"name": "handler", "sig": "handler Name phase P { … }", "tip": "A named block the engine runs each frame during phase P.", "kind": "keyword", "page": "kw-handler.html", "section": "Program structure"}, "kw-phase": {"name": "phase", "sig": "phase Start | Input | Update | FixedUpdate | Render", "tip": "Names which stage of the frame a handler runs in.", "kind": "keyword", "page": "kw-phase.html", "section": "Program structure"}, "kw-const": {"name": "const", "sig": "const NAME: T = value", "tip": "A compile-time constant, folded into the code with no storage.", "kind": "keyword", "page": "kw-const.html", "section": "Program structure"}, "kw-var": {"name": "var", "sig": "var name: T = value", "tip": "A mutable binding — at program scope, your game's persistent named state.", "kind": "keyword", "page": "kw-var.html", "section": "Program structure"}, "kw-let": {"name": "let", "sig": "let name = value", "tip": "An immutable binding — the default choice for a value that never changes.", "kind": "keyword", "page": "kw-let.html", "section": "Program structure"}, "kw-function": {"name": "function", "sig": "function name(a: T, b: T) -> R { … }", "tip": "A function — reusable logic called positionally or with named arguments.", "kind": "keyword", "page": "kw-function.html", "section": "Program structure"}, "kw-fn": {"name": "fn", "sig": "fn name", "tip": "A top-level function named as a value - the entry point handed to Job.parallel_for.", "kind": "keyword", "page": "kw-fn.html", "section": "Program structure"}, "kw-prefab": {"name": "prefab", "sig": "prefab Name: Model { Comp { field: value }, … }", "tip": "A model with preset component fields — spawn it, override what varies.", "kind": "keyword", "page": "kw-prefab.html", "section": "Program structure"}, "kw-return": {"name": "return", "sig": "return value", "tip": "Hand a value back from a function and stop running it.", "kind": "keyword", "page": "kw-return.html", "section": "Program structure"}, "kw-entry": {"name": "entry", "sig": "entry { … }", "tip": "The program's main block — runs once, top to bottom.", "kind": "keyword", "page": "kw-entry.html", "section": "Program structure"}, "kw-import": {"name": "import", "sig": "import \"file.ludic\"", "tip": "Splice another Ludic file's declarations into this program.", "kind": "keyword", "page": "kw-import.html", "section": "Program structure"}, "kw-public": {"name": "public", "sig": "scene Name start public { … }", "tip": "Expose a declaration's lifecycle on the public event bus.", "kind": "keyword", "page": "kw-public.html", "section": "Program structure"}, "kw-extern": {"name": "extern", "sig": "extern function name(a: T) -> R = \"symbol\"", "tip": "Bind a name to an external native symbol — the seam for platform and library calls.", "kind": "keyword", "page": "kw-extern.html", "section": "Program structure"}, "kw-new": {"name": "new", "sig": "new Record { … } new []T", "tip": "Allocate a property record or an empty slice on the heap.", "kind": "keyword", "page": "kw-new.html", "section": "Program structure"}, "kw-namespace": {"name": "namespace", "sig": "namespace Name { export function foo(…) … internal function bar(…) … }", "tip": "Group functions into a Name.* namespace and control its public surface.", "kind": "keyword", "page": "kw-namespace.html", "section": "Program structure"}, "kw-enum": {"name": "enum", "sig": "enum Name { A, B, C }", "tip": "A named set of integer constants — names for a magic-number space.", "kind": "keyword", "page": "kw-enum.html", "section": "Program structure"}, "kw-ui": {"name": "ui", "sig": "ui { panel { … } }", "tip": "Declare a retained widget tree as data; the engine lays it out and draws it.", "kind": "keyword", "page": "kw-ui.html", "section": "Program structure"}, "kw-spawn": {"name": "spawn", "sig": "spawn Label { Prop { field: v }; … }", "tip": "Create a model instance carrying the listed properties, seeding their fields.", "kind": "keyword", "page": "kw-spawn.html", "section": "Entities & the ECS"}, "kw-despawn": {"name": "despawn", "sig": "despawn entity", "tip": "Remove a model instance from the world, firing any @OnDespawn hooks.", "kind": "keyword", "page": "kw-despawn.html", "section": "Entities & the ECS"}, "kw-query": {"name": "query", "sig": "query [PropA, PropB, {Tag}]", "tip": "Match every model instance carrying all the listed properties.", "kind": "keyword", "page": "kw-query.html", "section": "Entities & the ECS"}, "kw-self": {"name": "self", "sig": "self()", "tip": "The model instance currently bound by the enclosing query loop.", "kind": "keyword", "page": "kw-self.html", "section": "Entities & the ECS"}, "kw-enable": {"name": "enable", "sig": "enable Prop on entity", "tip": "Re-activate a disabled property, model, or handler — its data is intact.", "kind": "keyword", "page": "kw-enable.html", "section": "Entities & the ECS"}, "kw-disable": {"name": "disable", "sig": "disable Prop on entity", "tip": "Deactivate a property, model, or handler without destroying its data.", "kind": "keyword", "page": "kw-disable.html", "section": "Entities & the ECS"}, "kw-attach": {"name": "attach", "sig": "attach Prop on entity { overrides }", "tip": "Structurally add a property to a live model instance, seeding its fields.", "kind": "keyword", "page": "kw-attach.html", "section": "Entities & the ECS"}, "kw-detach": {"name": "detach", "sig": "detach Prop on entity", "tip": "Structurally remove a property from a live model instance.", "kind": "keyword", "page": "kw-detach.html", "section": "Entities & the ECS"}, "fn-world_attach_dyn": {"name": "world_attach_dyn", "sig": "world_attach_dyn(target, property)", "tip": "Attach a property to an instance by numeric id at runtime (dynamic ECS).", "kind": "builtin", "page": "fn-world_attach_dyn.html", "section": "Entities & the ECS"}, "fn-world_count": {"name": "world_count", "sig": "world_count() -> int", "tip": "The total number of live model instances in the world.", "kind": "builtin", "page": "fn-world_count.html", "section": "Entities & the ECS"}, "fn-world_detach_dyn": {"name": "world_detach_dyn", "sig": "world_detach_dyn(target, property)", "tip": "Detach a property from an instance by numeric id at runtime (dynamic ECS).", "kind": "builtin", "page": "fn-world_detach_dyn.html", "section": "Entities & the ECS"}, "fn-world_field_id": {"name": "world_field_id", "sig": "world_field_id(property, name) -> int", "tip": "Resolve a field name within a property to its numeric index.", "kind": "builtin", "page": "fn-world_field_id.html", "section": "Entities & the ECS"}, "fn-world_get": {"name": "world_get", "sig": "world_get(target, property, field) -> int", "tip": "Read one field of a model instance by numeric id (reflection ABI).", "kind": "builtin", "page": "fn-world_get.html", "section": "Entities & the ECS"}, "fn-world_has": {"name": "world_has", "sig": "world_has(target, property) -> bool", "tip": "Test whether a model instance currently carries a property.", "kind": "builtin", "page": "fn-world_has.html", "section": "Entities & the ECS"}, "fn-world_kind": {"name": "world_kind", "sig": "world_kind(target) -> int", "tip": "The model id of an instance — which kind of thing it is.", "kind": "builtin", "page": "fn-world_kind.html", "section": "Entities & the ECS"}, "fn-world_load": {"name": "world_load", "sig": "world_load(buf, len)", "tip": "Restore the whole world from a serialized byte buffer.", "kind": "builtin", "page": "fn-world_load.html", "section": "Entities & the ECS"}, "fn-world_model_id": {"name": "world_model_id", "sig": "world_model_id(name) -> int", "tip": "Resolve a model's name to its stable numeric id.", "kind": "builtin", "page": "fn-world_model_id.html", "section": "Entities & the ECS"}, "fn-world_prop_id": {"name": "world_prop_id", "sig": "world_prop_id(name) -> int", "tip": "Resolve a property's name to its stable numeric id.", "kind": "builtin", "page": "fn-world_prop_id.html", "section": "Entities & the ECS"}, "fn-world_query_next": {"name": "world_query_next", "sig": "world_query_next(property, cursor) -> entity", "tip": "Step to the next instance carrying a property, walking the world by id.", "kind": "builtin", "page": "fn-world_query_next.html", "section": "Entities & the ECS"}, "fn-world_register_prop": {"name": "world_register_prop", "sig": "world_register_prop(name, fields) -> int", "tip": "Register a brand-new property at runtime and get its id (dynamic ECS).", "kind": "builtin", "page": "fn-world_register_prop.html", "section": "Entities & the ECS"}, "fn-world_save": {"name": "world_save", "sig": "world_save(buf) -> int", "tip": "Serialize the whole world into a buffer; returns the number of bytes written.", "kind": "builtin", "page": "fn-world_save.html", "section": "Entities & the ECS"}, "fn-world_set": {"name": "world_set", "sig": "world_set(target, property, field, value)", "tip": "Write one field of a model instance by numeric id (reflection ABI).", "kind": "builtin", "page": "fn-world_set.html", "section": "Entities & the ECS"}, "fn-world_size": {"name": "world_size", "sig": "world_size() -> int", "tip": "The number of live model instances in the world.", "kind": "builtin", "page": "fn-world_size.html", "section": "Entities & the ECS"}, "fn-world_spawn": {"name": "world_spawn", "sig": "world_spawn(model) -> entity", "tip": "Spawn an instance of a model chosen by numeric id at runtime.", "kind": "builtin", "page": "fn-world_spawn.html", "section": "Entities & the ECS"}, "kw-if": {"name": "if / else", "sig": "if cond { … } else { … }", "tip": "A branch — run one block when a condition holds, another when it doesn't.", "kind": "keyword", "page": "kw-if.html", "section": "Control flow"}, "kw-while": {"name": "while", "sig": "while cond { … }", "tip": "Loop as long as a condition holds, re-checking it before each pass.", "kind": "keyword", "page": "kw-while.html", "section": "Control flow"}, "kw-for": {"name": "for … in", "sig": "for name in a .. b { … }", "tip": "Range loop — iterate the half-open range from a up to but not including b.", "kind": "keyword", "page": "kw-for.html", "section": "Control flow"}, "kw-in": {"name": "in", "sig": "for x in range | query", "tip": "The part of a for loop that names what to iterate — a range or a query.", "kind": "keyword", "page": "kw-in.html", "section": "Control flow"}, "kw-match": {"name": "match", "sig": "match value { 0, 1 => … _ => … }", "tip": "Multi-way branch on one value, matching one or more literals per arm.", "kind": "keyword", "page": "kw-match.html", "section": "Control flow"}, "kw-machine": {"name": "machine", "sig": "machine store { state Name { … } }", "tip": "An explicit state machine over an int var — dispatches on the store's value.", "kind": "keyword", "page": "kw-machine.html", "section": "Control flow"}, "kw-state": {"name": "state", "sig": "state Name { … }", "tip": "One state of a machine — its body runs while the machine sits in it.", "kind": "keyword", "page": "kw-state.html", "section": "Control flow"}, "kw-become": {"name": "become", "sig": "become Name", "tip": "Transition to another state of the enclosing machine, or to another scene.", "kind": "keyword", "page": "kw-become.html", "section": "Control flow"}, "kw-break": {"name": "break", "sig": "break", "tip": "Leave the enclosing loop immediately.", "kind": "keyword", "page": "kw-break.html", "section": "Control flow"}, "kw-continue": {"name": "continue", "sig": "continue", "tip": "Skip to the next iteration of the loop.", "kind": "keyword", "page": "kw-continue.html", "section": "Control flow"}, "kw-where": {"name": "where", "sig": "for (Binds) in query [Comps] where cond { … }", "tip": "Filter a query loop to entities that satisfy a condition.", "kind": "keyword", "page": "kw-where.html", "section": "Control flow"}, "kw-try": {"name": "try", "sig": "try EXPR else { … }", "tip": "Recover a fallible result as a value, with a fallback — no exceptions, no unwinding.", "kind": "keyword", "page": "kw-try.html", "section": "Control flow"}, "kw-scene": {"name": "scene", "sig": "scene Name [start] { on enter{} on exit{} layer … }", "tip": "A mutually-exclusive game state — a title screen, the overworld, a battle.", "kind": "keyword", "page": "kw-scene.html", "section": "Scenes & layers"}, "kw-layer": {"name": "layer", "sig": "layer Name { handlers }", "tip": "A named group of handlers inside a scene; layers render in declaration order.", "kind": "keyword", "page": "kw-layer.html", "section": "Scenes & layers"}, "kw-on": {"name": "on enter / on exit", "sig": "on enter { … } on exit { … }", "tip": "Scene lifecycle hooks that fire as a scene becomes active or is left.", "kind": "keyword", "page": "kw-on.html", "section": "Scenes & layers"}, "kw-enter": {"name": "enter", "sig": "on enter { … }", "tip": "The scene-entry hook — runs once as a scene becomes active.", "kind": "keyword", "page": "kw-enter.html", "section": "Scenes & layers"}, "kw-exit": {"name": "exit", "sig": "on exit { … }", "tip": "The scene-exit hook — runs once as a scene is left.", "kind": "keyword", "page": "kw-exit.html", "section": "Scenes & layers"}, "kw-start": {"name": "start", "sig": "scene Name start { … }", "tip": "Marks the one scene the game begins in.", "kind": "keyword", "page": "kw-start.html", "section": "Scenes & layers"}, "kw-event": {"name": "event", "sig": "event Name { field: T = default }", "tip": "Declare a public event carrying a flat payload that listeners react to.", "kind": "keyword", "page": "kw-event.html", "section": "Events"}, "kw-emit": {"name": "emit", "sig": "emit Name(field: value)", "tip": "Fire an event, running every listener; as an expression it yields the veto flag.", "kind": "keyword", "page": "kw-emit.html", "section": "Events"}, "kw-cancel": {"name": "cancel", "sig": "cancel", "tip": "Inside a listener, veto the cancellable event being emitted.", "kind": "keyword", "page": "kw-cancel.html", "section": "Events"}, "kw-cancellable": {"name": "cancellable", "sig": "event cancellable Name { … }", "tip": "Marks an event whose listeners may veto it with cancel.", "kind": "keyword", "page": "kw-cancellable.html", "section": "Events"}, "screen-clear": {"name": "Screen.clear", "sig": "Screen.clear(color)", "tip": "Fill the whole framebuffer with one color to start a fresh frame.", "kind": "namespace-method", "page": "screen-clear.html", "section": "Screen — drawing"}, "screen-fill_rectangle": {"name": "Screen.fill_rectangle", "sig": "Screen.fill_rectangle(x, y, width, height, color)", "tip": "Draw a solid, filled rectangle at a pixel position.", "kind": "namespace-method", "page": "screen-fill_rectangle.html", "section": "Screen — drawing"}, "screen-draw_rectangle": {"name": "Screen.draw_rectangle", "sig": "Screen.draw_rectangle(x, y, width, height, color)", "tip": "Draw a one-pixel-thick rectangle outline (not filled).", "kind": "namespace-method", "page": "screen-draw_rectangle.html", "section": "Screen — drawing"}, "screen-put_pixel": {"name": "Screen.put_pixel", "sig": "Screen.put_pixel(x, y, color)", "tip": "Set a single pixel at a pixel coordinate to one color.", "kind": "namespace-method", "page": "screen-put_pixel.html", "section": "Screen — drawing"}, "screen-draw_text": {"name": "Screen.draw_text", "sig": "Screen.draw_text(x, y, text, color, scale)", "tip": "Draw a string with the built-in font at an integer scale.", "kind": "namespace-method", "page": "screen-draw_text.html", "section": "Screen — drawing"}, "screen-draw_number": {"name": "Screen.draw_number", "sig": "Screen.draw_number(x, y, value, color, scale)", "tip": "Draw an integer directly, with no string allocation or conversion.", "kind": "namespace-method", "page": "screen-draw_number.html", "section": "Screen — drawing"}, "screen-show": {"name": "Screen.show", "sig": "Screen.show()", "tip": "Present the finished frame — copy everything drawn this frame to the window.", "kind": "namespace-method", "page": "screen-show.html", "section": "Screen — drawing"}, "screen-width": {"name": "Screen.width", "sig": "Screen.width() -> int", "tip": "The framebuffer width in pixels.", "kind": "namespace-method", "page": "screen-width.html", "section": "Screen — drawing"}, "screen-height": {"name": "Screen.height", "sig": "Screen.height() -> int", "tip": "The framebuffer height in pixels.", "kind": "namespace-method", "page": "screen-height.html", "section": "Screen — drawing"}, "screen-status": {"name": "Screen.status", "sig": "Screen.status(text)", "tip": "Set the persistent one-line status/HUD string shown by the runtime.", "kind": "namespace-method", "page": "screen-status.html", "section": "Screen — drawing"}, "screen-line": {"name": "Screen.line", "sig": "Screen.line(x1, y1, x2, y2, color)", "tip": "Draw a straight line between two points.", "kind": "namespace-method", "page": "screen-line.html", "section": "Screen — drawing"}, "screen-circle": {"name": "Screen.circle", "sig": "Screen.circle(x, y, radius, color)", "tip": "Draw a circle outline.", "kind": "namespace-method", "page": "screen-circle.html", "section": "Screen — drawing"}, "screen-fill_circle": {"name": "Screen.fill_circle", "sig": "Screen.fill_circle(x, y, radius, color)", "tip": "Draw a filled disc.", "kind": "namespace-method", "page": "screen-fill_circle.html", "section": "Screen — drawing"}, "screen-triangle": {"name": "Screen.triangle", "sig": "Screen.triangle(x1, y1, x2, y2, x3, y3, color)", "tip": "Draw a triangle outline.", "kind": "namespace-method", "page": "screen-triangle.html", "section": "Screen — drawing"}, "screen-fill_triangle": {"name": "Screen.fill_triangle", "sig": "Screen.fill_triangle(x1, y1, x2, y2, x3, y3, color)", "tip": "Draw a filled triangle.", "kind": "namespace-method", "page": "screen-fill_triangle.html", "section": "Screen — drawing"}, "screen-sprite": {"name": "Screen.sprite", "sig": "Screen.sprite(id, x, y)", "tip": "Blit a sprite at its natural size.", "kind": "namespace-method", "page": "screen-sprite.html", "section": "Screen — drawing"}, "screen-sprite_scaled": {"name": "Screen.sprite_scaled", "sig": "Screen.sprite_scaled(id, x, y, scale)", "tip": "Blit a sprite at an integer scale.", "kind": "namespace-method", "page": "screen-sprite_scaled.html", "section": "Screen — drawing"}, "screen-oval": {"name": "Screen.oval", "sig": "Screen.oval(x, y, rx, ry, color)", "tip": "Draw an axis-aligned ellipse outline.", "kind": "namespace-method", "page": "screen-oval.html", "section": "Screen — drawing"}, "screen-camera": {"name": "Screen.camera", "sig": "Screen.camera(x, y)", "tip": "Set the world-space camera offset for the draw path.", "kind": "namespace-method", "page": "screen-camera.html", "section": "Screen — drawing"}, "screen-clip": {"name": "Screen.clip", "sig": "Screen.clip(x, y, width, height)", "tip": "Restrict drawing to a screen-space rectangle.", "kind": "namespace-method", "page": "screen-clip.html", "section": "Screen — drawing"}, "screen-clip_reset": {"name": "Screen.clip_reset", "sig": "Screen.clip_reset()", "tip": "Lift the clip rectangle (draw to the whole screen again).", "kind": "namespace-method", "page": "screen-clip_reset.html", "section": "Screen — drawing"}, "screen-blend_mode": {"name": "Screen.blend_mode", "sig": "Screen.blend_mode(mode)", "tip": "Choose replace or additive pixel blending.", "kind": "namespace-method", "page": "screen-blend_mode.html", "section": "Screen — drawing"}, "screen-measure_text": {"name": "Screen.measure_text", "sig": "Screen.measure_text(text) -> int", "tip": "The pixel advance width of text in the built-in font.", "kind": "namespace-method", "page": "screen-measure_text.html", "section": "Screen — drawing"}, "screen-pixel": {"name": "Screen.pixel", "sig": "Screen.pixel(x, y) -> int", "tip": "Read a framebuffer pixel (0x00RRGGBB), or 0 if off-screen.", "kind": "namespace-method", "page": "screen-pixel.html", "section": "Screen — drawing"}, "screen-bar": {"name": "Screen.bar", "sig": "Screen.bar(x:, y:, width:, height:, value:, max:, color:, back:)", "tip": "A filled meter: value of max over a track.", "kind": "namespace-method", "page": "screen-bar.html", "section": "Screen — drawing"}, "clock-now": {"name": "Clock.now", "sig": "Clock.now() -> int", "tip": "The current simulated instant.", "kind": "namespace-method", "page": "clock-now.html", "section": "Clock"}, "clock-set": {"name": "Clock.set", "sig": "Clock.set(t)", "tip": "Set the clock to an instant.", "kind": "namespace-method", "page": "clock-set.html", "section": "Clock"}, "clock-advance": {"name": "Clock.advance", "sig": "Clock.advance(span)", "tip": "Move the clock forward by a Duration.", "kind": "namespace-method", "page": "clock-advance.html", "section": "Clock"}, "clock-reset": {"name": "Clock.reset", "sig": "Clock.reset()", "tip": "Reset the clock to the epoch (0).", "kind": "namespace-method", "page": "clock-reset.html", "section": "Clock"}, "collision-rects": {"name": "Collision.rects", "sig": "Collision.rects(ax, ay, aw, ah, bx, by, bw, bh) -> bool", "tip": "Do two rectangles overlap?", "kind": "namespace-method", "page": "collision-rects.html", "section": "Collision"}, "collision-point_rect": {"name": "Collision.point_rect", "sig": "Collision.point_rect(px, py, rx, ry, rw, rh) -> bool", "tip": "Is a point inside a rectangle?", "kind": "namespace-method", "page": "collision-point_rect.html", "section": "Collision"}, "collision-circles": {"name": "Collision.circles", "sig": "Collision.circles(ax, ay, ar, bx, by, br) -> bool", "tip": "Do two circles overlap?", "kind": "namespace-method", "page": "collision-circles.html", "section": "Collision"}, "collision-rect_circle": {"name": "Collision.rect_circle", "sig": "Collision.rect_circle(rx, ry, rw, rh, cx, cy, cr) -> bool", "tip": "Does a rectangle overlap a circle?", "kind": "namespace-method", "page": "collision-rect_circle.html", "section": "Collision"}, "color-rgb": {"name": "Color.rgb", "sig": "Color.rgb(r, g, b) -> int", "tip": "Build a color from red, green, blue.", "kind": "namespace-method", "page": "color-rgb.html", "section": "Color functions"}, "color-rgba": {"name": "Color.rgba", "sig": "Color.rgba(r, g, b, a) -> int", "tip": "Build a color with an alpha byte.", "kind": "namespace-method", "page": "color-rgba.html", "section": "Color functions"}, "color-lerp": {"name": "Color.lerp", "sig": "Color.lerp(c0, c1, t) -> int", "tip": "Blend between two colors.", "kind": "namespace-method", "page": "color-lerp.html", "section": "Color functions"}, "color-darken": {"name": "Color.darken", "sig": "Color.darken(c, amount) -> int", "tip": "Scale a color toward black.", "kind": "namespace-method", "page": "color-darken.html", "section": "Color functions"}, "color-lighten": {"name": "Color.lighten", "sig": "Color.lighten(c, amount) -> int", "tip": "Scale a color toward white.", "kind": "namespace-method", "page": "color-lighten.html", "section": "Color functions"}, "color-with_alpha": {"name": "Color.with_alpha", "sig": "Color.with_alpha(c, a) -> int", "tip": "Replace a color's alpha byte.", "kind": "namespace-method", "page": "color-with_alpha.html", "section": "Color functions"}, "crypto-sha256": {"name": "Crypto.sha256", "sig": "Crypto.sha256(s) -> string", "tip": "SHA-256 of a string, as 64 hex characters.", "kind": "namespace-method", "page": "crypto-sha256.html", "section": "Crypto"}, "crypto-hmac_sha256": {"name": "Crypto.hmac_sha256", "sig": "Crypto.hmac_sha256(key, msg) -> string", "tip": "Sign a message with a shared secret key.", "kind": "namespace-method", "page": "crypto-hmac_sha256.html", "section": "Crypto"}, "crypto-verify_hmac": {"name": "Crypto.verify_hmac", "sig": "Crypto.verify_hmac(key, msg, mac) -> bool", "tip": "Constant-time check that a MAC matches.", "kind": "namespace-method", "page": "crypto-verify_hmac.html", "section": "Crypto"}, "crypto-hex": {"name": "Crypto.hex", "sig": "Crypto.hex(s) -> string", "tip": "Lowercase hex of a string's bytes.", "kind": "namespace-method", "page": "crypto-hex.html", "section": "Crypto"}, "crypto-ct_equal": {"name": "Crypto.ct_equal", "sig": "Crypto.ct_equal(a, b) -> bool", "tip": "Constant-time string equality for secrets.", "kind": "namespace-method", "page": "crypto-ct_equal.html", "section": "Crypto"}, "crypto-random_bytes": {"name": "Crypto.random_bytes", "sig": "Crypto.random_bytes(n) -> string", "tip": "n bytes from the OS CSPRNG, as a 2n-character hex string.", "kind": "namespace-method", "page": "crypto-random_bytes.html", "section": "Crypto"}, "crypto-random_hex": {"name": "Crypto.random_hex", "sig": "Crypto.random_hex(n) -> string", "tip": "Alias for random_bytes — n secure bytes as a 2n-char hex string.", "kind": "namespace-method", "page": "crypto-random_hex.html", "section": "Crypto"}, "crypto-random_u32": {"name": "Crypto.random_u32", "sig": "Crypto.random_u32() -> int", "tip": "One CSPRNG-drawn 32-bit integer.", "kind": "namespace-method", "page": "crypto-random_u32.html", "section": "Crypto"}, "crypto-base64": {"name": "Crypto.base64", "sig": "Crypto.base64(s) -> string", "tip": "Standard base64 (RFC 4648) of a string's bytes.", "kind": "namespace-method", "page": "crypto-base64.html", "section": "Crypto"}, "date-new": {"name": "Date.new", "sig": "Date.new(year, month, day) -> int", "tip": "A calendar day as days-since-1970.", "kind": "namespace-method", "page": "date-new.html", "section": "Date"}, "date-year": {"name": "Date.year", "sig": "Date.year(date) -> int", "tip": "The calendar year of a date.", "kind": "namespace-method", "page": "date-year.html", "section": "Date"}, "date-month": {"name": "Date.month", "sig": "Date.month(date) -> int", "tip": "The month (1-12) of a date.", "kind": "namespace-method", "page": "date-month.html", "section": "Date"}, "date-day": {"name": "Date.day", "sig": "Date.day(date) -> int", "tip": "The day of the month (1-31) of a date.", "kind": "namespace-method", "page": "date-day.html", "section": "Date"}, "date-weekday": {"name": "Date.weekday", "sig": "Date.weekday(date) -> int", "tip": "Day of the week, 0=Sunday..6=Saturday.", "kind": "namespace-method", "page": "date-weekday.html", "section": "Date"}, "date-is_leap": {"name": "Date.is_leap", "sig": "Date.is_leap(year) -> bool", "tip": "True if the year is a leap year.", "kind": "namespace-method", "page": "date-is_leap.html", "section": "Date"}, "date-days_in_month": {"name": "Date.days_in_month", "sig": "Date.days_in_month(year, month) -> int", "tip": "Number of days in a given month.", "kind": "namespace-method", "page": "date-days_in_month.html", "section": "Date"}, "date-to_epoch": {"name": "Date.to_epoch", "sig": "Date.to_epoch(date) -> int", "tip": "Midnight UTC of the day, as a DateTime.", "kind": "namespace-method", "page": "date-to_epoch.html", "section": "Date"}, "date-add_days": {"name": "Date.add_days", "sig": "Date.add_days(date, n) -> int", "tip": "The date n days later (n may be negative).", "kind": "namespace-method", "page": "date-add_days.html", "section": "Date"}, "date-diff_days": {"name": "Date.diff_days", "sig": "Date.diff_days(a, b) -> int", "tip": "Whole days from b to a (a - b).", "kind": "namespace-method", "page": "date-diff_days.html", "section": "Date"}, "datetime-from": {"name": "DateTime.from", "sig": "DateTime.from(year, month, day, hour, minute, second) -> int", "tip": "Build an instant from its calendar parts.", "kind": "namespace-method", "page": "datetime-from.html", "section": "DateTime"}, "datetime-date": {"name": "DateTime.date", "sig": "DateTime.date(dt) -> int", "tip": "The calendar day the instant falls on.", "kind": "namespace-method", "page": "datetime-date.html", "section": "DateTime"}, "datetime-add": {"name": "DateTime.add", "sig": "DateTime.add(dt, span) -> int", "tip": "The instant `span` seconds later.", "kind": "namespace-method", "page": "datetime-add.html", "section": "DateTime"}, "datetime-year": {"name": "DateTime.year", "sig": "DateTime.year(dt) -> int", "tip": "The calendar year of an instant.", "kind": "namespace-method", "page": "datetime-year.html", "section": "DateTime"}, "datetime-month": {"name": "DateTime.month", "sig": "DateTime.month(dt) -> int", "tip": "The month (1-12) of an instant.", "kind": "namespace-method", "page": "datetime-month.html", "section": "DateTime"}, "datetime-day": {"name": "DateTime.day", "sig": "DateTime.day(dt) -> int", "tip": "The day of the month (1-31) of an instant.", "kind": "namespace-method", "page": "datetime-day.html", "section": "DateTime"}, "datetime-weekday": {"name": "DateTime.weekday", "sig": "DateTime.weekday(dt) -> int", "tip": "Day of the week, 0=Sunday..6=Saturday.", "kind": "namespace-method", "page": "datetime-weekday.html", "section": "DateTime"}, "datetime-hour": {"name": "DateTime.hour", "sig": "DateTime.hour(dt) -> int", "tip": "The hour of day (0-23) of an instant.", "kind": "namespace-method", "page": "datetime-hour.html", "section": "DateTime"}, "datetime-minute": {"name": "DateTime.minute", "sig": "DateTime.minute(dt) -> int", "tip": "The minute of the hour (0-59) of an instant.", "kind": "namespace-method", "page": "datetime-minute.html", "section": "DateTime"}, "datetime-second": {"name": "DateTime.second", "sig": "DateTime.second(dt) -> int", "tip": "The second of the minute (0-59) of an instant.", "kind": "namespace-method", "page": "datetime-second.html", "section": "DateTime"}, "datetime-format": {"name": "DateTime.format", "sig": "DateTime.format(dt, pattern) -> string", "tip": "Render an instant as text using a token pattern.", "kind": "namespace-method", "page": "datetime-format.html", "section": "DateTime"}, "datetime-parse": {"name": "DateTime.parse", "sig": "DateTime.parse(text, pattern) -> int", "tip": "Parse text into an instant; -1 on failure.", "kind": "namespace-method", "page": "datetime-parse.html", "section": "DateTime"}, "duration-seconds": {"name": "Duration.seconds", "sig": "Duration.seconds(n) -> int", "tip": "A span of n whole seconds.", "kind": "namespace-method", "page": "duration-seconds.html", "section": "Duration"}, "duration-minutes": {"name": "Duration.minutes", "sig": "Duration.minutes(n) -> int", "tip": "A span of n minutes, in seconds.", "kind": "namespace-method", "page": "duration-minutes.html", "section": "Duration"}, "duration-hours": {"name": "Duration.hours", "sig": "Duration.hours(n) -> int", "tip": "A span of n hours, in seconds.", "kind": "namespace-method", "page": "duration-hours.html", "section": "Duration"}, "duration-days": {"name": "Duration.days", "sig": "Duration.days(n) -> int", "tip": "A span of n days, in seconds.", "kind": "namespace-method", "page": "duration-days.html", "section": "Duration"}, "duration-as_seconds": {"name": "Duration.as_seconds", "sig": "Duration.as_seconds(span) -> int", "tip": "The span in whole seconds.", "kind": "namespace-method", "page": "duration-as_seconds.html", "section": "Duration"}, "duration-as_minutes": {"name": "Duration.as_minutes", "sig": "Duration.as_minutes(span) -> int", "tip": "The span in whole minutes.", "kind": "namespace-method", "page": "duration-as_minutes.html", "section": "Duration"}, "duration-as_hours": {"name": "Duration.as_hours", "sig": "Duration.as_hours(span) -> int", "tip": "The span in whole hours.", "kind": "namespace-method", "page": "duration-as_hours.html", "section": "Duration"}, "duration-as_days": {"name": "Duration.as_days", "sig": "Duration.as_days(span) -> int", "tip": "The span in whole days.", "kind": "namespace-method", "page": "duration-as_days.html", "section": "Duration"}, "ease-in": {"name": "Ease.in", "sig": "Ease.in(t) -> fixed", "tip": "Accelerate from rest (quadratic ease-in).", "kind": "namespace-method", "page": "ease-in.html", "section": "Ease"}, "ease-out": {"name": "Ease.out", "sig": "Ease.out(t) -> fixed", "tip": "Decelerate to rest (quadratic ease-out).", "kind": "namespace-method", "page": "ease-out.html", "section": "Ease"}, "ease-in_out": {"name": "Ease.in_out", "sig": "Ease.in_out(t) -> fixed", "tip": "Ease in and then out (smoothstep).", "kind": "namespace-method", "page": "ease-in_out.html", "section": "Ease"}, "ease-back": {"name": "Ease.back", "sig": "Ease.back(t) -> fixed", "tip": "Ease in with a small backward anticipation.", "kind": "namespace-method", "page": "ease-back.html", "section": "Ease"}, "ease-bounce": {"name": "Ease.bounce", "sig": "Ease.bounce(t) -> fixed", "tip": "Ease out with a settling bounce.", "kind": "namespace-method", "page": "ease-bounce.html", "section": "Ease"}, "ease-elastic": {"name": "Ease.elastic", "sig": "Ease.elastic(t) -> fixed", "tip": "Ease out with a springy wobble.", "kind": "namespace-method", "page": "ease-elastic.html", "section": "Ease"}, "fs-exists": {"name": "Fs.exists", "sig": "Fs.exists(p) -> bool", "tip": "Does a path exist?", "kind": "namespace-method", "page": "fs-exists.html", "section": "Fs"}, "fs-is_dir": {"name": "Fs.is_dir", "sig": "Fs.is_dir(p) -> bool", "tip": "Is a path a directory?", "kind": "namespace-method", "page": "fs-is_dir.html", "section": "Fs"}, "fs-read_text": {"name": "Fs.read_text", "sig": "Fs.read_text(p) -> string", "tip": "Read a whole file as a string.", "kind": "namespace-method", "page": "fs-read_text.html", "section": "Fs"}, "fs-write_text": {"name": "Fs.write_text", "sig": "Fs.write_text(p, s) -> bool", "tip": "Write a string to a file (atomically).", "kind": "namespace-method", "page": "fs-write_text.html", "section": "Fs"}, "fs-append_text": {"name": "Fs.append_text", "sig": "Fs.append_text(p, s) -> bool", "tip": "Append a string to a file.", "kind": "namespace-method", "page": "fs-append_text.html", "section": "Fs"}, "fs-remove": {"name": "Fs.remove", "sig": "Fs.remove(p) -> bool", "tip": "Delete a file.", "kind": "namespace-method", "page": "fs-remove.html", "section": "Fs"}, "fs-size": {"name": "Fs.size", "sig": "Fs.size(p) -> int", "tip": "File size in bytes.", "kind": "namespace-method", "page": "fs-size.html", "section": "Fs"}, "fs-mkdir": {"name": "Fs.mkdir", "sig": "Fs.mkdir(p) -> bool", "tip": "Create a directory and its parents.", "kind": "namespace-method", "page": "fs-mkdir.html", "section": "Fs"}, "fs-copy": {"name": "Fs.copy", "sig": "Fs.copy(src, dst) -> bool", "tip": "Copy a file byte-for-byte.", "kind": "namespace-method", "page": "fs-copy.html", "section": "Fs"}, "fs-list": {"name": "Fs.list", "sig": "Fs.list(dir) -> []string", "tip": "Directory entries, sorted.", "kind": "namespace-method", "page": "fs-list.html", "section": "Fs"}, "hash-of": {"name": "Hash.of", "sig": "Hash.of(s) -> int", "tip": "The fast default string hash.", "kind": "namespace-method", "page": "hash-of.html", "section": "Hash"}, "hash-fnv1a": {"name": "Hash.fnv1a", "sig": "Hash.fnv1a(s) -> int", "tip": "FNV-1a 32-bit, named explicitly.", "kind": "namespace-method", "page": "hash-fnv1a.html", "section": "Hash"}, "hash-crc32": {"name": "Hash.crc32", "sig": "Hash.crc32(s) -> int", "tip": "CRC-32 checksum for corruption detection.", "kind": "namespace-method", "page": "hash-crc32.html", "section": "Hash"}, "hash-mix": {"name": "Hash.mix", "sig": "Hash.mix(x) -> int", "tip": "Avalanche one integer into a well-scrambled value.", "kind": "namespace-method", "page": "hash-mix.html", "section": "Hash"}, "hash-combine": {"name": "Hash.combine", "sig": "Hash.combine(...) -> int", "tip": "Fold several ints into one deterministic seed.", "kind": "namespace-method", "page": "hash-combine.html", "section": "Hash"}, "hash-of64": {"name": "Hash.of64", "sig": "Hash.of64(s) -> long", "tip": "The fast default 64-bit string hash.", "kind": "namespace-method", "page": "hash-of64.html", "section": "Hash"}, "hash-fnv1a_64": {"name": "Hash.fnv1a_64", "sig": "Hash.fnv1a_64(s) -> long", "tip": "FNV-1a 64-bit, named explicitly.", "kind": "namespace-method", "page": "hash-fnv1a_64.html", "section": "Hash"}, "hash-mix64": {"name": "Hash.mix64", "sig": "Hash.mix64(x) -> long", "tip": "Avalanche one 64-bit integer into a well-scrambled value.", "kind": "namespace-method", "page": "hash-mix64.html", "section": "Hash"}, "input-key": {"name": "Input.key", "sig": "Input.key() -> int", "tip": "The key pressed this frame as a character code (0 when nothing is pressed).", "kind": "namespace-method", "page": "input-key.html", "section": "Input"}, "input-bind": {"name": "Input.bind", "sig": "Input.bind(action: str, key: int) -> void", "tip": "Bind a physical key to a named action, so gameplay reads the action, not the key.", "kind": "namespace-method", "page": "input-bind.html", "section": "Input"}, "input-rebind": {"name": "Input.rebind", "sig": "Input.rebind(action: str, from: int, to: int) -> void", "tip": "Remap an action from one key to another at runtime (rebinding menus).", "kind": "namespace-method", "page": "input-rebind.html", "section": "Input"}, "input-poll": {"name": "Input.poll", "sig": "Input.poll() -> int", "tip": "Advance one frame of input; the single per-frame read behind actions and replay.", "kind": "namespace-method", "page": "input-poll.html", "section": "Input"}, "input-down": {"name": "Input.down", "sig": "Input.down(action: str) -> bool", "tip": "Is a named action held on the frame last polled?", "kind": "namespace-method", "page": "input-down.html", "section": "Input"}, "input-pressed": {"name": "Input.pressed", "sig": "Input.pressed(action: str) -> bool", "tip": "Did a named action go down this frame (a one-shot edge)?", "kind": "namespace-method", "page": "input-pressed.html", "section": "Input"}, "input-record": {"name": "Input.record", "sig": "Input.record() -> void", "tip": "Start recording polled input each frame (for deterministic replay).", "kind": "namespace-method", "page": "input-record.html", "section": "Input"}, "input-replay": {"name": "Input.replay", "sig": "Input.replay() -> void", "tip": "Replay recorded input; poll then reads the tape, not the device.", "kind": "namespace-method", "page": "input-replay.html", "section": "Input"}, "input-key_down": {"name": "Input.key_down", "sig": "Input.key_down(key) -> bool", "tip": "Is a physical key held this frame?", "kind": "namespace-method", "page": "input-key_down.html", "section": "Input"}, "input-key_pressed": {"name": "Input.key_pressed", "sig": "Input.key_pressed(key) -> bool", "tip": "Did a key go down this frame (edge)?", "kind": "namespace-method", "page": "input-key_pressed.html", "section": "Input"}, "input-key_released": {"name": "Input.key_released", "sig": "Input.key_released(key) -> bool", "tip": "Did a key go up this frame (edge)?", "kind": "namespace-method", "page": "input-key_released.html", "section": "Input"}, "input-key_label": {"name": "Input.key_label", "sig": "Input.key_label(key) -> string", "tip": "The name to show a player for a key - in their own keyboard layout.", "kind": "namespace-method", "page": "input-key_label.html", "section": "Input"}, "input-press": {"name": "Input.press", "sig": "Input.press(key)", "tip": "Inject a held key (AI, tutorial, testing, network).", "kind": "namespace-method", "page": "input-press.html", "section": "Input"}, "input-release": {"name": "Input.release", "sig": "Input.release(key)", "tip": "Release an injected key.", "kind": "namespace-method", "page": "input-release.html", "section": "Input"}, "input-axis": {"name": "Input.axis", "sig": "Input.axis(neg, pos) -> fixed", "tip": "A -1..+1 axis from two keys.", "kind": "namespace-method", "page": "input-axis.html", "section": "Input"}, "input-axis_i": {"name": "Input.axis_i", "sig": "Input.axis_i(neg, pos) -> int", "tip": "A -1/0/1 directional intent as a plain int, no bool->int glue.", "kind": "namespace-method", "page": "input-axis_i.html", "section": "Input"}, "input-vector": {"name": "Input.vector", "sig": "Input.vector(left, right, up, down) -> Vector", "tip": "A normalized 2D vector from four keys.", "kind": "namespace-method", "page": "input-vector.html", "section": "Input"}, "input-strength": {"name": "Input.strength", "sig": "Input.strength(action) -> fixed", "tip": "0..1 strength of a named action.", "kind": "namespace-method", "page": "input-strength.html", "section": "Input"}, "input-mouse_x": {"name": "Input.mouse_x", "sig": "Input.mouse_x() -> int", "tip": "The mouse x position this frame.", "kind": "namespace-method", "page": "input-mouse_x.html", "section": "Input"}, "input-mouse_y": {"name": "Input.mouse_y", "sig": "Input.mouse_y() -> int", "tip": "The mouse y position this frame.", "kind": "namespace-method", "page": "input-mouse_y.html", "section": "Input"}, "input-mouse_dx": {"name": "Input.mouse_dx", "sig": "Input.mouse_dx() -> int", "tip": "Mouse x movement since the last poll.", "kind": "namespace-method", "page": "input-mouse_dx.html", "section": "Input"}, "input-mouse_dy": {"name": "Input.mouse_dy", "sig": "Input.mouse_dy() -> int", "tip": "Mouse y movement since the last poll.", "kind": "namespace-method", "page": "input-mouse_dy.html", "section": "Input"}, "input-mouse_down": {"name": "Input.mouse_down", "sig": "Input.mouse_down(button) -> bool", "tip": "Is a mouse button held?", "kind": "namespace-method", "page": "input-mouse_down.html", "section": "Input"}, "input-wheel": {"name": "Input.wheel", "sig": "Input.wheel() -> int", "tip": "Scroll-wheel delta this frame.", "kind": "namespace-method", "page": "input-wheel.html", "section": "Input"}, "input-set_mouse": {"name": "Input.set_mouse", "sig": "Input.set_mouse(x, y, buttons, wheel)", "tip": "Inject the mouse state (headless / AI / testing).", "kind": "namespace-method", "page": "input-set_mouse.html", "section": "Input"}, "input-pad_connected": {"name": "Input.pad_connected", "sig": "Input.pad_connected(pad) -> bool", "tip": "Is a gamepad connected?", "kind": "namespace-method", "page": "input-pad_connected.html", "section": "Input"}, "input-pad_button": {"name": "Input.pad_button", "sig": "Input.pad_button(pad, button) -> bool", "tip": "Is a gamepad button held?", "kind": "namespace-method", "page": "input-pad_button.html", "section": "Input"}, "input-pad_axis": {"name": "Input.pad_axis", "sig": "Input.pad_axis(pad, axis) -> fixed", "tip": "A gamepad analog axis, -1..+1.", "kind": "namespace-method", "page": "input-pad_axis.html", "section": "Input"}, "input-set_pad": {"name": "Input.set_pad", "sig": "Input.set_pad(pad, connected, buttons, lx, ly, rx, ry)", "tip": "Inject a gamepad's whole state.", "kind": "namespace-method", "page": "input-set_pad.html", "section": "Input"}, "input-touch_count": {"name": "Input.touch_count", "sig": "Input.touch_count() -> int", "tip": "How many touch points are active?", "kind": "namespace-method", "page": "input-touch_count.html", "section": "Input"}, "input-touch_x": {"name": "Input.touch_x", "sig": "Input.touch_x(index) -> int", "tip": "The x of a touch point.", "kind": "namespace-method", "page": "input-touch_x.html", "section": "Input"}, "input-touch_y": {"name": "Input.touch_y", "sig": "Input.touch_y(index) -> int", "tip": "The y of a touch point.", "kind": "namespace-method", "page": "input-touch_y.html", "section": "Input"}, "input-set_touch": {"name": "Input.set_touch", "sig": "Input.set_touch(index, x, y, active)", "tip": "Inject a touch point.", "kind": "namespace-method", "page": "input-set_touch.html", "section": "Input"}, "input-action": {"name": "Input.action", "sig": "Input.action(action: str, key: int) -> void", "tip": "Register a default key binding for an action (kept if already bound).", "kind": "namespace-method", "page": "input-action.html", "section": "Input"}, "input-bind_pad": {"name": "Input.bind_pad", "sig": "Input.bind_pad(action: str, button: int) -> void", "tip": "Also fire a named action from a gamepad button (device-agnostic).", "kind": "namespace-method", "page": "input-bind_pad.html", "section": "Input"}, "input-active": {"name": "Input.active", "sig": "Input.active(action: str) -> bool", "tip": "Is a named action active right now (any bound key held, or pad button down)?", "kind": "namespace-method", "page": "input-active.html", "section": "Input"}, "input-just_pressed": {"name": "Input.just_pressed", "sig": "Input.just_pressed(action: str) -> bool", "tip": "Did a named action go active this frame (the deterministic on-press)?", "kind": "namespace-method", "page": "input-just_pressed.html", "section": "Input"}, "input-just_released": {"name": "Input.just_released", "sig": "Input.just_released(action: str) -> bool", "tip": "Did a named action go inactive this frame (the on-release edge)?", "kind": "namespace-method", "page": "input-just_released.html", "section": "Input"}, "input-cursor_mode": {"name": "Input.cursor_mode", "sig": "Input.cursor_mode(mode)", "tip": "Hide / lock / confine the OS mouse cursor to the window (windowed).", "kind": "namespace-method", "page": "input-cursor_mode.html", "section": "Input"}, "input-move_i": {"name": "Input.move_i", "sig": "Input.move_i() -> IVec2", "tip": "The standard top-down movement intent, -1/0/1 per axis.", "kind": "namespace-method", "page": "input-move_i.html", "section": "Input"}, "list-len": {"name": "List.len", "sig": "List.len(s) -> int", "tip": "The number of elements in a slice.", "kind": "namespace-method", "page": "list-len.html", "section": "List"}, "list-push": {"name": "List.push", "sig": "List.push(s, v) -> void", "tip": "Append an element to the end of a slice.", "kind": "namespace-method", "page": "list-push.html", "section": "List"}, "list-clear": {"name": "List.clear", "sig": "List.clear(s) -> void", "tip": "Remove all elements, keeping capacity.", "kind": "namespace-method", "page": "list-clear.html", "section": "List"}, "list-first": {"name": "List.first", "sig": "List.first(s) -> T", "tip": "The first element of a slice.", "kind": "namespace-method", "page": "list-first.html", "section": "List"}, "list-last": {"name": "List.last", "sig": "List.last(s) -> T", "tip": "The last element of a slice.", "kind": "namespace-method", "page": "list-last.html", "section": "List"}, "list-pop": {"name": "List.pop", "sig": "List.pop(s) -> T", "tip": "Remove and return the last element.", "kind": "namespace-method", "page": "list-pop.html", "section": "List"}, "list-swap": {"name": "List.swap", "sig": "List.swap(s, i, j) -> void", "tip": "Exchange the elements at two indices.", "kind": "namespace-method", "page": "list-swap.html", "section": "List"}, "list-contains": {"name": "List.contains", "sig": "List.contains(s, v) -> bool", "tip": "Whether a value appears in a slice.", "kind": "namespace-method", "page": "list-contains.html", "section": "List"}, "list-index_of": {"name": "List.index_of", "sig": "List.index_of(s, v) -> int", "tip": "The index of a value in a slice, or -1 if absent.", "kind": "namespace-method", "page": "list-index_of.html", "section": "List"}, "list-reverse": {"name": "List.reverse", "sig": "List.reverse(s) -> void", "tip": "Reverse the order of a slice in place.", "kind": "namespace-method", "page": "list-reverse.html", "section": "List"}, "list-insert": {"name": "List.insert", "sig": "List.insert(s, i, v) -> void", "tip": "Insert an element at an index, shifting the rest up.", "kind": "namespace-method", "page": "list-insert.html", "section": "List"}, "list-remove_at": {"name": "List.remove_at", "sig": "List.remove_at(s, i) -> void", "tip": "Remove the element at an index, shifting the rest down.", "kind": "namespace-method", "page": "list-remove_at.html", "section": "List"}, "list-remove": {"name": "List.remove", "sig": "List.remove(s, v) -> void", "tip": "Remove the first element equal to a value.", "kind": "namespace-method", "page": "list-remove.html", "section": "List"}, "list-sort": {"name": "List.sort", "sig": "List.sort(s) -> void", "tip": "Sort a slice in ascending order, in place.", "kind": "namespace-method", "page": "list-sort.html", "section": "List"}, "list-sort_by": {"name": "List.sort_by", "sig": "List.sort_by(s, key) -> void", "tip": "Sort a slice ascending by a key each element maps to.", "kind": "namespace-method", "page": "list-sort_by.html", "section": "List"}, "list-sort_desc_by": {"name": "List.sort_desc_by", "sig": "List.sort_desc_by(s, key) -> void", "tip": "Sort a slice descending by a key each element maps to.", "kind": "namespace-method", "page": "list-sort_desc_by.html", "section": "List"}, "list-sort_with": {"name": "List.sort_with", "sig": "List.sort_with(s, cmp) -> void", "tip": "Sort a slice with a full two-argument comparator.", "kind": "namespace-method", "page": "list-sort_with.html", "section": "List"}, "list-sample": {"name": "List.sample", "sig": "List.sample(pool, count) -> []int", "tip": "Random picks from an int slice, distinct while it can.", "kind": "namespace-method", "page": "list-sample.html", "section": "List"}, "log-trace": {"name": "Log.trace", "sig": "Log.trace(msg, [key, value]...) -> void", "tip": "Log at the trace level (0) — the most verbose.", "kind": "namespace-method", "page": "log-trace.html", "section": "Log"}, "log-debug": {"name": "Log.debug", "sig": "Log.debug(msg, [key, value]...) -> void", "tip": "Log at the debug level (1) — development detail.", "kind": "namespace-method", "page": "log-debug.html", "section": "Log"}, "log-info": {"name": "Log.info", "sig": "Log.info(msg, [key, value]...) -> void", "tip": "Log at the info level (2) — normal operation.", "kind": "namespace-method", "page": "log-info.html", "section": "Log"}, "log-warn": {"name": "Log.warn", "sig": "Log.warn(msg, [key, value]...) -> void", "tip": "Log at the warn level (3) — something looks wrong.", "kind": "namespace-method", "page": "log-warn.html", "section": "Log"}, "log-error": {"name": "Log.error", "sig": "Log.error(msg, [key, value]...) -> void", "tip": "Log at the error level (4) — a failure.", "kind": "namespace-method", "page": "log-error.html", "section": "Log"}, "log-set_level": {"name": "Log.set_level", "sig": "Log.set_level(n) -> void", "tip": "Show only messages at level n or above (0 = all).", "kind": "namespace-method", "page": "log-set_level.html", "section": "Log"}, "log-level": {"name": "Log.level", "sig": "Log.level() -> int", "tip": "The current logging threshold.", "kind": "namespace-method", "page": "log-level.html", "section": "Log"}, "math-min": {"name": "Math.min", "sig": "Math.min(a, b) -> int", "tip": "The smaller of two values.", "kind": "namespace-method", "page": "math-min.html", "section": "Math"}, "math-max": {"name": "Math.max", "sig": "Math.max(a, b) -> int", "tip": "The larger of two values.", "kind": "namespace-method", "page": "math-max.html", "section": "Math"}, "math-abs": {"name": "Math.abs", "sig": "Math.abs(x) -> int", "tip": "The magnitude of a value, dropping its sign.", "kind": "namespace-method", "page": "math-abs.html", "section": "Math"}, "math-clamp": {"name": "Math.clamp", "sig": "Math.clamp(v, lo, hi) -> int", "tip": "Constrain a value to the range [lo, hi].", "kind": "namespace-method", "page": "math-clamp.html", "section": "Math"}, "math-sign": {"name": "Math.sign", "sig": "Math.sign(x) -> int", "tip": "The sign of a value as -1, 0, or 1.", "kind": "namespace-method", "page": "math-sign.html", "section": "Math"}, "math-floor": {"name": "Math.floor", "sig": "Math.floor(x) -> int", "tip": "Round a fixed value down to the nearest whole int.", "kind": "namespace-method", "page": "math-floor.html", "section": "Math"}, "math-ceil": {"name": "Math.ceil", "sig": "Math.ceil(x) -> int", "tip": "Round a fixed value up to the nearest whole int.", "kind": "namespace-method", "page": "math-ceil.html", "section": "Math"}, "math-round": {"name": "Math.round", "sig": "Math.round(x) -> int", "tip": "Round a fixed value to the nearest whole int.", "kind": "namespace-method", "page": "math-round.html", "section": "Math"}, "math-lerp": {"name": "Math.lerp", "sig": "Math.lerp(a, b, t) -> fixed", "tip": "Blend between two values by a 0..1 amount.", "kind": "namespace-method", "page": "math-lerp.html", "section": "Math"}, "math-inverse_lerp": {"name": "Math.inverse_lerp", "sig": "Math.inverse_lerp(a, b, v) -> fixed", "tip": "Find where a value sits between two endpoints as a 0..1 fraction.", "kind": "namespace-method", "page": "math-inverse_lerp.html", "section": "Math"}, "math-remap": {"name": "Math.remap", "sig": "Math.remap(v, in0, in1, out0, out1) -> fixed", "tip": "Rescale a value from one range into another.", "kind": "namespace-method", "page": "math-remap.html", "section": "Math"}, "math-sqrt": {"name": "Math.sqrt", "sig": "Math.sqrt(x) -> fixed", "tip": "The square root of a fixed value.", "kind": "namespace-method", "page": "math-sqrt.html", "section": "Math"}, "math-sin": {"name": "Math.sin", "sig": "Math.sin(radians) -> fixed", "tip": "Sine of an angle in radians.", "kind": "namespace-method", "page": "math-sin.html", "section": "Math"}, "math-cos": {"name": "Math.cos", "sig": "Math.cos(radians) -> fixed", "tip": "Cosine of an angle in radians.", "kind": "namespace-method", "page": "math-cos.html", "section": "Math"}, "math-tan": {"name": "Math.tan", "sig": "Math.tan(radians) -> fixed", "tip": "Tangent of an angle in radians.", "kind": "namespace-method", "page": "math-tan.html", "section": "Math"}, "math-hypot": {"name": "Math.hypot", "sig": "Math.hypot(x, y) -> fixed", "tip": "Length of the vector (x, y).", "kind": "namespace-method", "page": "math-hypot.html", "section": "Math"}, "math-dist": {"name": "Math.dist", "sig": "Math.dist(x0, y0, x1, y1) -> fixed", "tip": "Distance between two points.", "kind": "namespace-method", "page": "math-dist.html", "section": "Math"}, "math-dist2": {"name": "Math.dist2", "sig": "Math.dist2(x0, y0, x1, y1) -> fixed", "tip": "Squared distance between two points.", "kind": "namespace-method", "page": "math-dist2.html", "section": "Math"}, "math-deg_to_rad": {"name": "Math.deg_to_rad", "sig": "Math.deg_to_rad(degrees) -> fixed", "tip": "Convert degrees to radians.", "kind": "namespace-method", "page": "math-deg_to_rad.html", "section": "Math"}, "math-rad_to_deg": {"name": "Math.rad_to_deg", "sig": "Math.rad_to_deg(radians) -> fixed", "tip": "Convert radians to degrees.", "kind": "namespace-method", "page": "math-rad_to_deg.html", "section": "Math"}, "math-posmod": {"name": "Math.posmod", "sig": "Math.posmod(a, m) -> int", "tip": "Modulo that is always non-negative.", "kind": "namespace-method", "page": "math-posmod.html", "section": "Math"}, "math-wrap": {"name": "Math.wrap", "sig": "Math.wrap(v, lo, hi) -> int", "tip": "Wrap a value into the range [lo, hi).", "kind": "namespace-method", "page": "math-wrap.html", "section": "Math"}, "math-ping_pong": {"name": "Math.ping_pong", "sig": "Math.ping_pong(t, len) -> int", "tip": "Bounce a counter back and forth in [0, len].", "kind": "namespace-method", "page": "math-ping_pong.html", "section": "Math"}, "math-snapped": {"name": "Math.snapped", "sig": "Math.snapped(v, step) -> fixed", "tip": "Round a value to the nearest multiple of step.", "kind": "namespace-method", "page": "math-snapped.html", "section": "Math"}, "math-move_toward": {"name": "Math.move_toward", "sig": "Math.move_toward(from, to, delta) -> fixed", "tip": "Step from one value toward another by at most delta.", "kind": "namespace-method", "page": "math-move_toward.html", "section": "Math"}, "math-smoothstep": {"name": "Math.smoothstep", "sig": "Math.smoothstep(e0, e1, x) -> fixed", "tip": "A smooth 0..1 ramp between two edges.", "kind": "namespace-method", "page": "math-smoothstep.html", "section": "Math"}, "math-atan2": {"name": "Math.atan2", "sig": "Math.atan2(y, x) -> fixed", "tip": "The angle of the vector (x, y), in radians.", "kind": "namespace-method", "page": "math-atan2.html", "section": "Math"}, "math-asin": {"name": "Math.asin", "sig": "Math.asin(x) -> fixed", "tip": "The arcsine of a value, in radians.", "kind": "namespace-method", "page": "math-asin.html", "section": "Math"}, "math-acos": {"name": "Math.acos", "sig": "Math.acos(x) -> fixed", "tip": "The arccosine of a value, in radians.", "kind": "namespace-method", "page": "math-acos.html", "section": "Math"}, "math-exp": {"name": "Math.exp", "sig": "Math.exp(x) -> fixed", "tip": "e raised to the power x.", "kind": "namespace-method", "page": "math-exp.html", "section": "Math"}, "math-log": {"name": "Math.log", "sig": "Math.log(x) -> fixed", "tip": "The natural logarithm of x.", "kind": "namespace-method", "page": "math-log.html", "section": "Math"}, "math-pow": {"name": "Math.pow", "sig": "Math.pow(base, exp) -> fixed", "tip": "base raised to a fixed exponent.", "kind": "namespace-method", "page": "math-pow.html", "section": "Math"}, "memory-bytes": {"name": "Memory.bytes", "sig": "Memory.bytes(n) -> pointer", "tip": "Allocate n bytes.", "kind": "namespace-method", "page": "memory-bytes.html", "section": "Memory"}, "memory-words": {"name": "Memory.words", "sig": "Memory.words(n) -> words", "tip": "Allocate n 32-bit words.", "kind": "namespace-method", "page": "memory-words.html", "section": "Memory"}, "memory-copy": {"name": "Memory.copy", "sig": "Memory.copy(dst, src, n) -> void", "tip": "Copy n bytes between buffers.", "kind": "namespace-method", "page": "memory-copy.html", "section": "Memory"}, "memory-fill": {"name": "Memory.fill", "sig": "Memory.fill(buf, value, n) -> void", "tip": "Set n bytes to a value.", "kind": "namespace-method", "page": "memory-fill.html", "section": "Memory"}, "memory-peek": {"name": "Memory.peek", "sig": "Memory.peek(buf, i) -> int", "tip": "Read one byte.", "kind": "namespace-method", "page": "memory-peek.html", "section": "Memory"}, "memory-poke": {"name": "Memory.poke", "sig": "Memory.poke(buf, i, value) -> void", "tip": "Write one byte.", "kind": "namespace-method", "page": "memory-poke.html", "section": "Memory"}, "mime-of": {"name": "Mime.of", "sig": "Mime.of(path) -> string", "tip": "MIME type from a file extension.", "kind": "namespace-method", "page": "mime-of.html", "section": "Mime"}, "mime-sniff": {"name": "Mime.sniff", "sig": "Mime.sniff(path) -> string", "tip": "MIME type refined by magic bytes.", "kind": "namespace-method", "page": "mime-sniff.html", "section": "Mime"}, "network-send": {"name": "Network.send", "sig": "Network.send(peer, buf, len) -> void", "tip": "Put a datagram on the wire.", "kind": "namespace-method", "page": "network-send.html", "section": "Network"}, "network-poll": {"name": "Network.poll", "sig": "Network.poll(buf, cap) -> int", "tip": "Read an inbound datagram.", "kind": "namespace-method", "page": "network-poll.html", "section": "Network"}, "network-serialize": {"name": "Network.serialize", "sig": "Network.serialize(entity, buf) -> int", "tip": "Serialize an entity's synced state.", "kind": "namespace-method", "page": "network-serialize.html", "section": "Network"}, "network-apply": {"name": "Network.apply", "sig": "Network.apply(entity, buf) -> int", "tip": "Apply serialized state to an entity.", "kind": "namespace-method", "page": "network-apply.html", "section": "Network"}, "network-owner": {"name": "Network.owner", "sig": "Network.owner(entity) -> int", "tip": "The peer that owns an entity.", "kind": "namespace-method", "page": "network-owner.html", "section": "Network"}, "network-set_owner": {"name": "Network.set_owner", "sig": "Network.set_owner(entity, peer) -> void", "tip": "Assign ownership of an entity.", "kind": "namespace-method", "page": "network-set_owner.html", "section": "Network"}, "network-is_server": {"name": "Network.is_server", "sig": "Network.is_server() -> bool", "tip": "Is this peer the server?", "kind": "namespace-method", "page": "network-is_server.html", "section": "Network"}, "network-is_owner": {"name": "Network.is_owner", "sig": "Network.is_owner(entity) -> bool", "tip": "Does this peer own the entity?", "kind": "namespace-method", "page": "network-is_owner.html", "section": "Network"}, "network-local_id": {"name": "Network.local_id", "sig": "Network.local_id() -> int", "tip": "This peer's own id.", "kind": "namespace-method", "page": "network-local_id.html", "section": "Network"}, "noise-value2": {"name": "Noise.value2", "sig": "Noise.value2(x, y, seed) -> fixed", "tip": "2D value (lattice) noise, deterministic, in [-1, 1].", "kind": "namespace-method", "page": "noise-value2.html", "section": "Noise"}, "noise-perlin2": {"name": "Noise.perlin2", "sig": "Noise.perlin2(x, y, seed) -> fixed", "tip": "2D Perlin gradient noise, deterministic, in [-1, 1].", "kind": "namespace-method", "page": "noise-perlin2.html", "section": "Noise"}, "noise-simplex2": {"name": "Noise.simplex2", "sig": "Noise.simplex2(x, y, seed) -> fixed", "tip": "2D simplex noise, the organic default, in [-1, 1].", "kind": "namespace-method", "page": "noise-simplex2.html", "section": "Noise"}, "noise-fbm2": {"name": "Noise.fbm2", "sig": "Noise.fbm2(x, y, seed, octaves) -> fixed", "tip": "Fractal Brownian motion — octaves of simplex, in [-1, 1].", "kind": "namespace-method", "page": "noise-fbm2.html", "section": "Noise"}, "noise-cellular2": {"name": "Noise.cellular2", "sig": "Noise.cellular2(x, y, seed) -> fixed", "tip": "Worley (cellular) F1 distance to the nearest cell point.", "kind": "namespace-method", "page": "noise-cellular2.html", "section": "Noise"}, "noise-cellular2_id": {"name": "Noise.cellular2_id", "sig": "Noise.cellular2_id(x, y, seed) -> int", "tip": "The id of the nearest Worley cell — stable per cell.", "kind": "namespace-method", "page": "noise-cellular2_id.html", "section": "Noise"}, "noise-unit": {"name": "Noise.unit", "sig": "Noise.unit(n) -> fixed", "tip": "Remap a [-1,1] noise sample to [0,1].", "kind": "namespace-method", "page": "noise-unit.html", "section": "Noise"}, "os-args": {"name": "Os.args", "sig": "Os.args() -> []string", "tip": "Every command-line argument, as a list.", "kind": "namespace-method", "page": "os-args.html", "section": "Os"}, "os-arg_count": {"name": "Os.arg_count", "sig": "Os.arg_count() -> int", "tip": "How many command-line arguments there are.", "kind": "namespace-method", "page": "os-arg_count.html", "section": "Os"}, "os-arg": {"name": "Os.arg", "sig": "Os.arg(i) -> string", "tip": "The i-th command-line argument.", "kind": "namespace-method", "page": "os-arg.html", "section": "Os"}, "os-env": {"name": "Os.env", "sig": "Os.env(name) -> string", "tip": "Read an environment variable (null if unset).", "kind": "namespace-method", "page": "os-env.html", "section": "Os"}, "os-env_or": {"name": "Os.env_or", "sig": "Os.env_or(name, fallback) -> string", "tip": "Read an environment variable, or a fallback.", "kind": "namespace-method", "page": "os-env_or.html", "section": "Os"}, "os-has_env": {"name": "Os.has_env", "sig": "Os.has_env(name) -> bool", "tip": "Is an environment variable set?", "kind": "namespace-method", "page": "os-has_env.html", "section": "Os"}, "os-set_env": {"name": "Os.set_env", "sig": "Os.set_env(name, value) -> bool", "tip": "Set an environment variable.", "kind": "namespace-method", "page": "os-set_env.html", "section": "Os"}, "os-unset_env": {"name": "Os.unset_env", "sig": "Os.unset_env(name) -> bool", "tip": "Remove an environment variable.", "kind": "namespace-method", "page": "os-unset_env.html", "section": "Os"}, "os-exit": {"name": "Os.exit", "sig": "Os.exit(code)", "tip": "Terminate the process with a status code.", "kind": "namespace-method", "page": "os-exit.html", "section": "Os"}, "os-platform": {"name": "Os.platform", "sig": "Os.platform() -> string", "tip": "The host platform id.", "kind": "namespace-method", "page": "os-platform.html", "section": "Os"}, "os-arch": {"name": "Os.arch", "sig": "Os.arch() -> string", "tip": "The host CPU architecture.", "kind": "namespace-method", "page": "os-arch.html", "section": "Os"}, "os-stdout_write": {"name": "Os.stdout_write", "sig": "Os.stdout_write(s)", "tip": "Write a string to standard output.", "kind": "namespace-method", "page": "os-stdout_write.html", "section": "Os"}, "os-stderr_write": {"name": "Os.stderr_write", "sig": "Os.stderr_write(s)", "tip": "Write a string to standard error.", "kind": "namespace-method", "page": "os-stderr_write.html", "section": "Os"}, "os-save_dir": {"name": "Os.save_dir", "sig": "Os.save_dir(app) -> string", "tip": "Per-user save directory for an app.", "kind": "namespace-method", "page": "os-save_dir.html", "section": "Os"}, "os-config_dir": {"name": "Os.config_dir", "sig": "Os.config_dir(app) -> string", "tip": "Per-user config directory for an app.", "kind": "namespace-method", "page": "os-config_dir.html", "section": "Os"}, "os-cache_dir": {"name": "Os.cache_dir", "sig": "Os.cache_dir(app) -> string", "tip": "Per-user cache directory for an app.", "kind": "namespace-method", "page": "os-cache_dir.html", "section": "Os"}, "os-temp_dir": {"name": "Os.temp_dir", "sig": "Os.temp_dir() -> string", "tip": "The system temporary directory.", "kind": "namespace-method", "page": "os-temp_dir.html", "section": "Os"}, "os-pid": {"name": "Os.pid", "sig": "Os.pid() -> int", "tip": "This process's id.", "kind": "namespace-method", "page": "os-pid.html", "section": "Os"}, "path-join": {"name": "Path.join", "sig": "Path.join(a, b) -> string", "tip": "Join two path segments with the separator.", "kind": "namespace-method", "page": "path-join.html", "section": "Path"}, "path-dir": {"name": "Path.dir", "sig": "Path.dir(p) -> string", "tip": "The directory part of a path.", "kind": "namespace-method", "page": "path-dir.html", "section": "Path"}, "path-base": {"name": "Path.base", "sig": "Path.base(p) -> string", "tip": "The final component of a path.", "kind": "namespace-method", "page": "path-base.html", "section": "Path"}, "path-ext": {"name": "Path.ext", "sig": "Path.ext(p) -> string", "tip": "The file extension, including the dot.", "kind": "namespace-method", "page": "path-ext.html", "section": "Path"}, "path-stem": {"name": "Path.stem", "sig": "Path.stem(p) -> string", "tip": "The final component without its extension.", "kind": "namespace-method", "page": "path-stem.html", "section": "Path"}, "path-normalize": {"name": "Path.normalize", "sig": "Path.normalize(p) -> string", "tip": "Collapse . / .. / duplicate separators.", "kind": "namespace-method", "page": "path-normalize.html", "section": "Path"}, "save-write": {"name": "Save.write", "sig": "Save.write() -> void", "tip": "Save a snapshot of the world.", "kind": "namespace-method", "page": "save-write.html", "section": "Save"}, "save-read": {"name": "Save.read", "sig": "Save.read() -> bool", "tip": "Restore the saved snapshot.", "kind": "namespace-method", "page": "save-read.html", "section": "Save"}, "system-run": {"name": "System.run", "sig": "System.run(command) -> int", "tip": "Run a shell command.", "kind": "namespace-method", "page": "system-run.html", "section": "System"}, "system-read_char": {"name": "System.read_char", "sig": "System.read_char() -> int", "tip": "Read one byte from standard input.", "kind": "namespace-method", "page": "system-read_char.html", "section": "System"}, "system-file_open": {"name": "System.file_open", "sig": "System.file_open(path, mode) -> pointer", "tip": "Open a file.", "kind": "namespace-method", "page": "system-file_open.html", "section": "System"}, "system-file_read": {"name": "System.file_read", "sig": "System.file_read(file, buf, n) -> int", "tip": "Read bytes from a file.", "kind": "namespace-method", "page": "system-file_read.html", "section": "System"}, "system-file_write": {"name": "System.file_write", "sig": "System.file_write(file, buf, n) -> int", "tip": "Write bytes to a file.", "kind": "namespace-method", "page": "system-file_write.html", "section": "System"}, "system-file_seek": {"name": "System.file_seek", "sig": "System.file_seek(file, offset, whence) -> int", "tip": "Move a file's read/write position.", "kind": "namespace-method", "page": "system-file_seek.html", "section": "System"}, "system-file_tell": {"name": "System.file_tell", "sig": "System.file_tell(file) -> int", "tip": "The current file position.", "kind": "namespace-method", "page": "system-file_tell.html", "section": "System"}, "system-file_close": {"name": "System.file_close", "sig": "System.file_close(file) -> void", "tip": "Close a file.", "kind": "namespace-method", "page": "system-file_close.html", "section": "System"}, "text-length": {"name": "Text.length", "sig": "Text.length(s) -> int", "tip": "The number of bytes in a string.", "kind": "namespace-method", "page": "text-length.html", "section": "Text"}, "text-char_at": {"name": "Text.char_at", "sig": "Text.char_at(s, i) -> int", "tip": "The byte value at an index, 0..255.", "kind": "namespace-method", "page": "text-char_at.html", "section": "Text"}, "text-slice": {"name": "Text.slice", "sig": "Text.slice(s, a, b) -> string", "tip": "A substring covering bytes [a, b).", "kind": "namespace-method", "page": "text-slice.html", "section": "Text"}, "text-starts_with": {"name": "Text.starts_with", "sig": "Text.starts_with(s, prefix) -> bool", "tip": "Whether a string begins with a given prefix.", "kind": "namespace-method", "page": "text-starts_with.html", "section": "Text"}, "text-ends_with": {"name": "Text.ends_with", "sig": "Text.ends_with(s, suffix) -> bool", "tip": "Whether a string ends with a given suffix.", "kind": "namespace-method", "page": "text-ends_with.html", "section": "Text"}, "text-contains": {"name": "Text.contains", "sig": "Text.contains(s, sub) -> bool", "tip": "Whether a substring appears anywhere in a string.", "kind": "namespace-method", "page": "text-contains.html", "section": "Text"}, "text-index_of": {"name": "Text.index_of", "sig": "Text.index_of(s, sub) -> int", "tip": "The byte index of a substring, or -1 if absent.", "kind": "namespace-method", "page": "text-index_of.html", "section": "Text"}, "text-equals": {"name": "Text.equals", "sig": "Text.equals(a, b) -> bool", "tip": "Whether two strings have identical bytes.", "kind": "namespace-method", "page": "text-equals.html", "section": "Text"}, "text-concat": {"name": "Text.concat", "sig": "Text.concat(a, b) -> string", "tip": "Join two strings into a new one.", "kind": "namespace-method", "page": "text-concat.html", "section": "Text"}, "text-to_int": {"name": "Text.to_int", "sig": "Text.to_int(s) -> int", "tip": "Parse a leading integer from a string.", "kind": "namespace-method", "page": "text-to_int.html", "section": "Text"}, "text-from_int": {"name": "Text.from_int", "sig": "Text.from_int(n) -> string", "tip": "Render an integer as a string.", "kind": "namespace-method", "page": "text-from_int.html", "section": "Text"}, "text-upper": {"name": "Text.upper", "sig": "Text.upper(s) -> string", "tip": "An uppercased copy of a string.", "kind": "namespace-method", "page": "text-upper.html", "section": "Text"}, "text-lower": {"name": "Text.lower", "sig": "Text.lower(s) -> string", "tip": "A lowercased copy of a string.", "kind": "namespace-method", "page": "text-lower.html", "section": "Text"}, "text-trim": {"name": "Text.trim", "sig": "Text.trim(s) -> string", "tip": "A copy with surrounding whitespace removed.", "kind": "namespace-method", "page": "text-trim.html", "section": "Text"}, "text-repeat": {"name": "Text.repeat", "sig": "Text.repeat(s, n) -> string", "tip": "A string repeated n times.", "kind": "namespace-method", "page": "text-repeat.html", "section": "Text"}, "text-pad_left": {"name": "Text.pad_left", "sig": "Text.pad_left(s, width) -> string", "tip": "Pad with spaces on the left to a width.", "kind": "namespace-method", "page": "text-pad_left.html", "section": "Text"}, "text-pad_right": {"name": "Text.pad_right", "sig": "Text.pad_right(s, width) -> string", "tip": "Pad with spaces on the right to a width.", "kind": "namespace-method", "page": "text-pad_right.html", "section": "Text"}, "text-split": {"name": "Text.split", "sig": "Text.split(s, sep) -> []string", "tip": "Split a string on a separator into a list.", "kind": "namespace-method", "page": "text-split.html", "section": "Text"}, "text-join": {"name": "Text.join", "sig": "Text.join(parts, sep) -> string", "tip": "Join a list of strings with a separator.", "kind": "namespace-method", "page": "text-join.html", "section": "Text"}, "text-replace": {"name": "Text.replace", "sig": "Text.replace(s, from, to) -> string", "tip": "Replace every occurrence of a substring.", "kind": "namespace-method", "page": "text-replace.html", "section": "Text"}, "time-frame": {"name": "Time.frame", "sig": "Time.frame() -> int", "tip": "The number of frames elapsed since start.", "kind": "namespace-method", "page": "time-frame.html", "section": "Time"}, "time-delta": {"name": "Time.delta", "sig": "Time.delta() -> fixed", "tip": "Seconds per frame (a fixed 1/60).", "kind": "namespace-method", "page": "time-delta.html", "section": "Time"}, "time-elapsed": {"name": "Time.elapsed", "sig": "Time.elapsed() -> fixed", "tip": "Seconds since start (deterministic).", "kind": "namespace-method", "page": "time-elapsed.html", "section": "Time"}, "time-now": {"name": "Time.now", "sig": "Time.now() -> int", "tip": "Wall-clock seconds (non-deterministic).", "kind": "namespace-method", "page": "time-now.html", "section": "Time"}, "time-since": {"name": "Time.since", "sig": "Time.since(past) -> int", "tip": "Seconds elapsed from a past instant to now (non-deterministic).", "kind": "namespace-method", "page": "time-since.html", "section": "Time"}, "unicode-len": {"name": "Unicode.len", "sig": "Unicode.len(s) -> int", "tip": "Number of code points in a string (not bytes).", "kind": "namespace-method", "page": "unicode-len.html", "section": "Unicode"}, "unicode-byte_len": {"name": "Unicode.byte_len", "sig": "Unicode.byte_len(s) -> int", "tip": "Number of bytes in a string.", "kind": "namespace-method", "page": "unicode-byte_len.html", "section": "Unicode"}, "unicode-is_valid_utf8": {"name": "Unicode.is_valid_utf8", "sig": "Unicode.is_valid_utf8(s) -> bool", "tip": "Is a string well-formed UTF-8?", "kind": "namespace-method", "page": "unicode-is_valid_utf8.html", "section": "Unicode"}, "unicode-char_at": {"name": "Unicode.char_at", "sig": "Unicode.char_at(s, i) -> int", "tip": "The i-th code point of a string.", "kind": "namespace-method", "page": "unicode-char_at.html", "section": "Unicode"}, "unicode-chars": {"name": "Unicode.chars", "sig": "Unicode.chars(s) -> []int", "tip": "Every code point of a string, in order.", "kind": "namespace-method", "page": "unicode-chars.html", "section": "Unicode"}, "unicode-upper": {"name": "Unicode.upper", "sig": "Unicode.upper(s) -> string", "tip": "Uppercase a string.", "kind": "namespace-method", "page": "unicode-upper.html", "section": "Unicode"}, "unicode-lower": {"name": "Unicode.lower", "sig": "Unicode.lower(s) -> string", "tip": "Lowercase a string.", "kind": "namespace-method", "page": "unicode-lower.html", "section": "Unicode"}, "unicode-truncate": {"name": "Unicode.truncate", "sig": "Unicode.truncate(s, n) -> string", "tip": "First n code points of a string.", "kind": "namespace-method", "page": "unicode-truncate.html", "section": "Unicode"}, "unicode-grapheme_len": {"name": "Unicode.grapheme_len", "sig": "Unicode.grapheme_len(s) -> int", "tip": "Number of user-perceived characters.", "kind": "namespace-method", "page": "unicode-grapheme_len.html", "section": "Unicode"}, "uuid-new": {"name": "Uuid.new", "sig": "Uuid.new() -> string", "tip": "A new random (v4) UUID as a canonical 36-char string.", "kind": "namespace-method", "page": "uuid-new.html", "section": "Uuid"}, "uuid-v4": {"name": "Uuid.v4", "sig": "Uuid.v4() -> string", "tip": "Explicit alias for Uuid.new — a random (v4) UUID.", "kind": "namespace-method", "page": "uuid-v4.html", "section": "Uuid"}, "uuid-new_v7": {"name": "Uuid.new_v7", "sig": "Uuid.new_v7() -> string", "tip": "A new time-ordered (v7) UUID; sorts by creation time.", "kind": "namespace-method", "page": "uuid-new_v7.html", "section": "Uuid"}, "uuid-v7": {"name": "Uuid.v7", "sig": "Uuid.v7() -> string", "tip": "Explicit alias for Uuid.new_v7 — a time-ordered UUID.", "kind": "namespace-method", "page": "uuid-v7.html", "section": "Uuid"}, "uuid-parse": {"name": "Uuid.parse", "sig": "Uuid.parse(s) -> string", "tip": "Normalise an untrusted string to a lowercase UUID, or the nil UUID.", "kind": "namespace-method", "page": "uuid-parse.html", "section": "Uuid"}, "uuid-is_valid": {"name": "Uuid.is_valid", "sig": "Uuid.is_valid(s) -> bool", "tip": "Is s a well-formed UUID string?", "kind": "namespace-method", "page": "uuid-is_valid.html", "section": "Uuid"}, "uuid-to_text": {"name": "Uuid.to_text", "sig": "Uuid.to_text(id) -> string", "tip": "The canonical text form of a UUID.", "kind": "namespace-method", "page": "uuid-to_text.html", "section": "Uuid"}, "uuid-equals": {"name": "Uuid.equals", "sig": "Uuid.equals(a, b) -> bool", "tip": "Case-insensitive UUID equality.", "kind": "namespace-method", "page": "uuid-equals.html", "section": "Uuid"}, "uuid-nil": {"name": "Uuid.nil", "sig": "Uuid.nil() -> string", "tip": "The all-zero UUID.", "kind": "namespace-method", "page": "uuid-nil.html", "section": "Uuid"}, "world-get": {"name": "World.get", "sig": "World.get(prop_id, field_id, entity) -> int", "tip": "Read a component field by id.", "kind": "namespace-method", "page": "world-get.html", "section": "World"}, "world-set": {"name": "World.set", "sig": "World.set(prop_id, field_id, entity, value) -> void", "tip": "Write a component field by id.", "kind": "namespace-method", "page": "world-set.html", "section": "World"}, "world-has": {"name": "World.has", "sig": "World.has(entity, prop_id) -> int", "tip": "Does an entity have a component?", "kind": "namespace-method", "page": "world-has.html", "section": "World"}, "world-count": {"name": "World.count", "sig": "World.count() -> int", "tip": "The number of live entities.", "kind": "namespace-method", "page": "world-count.html", "section": "World"}, "world-size": {"name": "World.size", "sig": "World.size() -> int", "tip": "The serialized size of the world.", "kind": "namespace-method", "page": "world-size.html", "section": "World"}, "world-spawn": {"name": "World.spawn", "sig": "World.spawn(model_id) -> entity", "tip": "Spawn an entity of a model by id.", "kind": "namespace-method", "page": "world-spawn.html", "section": "World"}, "world-save": {"name": "World.save", "sig": "World.save(buf) -> int", "tip": "Serialize the world into a buffer.", "kind": "namespace-method", "page": "world-save.html", "section": "World"}, "world-load": {"name": "World.load", "sig": "World.load(buf, len) -> void", "tip": "Restore the world from a buffer.", "kind": "namespace-method", "page": "world-load.html", "section": "World"}, "world-prop_id": {"name": "World.prop_id", "sig": "World.prop_id(name) -> int", "tip": "Look up a component's id by name.", "kind": "namespace-method", "page": "world-prop_id.html", "section": "World"}, "world-field_id": {"name": "World.field_id", "sig": "World.field_id(prop_id, name) -> int", "tip": "Look up a field's id by name.", "kind": "namespace-method", "page": "world-field_id.html", "section": "World"}, "world-model_id": {"name": "World.model_id", "sig": "World.model_id(name) -> int", "tip": "Look up a model's id by name.", "kind": "namespace-method", "page": "world-model_id.html", "section": "World"}, "world-kind": {"name": "World.kind", "sig": "World.kind(entity) -> int", "tip": "The model id of an entity.", "kind": "namespace-method", "page": "world-kind.html", "section": "World"}, "world-register_prop": {"name": "World.register_prop", "sig": "World.register_prop(name, size) -> int", "tip": "Register a new component at runtime.", "kind": "namespace-method", "page": "world-register_prop.html", "section": "World"}, "world-attach": {"name": "World.attach", "sig": "World.attach(entity, prop_id) -> void", "tip": "Attach a component to an entity at runtime.", "kind": "namespace-method", "page": "world-attach.html", "section": "World"}, "world-detach": {"name": "World.detach", "sig": "World.detach(entity, prop_id) -> void", "tip": "Detach a component from an entity at runtime.", "kind": "namespace-method", "page": "world-detach.html", "section": "World"}, "world-query_next": {"name": "World.query_next", "sig": "World.query_next(query_id, cursor) -> int", "tip": "Advance a reflective query.", "kind": "namespace-method", "page": "world-query_next.html", "section": "World"}, "world-despawn": {"name": "World.despawn", "sig": "World.despawn(entity)", "tip": "Despawn an entity by id — runs its @OnDespawn hooks and frees the slot.", "kind": "namespace-method", "page": "world-despawn.html", "section": "World"}, "audio-load": {"name": "Audio.load", "sig": "Audio.load(path) -> int", "tip": "Load a sound file into a handle.", "kind": "namespace-method", "page": "audio-load.html", "section": "Audio"}, "audio-play": {"name": "Audio.play", "sig": "Audio.play(id) -> void", "tip": "Fire a one-shot sound.", "kind": "namespace-method", "page": "audio-play.html", "section": "Audio"}, "audio-play_at": {"name": "Audio.play_at", "sig": "Audio.play_at(id, gain, pitch, pan) -> void", "tip": "Fire a one-shot with its own gain, pitch and stereo position.", "kind": "namespace-method", "page": "audio-play_at.html", "section": "Audio"}, "audio-play_sound": {"name": "Audio.play_sound", "sig": "Audio.play_sound(id) -> void", "tip": "Fire a one-shot sound (alias of play).", "kind": "namespace-method", "page": "audio-play_sound.html", "section": "Audio"}, "audio-play_music": {"name": "Audio.play_music", "sig": "Audio.play_music(id) -> void", "tip": "Loop a sound as background music.", "kind": "namespace-method", "page": "audio-play_music.html", "section": "Audio"}, "audio-stop": {"name": "Audio.stop", "sig": "Audio.stop(id) -> void", "tip": "Stop one sound.", "kind": "namespace-method", "page": "audio-stop.html", "section": "Audio"}, "audio-stop_music": {"name": "Audio.stop_music", "sig": "Audio.stop_music() -> void", "tip": "Stop the music channel.", "kind": "namespace-method", "page": "audio-stop_music.html", "section": "Audio"}, "audio-stop_all": {"name": "Audio.stop_all", "sig": "Audio.stop_all() -> void", "tip": "Stop every sound.", "kind": "namespace-method", "page": "audio-stop_all.html", "section": "Audio"}, "audio-volume": {"name": "Audio.volume", "sig": "Audio.volume(v) -> void", "tip": "Set the master volume.", "kind": "namespace-method", "page": "audio-volume.html", "section": "Audio"}, "audio-pitch": {"name": "Audio.pitch", "sig": "Audio.pitch(v) -> void", "tip": "Set the playback rate / pitch.", "kind": "namespace-method", "page": "audio-pitch.html", "section": "Audio"}, "audio-is_playing": {"name": "Audio.is_playing", "sig": "Audio.is_playing(id) -> bool", "tip": "Is this sound playing?", "kind": "namespace-method", "page": "audio-is_playing.html", "section": "Audio"}, "audio-define": {"name": "Audio.define", "sig": "Audio.define(name: s, path: p) -> int", "tip": "Load a sound into the bank under a name.", "kind": "namespace-method", "page": "audio-define.html", "section": "Audio"}, "audio-named": {"name": "Audio.named", "sig": "Audio.named(name: s) -> int", "tip": "The handle registered under a name, or 0.", "kind": "namespace-method", "page": "audio-named.html", "section": "Audio"}, "random-range": {"name": "Random.range", "sig": "Random.range(low, high) -> int", "tip": "A random integer in the inclusive range [low, high].", "kind": "namespace-method", "page": "random-range.html", "section": "Random"}, "random-chance": {"name": "Random.chance", "sig": "Random.chance(percent) -> bool", "tip": "Return true with the given percent probability.", "kind": "namespace-method", "page": "random-chance.html", "section": "Random"}, "random-seed": {"name": "Random.seed", "sig": "Random.seed(value)", "tip": "Seed the random generator so runs are reproducible.", "kind": "namespace-method", "page": "random-seed.html", "section": "Random"}, "random-value": {"name": "Random.value", "sig": "Random.value() -> fixed", "tip": "A random fixed value in [0, 1).", "kind": "namespace-method", "page": "random-value.html", "section": "Random"}, "random-int": {"name": "Random.int", "sig": "Random.int(max) -> int", "tip": "A random integer in [0, max).", "kind": "namespace-method", "page": "random-int.html", "section": "Random"}, "random-sign": {"name": "Random.sign", "sig": "Random.sign() -> int", "tip": "A random +1 or -1.", "kind": "namespace-method", "page": "random-sign.html", "section": "Random"}, "random-weighted": {"name": "Random.weighted", "sig": "Random.weighted(weights: []int) -> int", "tip": "An index drawn in proportion to its weight.", "kind": "namespace-method", "page": "random-weighted.html", "section": "Random"}, "vector-make": {"name": "Vector.make", "sig": "Vector.make(x, y) -> Vector", "tip": "Build a vector from x and y components.", "kind": "namespace-method", "page": "vector-make.html", "section": "Vector"}, "vector-zero": {"name": "Vector.zero", "sig": "Vector.zero() -> Vector", "tip": "The zero vector, (0, 0).", "kind": "namespace-method", "page": "vector-zero.html", "section": "Vector"}, "vector-x": {"name": "Vector.x", "sig": "Vector.x(v) -> fixed", "tip": "The x component of a vector.", "kind": "namespace-method", "page": "vector-x.html", "section": "Vector"}, "vector-y": {"name": "Vector.y", "sig": "Vector.y(v) -> fixed", "tip": "The y component of a vector.", "kind": "namespace-method", "page": "vector-y.html", "section": "Vector"}, "vector-add": {"name": "Vector.add", "sig": "Vector.add(a, b) -> Vector", "tip": "Component-wise sum a + b.", "kind": "namespace-method", "page": "vector-add.html", "section": "Vector"}, "vector-sub": {"name": "Vector.sub", "sig": "Vector.sub(a, b) -> Vector", "tip": "Component-wise difference a - b.", "kind": "namespace-method", "page": "vector-sub.html", "section": "Vector"}, "vector-scale": {"name": "Vector.scale", "sig": "Vector.scale(v, s) -> Vector", "tip": "Scale a vector by a scalar.", "kind": "namespace-method", "page": "vector-scale.html", "section": "Vector"}, "vector-dot": {"name": "Vector.dot", "sig": "Vector.dot(a, b) -> fixed", "tip": "The dot product of two vectors.", "kind": "namespace-method", "page": "vector-dot.html", "section": "Vector"}, "vector-length": {"name": "Vector.length", "sig": "Vector.length(v) -> fixed", "tip": "The length (magnitude) of a vector.", "kind": "namespace-method", "page": "vector-length.html", "section": "Vector"}, "vector-distance": {"name": "Vector.distance", "sig": "Vector.distance(a, b) -> fixed", "tip": "The distance between two points.", "kind": "namespace-method", "page": "vector-distance.html", "section": "Vector"}, "vector-normalize": {"name": "Vector.normalize", "sig": "Vector.normalize(v) -> Vector", "tip": "A unit vector in the same direction.", "kind": "namespace-method", "page": "vector-normalize.html", "section": "Vector"}, "vector-lerp": {"name": "Vector.lerp", "sig": "Vector.lerp(a, b, t) -> Vector", "tip": "Linear interpolation between two vectors.", "kind": "namespace-method", "page": "vector-lerp.html", "section": "Vector"}, "vector-rotate": {"name": "Vector.rotate", "sig": "Vector.rotate(v, angle) -> Vector", "tip": "Rotate a vector by an angle in radians.", "kind": "namespace-method", "page": "vector-rotate.html", "section": "Vector"}, "vector-angle": {"name": "Vector.angle", "sig": "Vector.angle(v) -> fixed", "tip": "The angle of a vector in radians.", "kind": "namespace-method", "page": "vector-angle.html", "section": "Vector"}, "vector-from_angle": {"name": "Vector.from_angle", "sig": "Vector.from_angle(a) -> Vector", "tip": "A unit vector pointing at an angle.", "kind": "namespace-method", "page": "vector-from_angle.html", "section": "Vector"}, "http-get": {"name": "Http.get", "sig": "Http.get(url) -> int", "tip": "Start an async GET request.", "kind": "namespace-method", "page": "http-get.html", "section": "Http"}, "http-post": {"name": "Http.post", "sig": "Http.post(url, body) -> int", "tip": "Start an async POST with a body.", "kind": "namespace-method", "page": "http-post.html", "section": "Http"}, "http-request": {"name": "Http.request", "sig": "Http.request(method, url, body) -> int", "tip": "Start a request with any method.", "kind": "namespace-method", "page": "http-request.html", "section": "Http"}, "http-open": {"name": "Http.open", "sig": "Http.open(method, url) -> int", "tip": "Open a request to configure before sending.", "kind": "namespace-method", "page": "http-open.html", "section": "Http"}, "http-set": {"name": "Http.set", "sig": "Http.set(handle, name, value) -> void", "tip": "Set a request header before sending.", "kind": "namespace-method", "page": "http-set.html", "section": "Http"}, "http-body": {"name": "Http.body", "sig": "Http.body(handle, body) -> void", "tip": "Set a string request body.", "kind": "namespace-method", "page": "http-body.html", "section": "Http"}, "http-body_bytes": {"name": "Http.body_bytes", "sig": "Http.body_bytes(handle, bytes, len) -> void", "tip": "Set a raw byte request body.", "kind": "namespace-method", "page": "http-body_bytes.html", "section": "Http"}, "http-send": {"name": "Http.send", "sig": "Http.send(handle) -> void", "tip": "Dispatch an opened request.", "kind": "namespace-method", "page": "http-send.html", "section": "Http"}, "http-poll": {"name": "Http.poll", "sig": "Http.poll(handle) -> int", "tip": "Poll a request; -1 pending, 0 error, else status.", "kind": "namespace-method", "page": "http-poll.html", "section": "Http"}, "http-status": {"name": "Http.status", "sig": "Http.status(handle) -> int", "tip": "The response HTTP status code.", "kind": "namespace-method", "page": "http-status.html", "section": "Http"}, "http-ok": {"name": "Http.ok", "sig": "Http.ok(handle) -> bool", "tip": "Was the response status 2xx?", "kind": "namespace-method", "page": "http-ok.html", "section": "Http"}, "http-text": {"name": "Http.text", "sig": "Http.text(handle) -> str", "tip": "The response body as text.", "kind": "namespace-method", "page": "http-text.html", "section": "Http"}, "http-body_len": {"name": "Http.body_len", "sig": "Http.body_len(handle) -> int", "tip": "The response body length in bytes.", "kind": "namespace-method", "page": "http-body_len.html", "section": "Http"}, "http-header": {"name": "Http.header", "sig": "Http.header(handle, name) -> str", "tip": "A response header value (case-insensitive).", "kind": "namespace-method", "page": "http-header.html", "section": "Http"}, "http-free": {"name": "Http.free", "sig": "Http.free(handle) -> void", "tip": "Release a request's resources.", "kind": "namespace-method", "page": "http-free.html", "section": "Http"}, "http-parse": {"name": "Http.parse", "sig": "Http.parse(bytes, len) -> int", "tip": "Parse a raw HTTP response into a handle.", "kind": "namespace-method", "page": "http-parse.html", "section": "Http"}, "http-save_to": {"name": "Http.save_to", "sig": "Http.save_to(handle, path) -> void", "tip": "Stream the response body to a file.", "kind": "namespace-method", "page": "http-save_to.html", "section": "Http"}, "http-received": {"name": "Http.received", "sig": "Http.received(handle) -> int", "tip": "Body bytes received so far.", "kind": "namespace-method", "page": "http-received.html", "section": "Http"}, "http-expected": {"name": "Http.expected", "sig": "Http.expected(handle) -> int", "tip": "The body length the server announced, or -1.", "kind": "namespace-method", "page": "http-expected.html", "section": "Http"}, "ivec2-make": {"name": "IVec2.make", "sig": "IVec2.make(x, y) -> IVec2", "tip": "Build an integer vector from x and y components.", "kind": "namespace-method", "page": "ivec2-make.html", "section": "IVec2"}, "ivec2-zero": {"name": "IVec2.zero", "sig": "IVec2.zero() -> IVec2", "tip": "The origin cell, (0, 0).", "kind": "namespace-method", "page": "ivec2-zero.html", "section": "IVec2"}, "ivec2-x": {"name": "IVec2.x", "sig": "IVec2.x(v) -> int", "tip": "The x component of an integer vector.", "kind": "namespace-method", "page": "ivec2-x.html", "section": "IVec2"}, "ivec2-y": {"name": "IVec2.y", "sig": "IVec2.y(v) -> int", "tip": "The y component of an integer vector.", "kind": "namespace-method", "page": "ivec2-y.html", "section": "IVec2"}, "ivec2-add": {"name": "IVec2.add", "sig": "IVec2.add(a, b) -> IVec2", "tip": "Component-wise sum of two integer vectors.", "kind": "namespace-method", "page": "ivec2-add.html", "section": "IVec2"}, "ivec2-sub": {"name": "IVec2.sub", "sig": "IVec2.sub(a, b) -> IVec2", "tip": "Component-wise difference of two integer vectors.", "kind": "namespace-method", "page": "ivec2-sub.html", "section": "IVec2"}, "ivec2-scale": {"name": "IVec2.scale", "sig": "IVec2.scale(v, s) -> IVec2", "tip": "Multiply both components by an integer.", "kind": "namespace-method", "page": "ivec2-scale.html", "section": "IVec2"}, "ivec2-dot": {"name": "IVec2.dot", "sig": "IVec2.dot(a, b) -> int", "tip": "The dot product ax*bx + ay*by.", "kind": "namespace-method", "page": "ivec2-dot.html", "section": "IVec2"}, "ivec2-equal": {"name": "IVec2.equal", "sig": "IVec2.equal(a, b) -> bool", "tip": "True when both components match.", "kind": "namespace-method", "page": "ivec2-equal.html", "section": "IVec2"}, "ivec2-manhattan": {"name": "IVec2.manhattan", "sig": "IVec2.manhattan(a, b) -> int", "tip": "Grid distance |dx| + |dy|.", "kind": "namespace-method", "page": "ivec2-manhattan.html", "section": "IVec2"}, "ivec2-to_vector": {"name": "IVec2.to_vector", "sig": "IVec2.to_vector(v) -> Vector", "tip": "Widen to a fixed-point Vector.", "kind": "namespace-method", "page": "ivec2-to_vector.html", "section": "IVec2"}, "ivec2-distance2": {"name": "IVec2.distance2", "sig": "IVec2.distance2(a, b) -> int", "tip": "The squared distance between two points.", "kind": "namespace-method", "page": "ivec2-distance2.html", "section": "IVec2"}, "ivec2-within": {"name": "IVec2.within", "sig": "IVec2.within(a, b, radius) -> bool", "tip": "Are two points within a radius of each other?", "kind": "namespace-method", "page": "ivec2-within.html", "section": "IVec2"}, "ivec2-heading": {"name": "IVec2.heading", "sig": "IVec2.heading(from, to) -> int", "tip": "The direction from one point to another, in degrees.", "kind": "namespace-method", "page": "ivec2-heading.html", "section": "IVec2"}, "ivec2-along": {"name": "IVec2.along", "sig": "IVec2.along(origin, degrees, distance) -> IVec2", "tip": "The point a distance along a heading.", "kind": "namespace-method", "page": "ivec2-along.html", "section": "IVec2"}, "ivec2-step": {"name": "IVec2.step", "sig": "IVec2.step(degrees) -> IVec2", "tip": "A -1/0/1 unit step along a heading.", "kind": "namespace-method", "page": "ivec2-step.html", "section": "IVec2"}, "map-size": {"name": "Map.size", "sig": "Map.size(width, height)", "tip": "Set the tilemap dimensions in cells before filling rows.", "kind": "namespace-method", "page": "map-size.html", "section": "Map — tilemap"}, "map-row": {"name": "Map.row", "sig": "Map.row(y, cells)", "tip": "Fill one row of the tilemap from a string of tile characters.", "kind": "namespace-method", "page": "map-row.html", "section": "Map — tilemap"}, "map-tile": {"name": "Map.tile", "sig": "Map.tile(x, y) -> int", "tip": "Read the tile character at a cell (out-of-bounds reads answer '#').", "kind": "namespace-method", "page": "map-tile.html", "section": "Map — tilemap"}, "map-get": {"name": "Map.get", "sig": "Map.get(x: tx, y: ty) -> int", "tip": "The glyph at a cell ('#' outside the map).", "kind": "namespace-method", "page": "map-get.html", "section": "Map — tilemap"}, "map-set": {"name": "Map.set", "sig": "Map.set(x: tx, y: ty, glyph: g)", "tip": "Write one cell in place.", "kind": "namespace-method", "page": "map-set.html", "section": "Map — tilemap"}, "map-fill": {"name": "Map.fill", "sig": "Map.fill(glyph: g)", "tip": "Every cell becomes the glyph.", "kind": "namespace-method", "page": "map-fill.html", "section": "Map — tilemap"}, "map-rect": {"name": "Map.rect", "sig": "Map.rect(x: tx, y: ty, width: w, height: h, glyph: g)", "tip": "Fill a rectangle of cells.", "kind": "namespace-method", "page": "map-rect.html", "section": "Map — tilemap"}, "map-border": {"name": "Map.border", "sig": "Map.border(glyph: g)", "tip": "The outermost ring of cells.", "kind": "namespace-method", "page": "map-border.html", "section": "Map — tilemap"}, "map-random_cell": {"name": "Map.random_cell", "sig": "Map.random_cell(glyph: g) -> IVec2", "tip": "A random cell holding the glyph (seeded RNG).", "kind": "namespace-method", "page": "map-random_cell.html", "section": "Map — tilemap"}, "map-is_solid": {"name": "Map.is_solid", "sig": "Map.is_solid(x: tx, y: ty) -> bool", "tip": "Is a cell solid, per the Solids config?", "kind": "namespace-method", "page": "map-is_solid.html", "section": "Map — tilemap"}, "map-is_solid_at": {"name": "Map.is_solid_at", "sig": "Map.is_solid_at(x: px, y: py) -> bool", "tip": "Is the cell under a pixel position solid?", "kind": "namespace-method", "page": "map-is_solid_at.html", "section": "Map — tilemap"}, "map-width": {"name": "Map.width", "sig": "Map.width() -> int", "tip": "The map's width in cells.", "kind": "namespace-method", "page": "map-width.html", "section": "Map — tilemap"}, "map-height": {"name": "Map.height", "sig": "Map.height() -> int", "tip": "The map's height in cells.", "kind": "namespace-method", "page": "map-height.html", "section": "Map — tilemap"}, "map-random_cell_far": {"name": "Map.random_cell_far", "sig": "Map.random_cell_far(glyph:, from:, min_tiles:) -> IVec2", "tip": "A random cell with the glyph, at least a distance from a point.", "kind": "namespace-method", "page": "map-random_cell_far.html", "section": "Map — tilemap"}, "map-to_tile": {"name": "Map.to_tile", "sig": "Map.to_tile(pixel: IVec2) -> IVec2", "tip": "The tile under a pixel position.", "kind": "namespace-method", "page": "map-to_tile.html", "section": "Map — tilemap"}, "rect-make": {"name": "Rect.make", "sig": "Rect.make(x, y, w, h) -> Rect", "tip": "Build a rectangle from a corner and a size.", "kind": "namespace-method", "page": "rect-make.html", "section": "Rect"}, "rect-x": {"name": "Rect.x", "sig": "Rect.x(r) -> fixed", "tip": "The left edge (x position).", "kind": "namespace-method", "page": "rect-x.html", "section": "Rect"}, "rect-y": {"name": "Rect.y", "sig": "Rect.y(r) -> fixed", "tip": "The top edge (y position).", "kind": "namespace-method", "page": "rect-y.html", "section": "Rect"}, "rect-w": {"name": "Rect.w", "sig": "Rect.w(r) -> fixed", "tip": "The width.", "kind": "namespace-method", "page": "rect-w.html", "section": "Rect"}, "rect-h": {"name": "Rect.h", "sig": "Rect.h(r) -> fixed", "tip": "The height.", "kind": "namespace-method", "page": "rect-h.html", "section": "Rect"}, "rect-right": {"name": "Rect.right", "sig": "Rect.right(r) -> fixed", "tip": "The right edge, x + w.", "kind": "namespace-method", "page": "rect-right.html", "section": "Rect"}, "rect-bottom": {"name": "Rect.bottom", "sig": "Rect.bottom(r) -> fixed", "tip": "The bottom edge, y + h.", "kind": "namespace-method", "page": "rect-bottom.html", "section": "Rect"}, "rect-center": {"name": "Rect.center", "sig": "Rect.center(r) -> Vector", "tip": "The center point as a Vector.", "kind": "namespace-method", "page": "rect-center.html", "section": "Rect"}, "rect-contains": {"name": "Rect.contains", "sig": "Rect.contains(r, px, py) -> bool", "tip": "True when the point is inside.", "kind": "namespace-method", "page": "rect-contains.html", "section": "Rect"}, "rect-intersects": {"name": "Rect.intersects", "sig": "Rect.intersects(a, b) -> bool", "tip": "True when two rectangles overlap.", "kind": "namespace-method", "page": "rect-intersects.html", "section": "Rect"}, "udp-open": {"name": "Udp.open", "sig": "Udp.open(port) -> int", "tip": "Open a socket on a port.", "kind": "namespace-method", "page": "udp-open.html", "section": "Udp"}, "udp-port": {"name": "Udp.port", "sig": "Udp.port(socket) -> int", "tip": "The port a socket is bound to.", "kind": "namespace-method", "page": "udp-port.html", "section": "Udp"}, "udp-send": {"name": "Udp.send", "sig": "Udp.send(socket, ip, port, bytes, len) -> int", "tip": "Send one datagram.", "kind": "namespace-method", "page": "udp-send.html", "section": "Udp"}, "udp-recv": {"name": "Udp.recv", "sig": "Udp.recv(socket, bytes, cap) -> int", "tip": "Read the next waiting datagram.", "kind": "namespace-method", "page": "udp-recv.html", "section": "Udp"}, "udp-from_ip": {"name": "Udp.from_ip", "sig": "Udp.from_ip(socket) -> int", "tip": "The sender of the last datagram read.", "kind": "namespace-method", "page": "udp-from_ip.html", "section": "Udp"}, "udp-from_port": {"name": "Udp.from_port", "sig": "Udp.from_port(socket) -> int", "tip": "The sender's port.", "kind": "namespace-method", "page": "udp-from_port.html", "section": "Udp"}, "udp-close": {"name": "Udp.close", "sig": "Udp.close(socket) -> void", "tip": "Close a socket.", "kind": "namespace-method", "page": "udp-close.html", "section": "Udp"}, "udp-resolve": {"name": "Udp.resolve", "sig": "Udp.resolve(name) -> int", "tip": "Look a host name up.", "kind": "namespace-method", "page": "udp-resolve.html", "section": "Udp"}, "udp-local_ip": {"name": "Udp.local_ip", "sig": "Udp.local_ip() -> int", "tip": "This machine's address.", "kind": "namespace-method", "page": "udp-local_ip.html", "section": "Udp"}, "udp-ip": {"name": "Udp.ip", "sig": "Udp.ip(text) -> int", "tip": "Parse a dotted address.", "kind": "namespace-method", "page": "udp-ip.html", "section": "Udp"}, "udp-ip_text": {"name": "Udp.ip_text", "sig": "Udp.ip_text(ip) -> string", "tip": "Format an address.", "kind": "namespace-method", "page": "udp-ip_text.html", "section": "Udp"}, "bigint-from": {"name": "BigInt.from", "sig": "BigInt.from(value) -> BigInt", "tip": "Turn a plain int into a BigInt.", "kind": "namespace-method", "page": "bigint-from.html", "section": "BigInt"}, "bigint-parse": {"name": "BigInt.parse", "sig": "BigInt.parse(text) -> BigInt", "tip": "Parse decimal text into a BigInt.", "kind": "namespace-method", "page": "bigint-parse.html", "section": "BigInt"}, "bigint-add": {"name": "BigInt.add", "sig": "BigInt.add(a, b) -> BigInt", "tip": "Exact sum of two big integers.", "kind": "namespace-method", "page": "bigint-add.html", "section": "BigInt"}, "bigint-sub": {"name": "BigInt.sub", "sig": "BigInt.sub(a, b) -> BigInt", "tip": "Exact difference of two big integers.", "kind": "namespace-method", "page": "bigint-sub.html", "section": "BigInt"}, "bigint-mul": {"name": "BigInt.mul", "sig": "BigInt.mul(a, b) -> BigInt", "tip": "Exact product of two big integers.", "kind": "namespace-method", "page": "bigint-mul.html", "section": "BigInt"}, "bigint-neg": {"name": "BigInt.neg", "sig": "BigInt.neg(a) -> BigInt", "tip": "Negate a big integer.", "kind": "namespace-method", "page": "bigint-neg.html", "section": "BigInt"}, "bigint-pow": {"name": "BigInt.pow", "sig": "BigInt.pow(a, exp) -> BigInt", "tip": "Raise a big integer to an int power.", "kind": "namespace-method", "page": "bigint-pow.html", "section": "BigInt"}, "bigint-div": {"name": "BigInt.div", "sig": "BigInt.div(a, d) -> BigInt", "tip": "Divide a big integer by an int (toward zero).", "kind": "namespace-method", "page": "bigint-div.html", "section": "BigInt"}, "bigint-mod": {"name": "BigInt.mod", "sig": "BigInt.mod(a, d) -> int", "tip": "Remainder of a big integer divided by an int.", "kind": "namespace-method", "page": "bigint-mod.html", "section": "BigInt"}, "bigint-cmp": {"name": "BigInt.cmp", "sig": "BigInt.cmp(a, b) -> int", "tip": "Compare two big integers: -1, 0, or 1.", "kind": "namespace-method", "page": "bigint-cmp.html", "section": "BigInt"}, "bigint-eq": {"name": "BigInt.eq", "sig": "BigInt.eq(a, b) -> bool", "tip": "True when two big integers are equal.", "kind": "namespace-method", "page": "bigint-eq.html", "section": "BigInt"}, "bigint-is_zero": {"name": "BigInt.is_zero", "sig": "BigInt.is_zero(a) -> bool", "tip": "True when a big integer is zero.", "kind": "namespace-method", "page": "bigint-is_zero.html", "section": "BigInt"}, "bigint-to_int": {"name": "BigInt.to_int", "sig": "BigInt.to_int(a) -> int", "tip": "Narrow a big integer to a plain int (clamped).", "kind": "namespace-method", "page": "bigint-to_int.html", "section": "BigInt"}, "bigint-str": {"name": "BigInt.str", "sig": "BigInt.str(a) -> string", "tip": "Render a big integer as decimal text.", "kind": "namespace-method", "page": "bigint-str.html", "section": "BigInt"}, "process-spawn": {"name": "Process.spawn", "sig": "Process.spawn(path, args) -> int", "tip": "Start a program; never blocks.", "kind": "namespace-method", "page": "process-spawn.html", "section": "Process"}, "process-poll": {"name": "Process.poll", "sig": "Process.poll(handle) -> int", "tip": "-1 while running, else the exit code.", "kind": "namespace-method", "page": "process-poll.html", "section": "Process"}, "process-kill": {"name": "Process.kill", "sig": "Process.kill(handle) -> void", "tip": "End a running child.", "kind": "namespace-method", "page": "process-kill.html", "section": "Process"}, "process-free": {"name": "Process.free", "sig": "Process.free(handle) -> void", "tip": "Let a process handle go.", "kind": "namespace-method", "page": "process-free.html", "section": "Process"}, "decimal-from": {"name": "Decimal.from", "sig": "Decimal.from(value) -> Decimal", "tip": "Turn a whole int into a Decimal.", "kind": "namespace-method", "page": "decimal-from.html", "section": "Decimal"}, "decimal-parse": {"name": "Decimal.parse", "sig": "Decimal.parse(text) -> Decimal", "tip": "Parse decimal text like \"19.99\".", "kind": "namespace-method", "page": "decimal-parse.html", "section": "Decimal"}, "decimal-add": {"name": "Decimal.add", "sig": "Decimal.add(a, b) -> Decimal", "tip": "Exact sum of two decimals.", "kind": "namespace-method", "page": "decimal-add.html", "section": "Decimal"}, "decimal-sub": {"name": "Decimal.sub", "sig": "Decimal.sub(a, b) -> Decimal", "tip": "Exact difference of two decimals.", "kind": "namespace-method", "page": "decimal-sub.html", "section": "Decimal"}, "decimal-mul": {"name": "Decimal.mul", "sig": "Decimal.mul(a, b) -> Decimal", "tip": "Exact product of two decimals.", "kind": "namespace-method", "page": "decimal-mul.html", "section": "Decimal"}, "decimal-neg": {"name": "Decimal.neg", "sig": "Decimal.neg(a) -> Decimal", "tip": "Negate a decimal.", "kind": "namespace-method", "page": "decimal-neg.html", "section": "Decimal"}, "decimal-cmp": {"name": "Decimal.cmp", "sig": "Decimal.cmp(a, b) -> int", "tip": "Compare two decimals: -1, 0, or 1.", "kind": "namespace-method", "page": "decimal-cmp.html", "section": "Decimal"}, "decimal-eq": {"name": "Decimal.eq", "sig": "Decimal.eq(a, b) -> bool", "tip": "True when two decimals are equal in value.", "kind": "namespace-method", "page": "decimal-eq.html", "section": "Decimal"}, "decimal-scale": {"name": "Decimal.scale", "sig": "Decimal.scale(d) -> int", "tip": "The number of digits after the point.", "kind": "namespace-method", "page": "decimal-scale.html", "section": "Decimal"}, "decimal-rescale": {"name": "Decimal.rescale", "sig": "Decimal.rescale(d, places) -> Decimal", "tip": "Change precision (truncates toward zero).", "kind": "namespace-method", "page": "decimal-rescale.html", "section": "Decimal"}, "decimal-str": {"name": "Decimal.str", "sig": "Decimal.str(d) -> string", "tip": "Render a decimal as text.", "kind": "namespace-method", "page": "decimal-str.html", "section": "Decimal"}, "type-int": {"name": "int", "sig": "int", "tip": "The default 32-bit signed integer — also how colors, keys, and tiles are carried.", "kind": "type", "page": "type-int.html", "section": "Types"}, "type-fixed": {"name": "fixed", "sig": "fixed", "tip": "Q16.16 fixed-point for deterministic fractional math — no floats.", "kind": "type", "page": "type-fixed.html", "section": "Types"}, "type-long": {"name": "long", "sig": "long", "tip": "A 64-bit signed integer for values that overflow a 32-bit int.", "kind": "type", "page": "type-long.html", "section": "Types"}, "type-bool": {"name": "bool", "sig": "bool", "tip": "A truth value — the result of comparisons and of and / or / not.", "kind": "type", "page": "type-bool.html", "section": "Types"}, "type-float": {"name": "float", "sig": "float", "tip": "A 32-bit IEEE floating-point number — what the GPU uses.", "kind": "type", "page": "type-float.html", "section": "Types"}, "type-string": {"name": "string", "sig": "string", "tip": "An immutable string — compared by content, sliceable, and interpolatable.", "kind": "type", "page": "type-string.html", "section": "Types"}, "type-double": {"name": "double", "sig": "double", "tip": "A 64-bit IEEE floating-point number for precise math.", "kind": "type", "page": "type-double.html", "section": "Types"}, "type-entity": {"name": "entity", "sig": "entity", "tip": "The id/handle of a spawned model instance, as returned by self().", "kind": "type", "page": "type-entity.html", "section": "Types"}, "type-pointer": {"name": "pointer", "sig": "pointer", "tip": "A raw address into memory — a byte buffer from bytes(n), or an FFI handle.", "kind": "type", "page": "type-pointer.html", "section": "Types"}, "type-words": {"name": "words", "sig": "words", "tip": "A raw buffer indexed as 32-bit words — each buffer[i] reads or writes an int.", "kind": "type", "page": "type-words.html", "section": "Types"}, "type-byte": {"name": "byte", "sig": "byte", "tip": "A raw buffer indexed one byte at a time — each buffer[i] reads or writes a byte.", "kind": "type", "page": "type-byte.html", "section": "Types"}, "type-slices": {"name": "[]T (slices)", "sig": "[]T", "tip": "A growable slice of T — new []T makes one, push appends, len counts, s[i] indexes.", "kind": "type", "page": "type-slices.html", "section": "Types"}, "type-fixeds": {"name": "fixeds", "sig": "fixeds", "tip": "A buffer of fixed-point values — f[i] reads and writes a fixed.", "kind": "type", "page": "type-fixeds.html", "section": "Types"}, "type-countdown": {"name": "countdown", "sig": "countdown", "tip": "An int component field the engine steps toward 0 once per Update.", "kind": "type", "page": "type-countdown.html", "section": "Types"}, "type-floats": {"name": "floats", "sig": "floats / doubles", "tip": "A buffer of floats (or doubles) — v[i] reads and writes one.", "kind": "type", "page": "type-floats.html", "section": "Types"}, "type-pointers": {"name": "pointers", "sig": "pointers", "tip": "A buffer of pointers — p[i] reads and writes a pointer.", "kind": "type", "page": "type-pointers.html", "section": "Types"}, "type-vector": {"name": "Vector", "sig": "Vector", "tip": "A 2D vector — two fixed components (x, y), copied by value.", "kind": "type", "page": "type-vector.html", "section": "Types"}, "type-ivec2": {"name": "IVec2", "sig": "IVec2", "tip": "An integer 2D vector — two int components (x, y), copied by value.", "kind": "type", "page": "type-ivec2.html", "section": "Types"}, "type-rect": {"name": "Rect", "sig": "Rect", "tip": "A rectangle — position (x, y) and size (w, h), copied by value.", "kind": "type", "page": "type-rect.html", "section": "Types"}, "type-void": {"name": "void", "sig": "void", "tip": "The absence of a value — the return type of a function that returns nothing.", "kind": "type", "page": "type-void.html", "section": "Types"}, "dict-new": {"name": "Dict.new", "sig": "Dict.new() -> Dict", "tip": "Create an empty string-keyed map.", "kind": "namespace-method", "page": "dict-new.html", "section": "Dict"}, "dict-set": {"name": "Dict.set", "sig": "Dict.set(d, key, value)", "tip": "Insert or update a key.", "kind": "namespace-method", "page": "dict-set.html", "section": "Dict"}, "dict-get": {"name": "Dict.get", "sig": "Dict.get(d, key) -> int", "tip": "Look up a key (0 if absent).", "kind": "namespace-method", "page": "dict-get.html", "section": "Dict"}, "dict-get_or": {"name": "Dict.get_or", "sig": "Dict.get_or(d, key, fallback) -> int", "tip": "Look up a key with an explicit default.", "kind": "namespace-method", "page": "dict-get_or.html", "section": "Dict"}, "dict-has": {"name": "Dict.has", "sig": "Dict.has(d, key) -> bool", "tip": "Is a key present?", "kind": "namespace-method", "page": "dict-has.html", "section": "Dict"}, "dict-remove": {"name": "Dict.remove", "sig": "Dict.remove(d, key)", "tip": "Delete a key.", "kind": "namespace-method", "page": "dict-remove.html", "section": "Dict"}, "dict-size": {"name": "Dict.size", "sig": "Dict.size(d) -> int", "tip": "How many keys are stored.", "kind": "namespace-method", "page": "dict-size.html", "section": "Dict"}, "dict-clear": {"name": "Dict.clear", "sig": "Dict.clear(d)", "tip": "Remove every key.", "kind": "namespace-method", "page": "dict-clear.html", "section": "Dict"}, "dict-keys": {"name": "Dict.keys", "sig": "Dict.keys(d) -> []pointer", "tip": "Every key, as a slice of strings.", "kind": "namespace-method", "page": "dict-keys.html", "section": "Dict"}, "op-arith": {"name": "Arithmetic", "sig": "+ - * / %", "tip": "Add, subtract, multiply, integer-divide, and remainder — on int and fixed.", "kind": "operator", "page": "op-arith.html", "section": "Operators & tokens"}, "op-compare": {"name": "Comparison", "sig": "== != < <= > >=", "tip": "Compare two values and yield a bool; on strings == compares contents.", "kind": "operator", "page": "op-compare.html", "section": "Operators & tokens"}, "op-logical": {"name": "Logical", "sig": "and or not", "tip": "The boolean combinators, spelled as words — never && or || or a bare !.", "kind": "operator", "page": "op-logical.html", "section": "Operators & tokens"}, "op-bitwise": {"name": "Bitwise", "sig": "& | ^ ~ << >>", "tip": "Bit-level and, or, xor, not, and shifts — with Go-style precedence.", "kind": "operator", "page": "op-bitwise.html", "section": "Operators & tokens"}, "op-range": {"name": "Range", "sig": "a .. b", "tip": "A half-open range for numeric for loops — from a up to but not including b.", "kind": "operator", "page": "op-range.html", "section": "Operators & tokens"}, "op-assign": {"name": "Assignment", "sig": "name = value", "tip": "Store into a var, a field, or an element — a statement, not an expression.", "kind": "operator", "page": "op-assign.html", "section": "Operators & tokens"}, "op-access": {"name": "Member & index", "sig": "x.field buffer[i] text[a..b]", "tip": "Field access, element index, and string slice — usable as value or target.", "kind": "operator", "page": "op-access.html", "section": "Operators & tokens"}, "op-interp": {"name": "String interpolation", "sig": "`text {expr} more`", "tip": "A backtick string with {expr} holes, each stringified and concatenated.", "kind": "operator", "page": "op-interp.html", "section": "Operators & tokens"}, "op-literals": {"name": "Literals", "sig": "42 0x1E90FF 'w' \"text\" true null", "tip": "Integer, hex, character, string, boolean, and null-pointer literals.", "kind": "operator", "page": "op-literals.html", "section": "Operators & tokens"}, "op-comment": {"name": "Comment", "sig": "# to end of line", "tip": "Everything after # on a line is a comment, ignored by the compiler.", "kind": "operator", "page": "op-comment.html", "section": "Operators & tokens"}, "fn-print": {"name": "print", "sig": "print(x)", "tip": "Print an int or string followed by a newline — for headless tests and debugging.", "kind": "builtin", "page": "fn-print.html", "section": "Builtin functions"}, "fn-string": {"name": "string", "sig": "string(x) -> string", "tip": "Convert an int, bool, or fixed value to text; a string passes through unchanged.", "kind": "builtin", "page": "fn-string.html", "section": "Builtin functions"}, "fn-quit": {"name": "quit", "sig": "quit()", "tip": "Stop the game loop cleanly after the current frame finishes.", "kind": "builtin", "page": "fn-quit.html", "section": "Builtin functions"}, "fn-save": {"name": "save", "sig": "save()", "tip": "Serialize the whole world — every model instance, property, and program var — in one call.", "kind": "builtin", "page": "fn-save.html", "section": "Builtin functions"}, "fn-load": {"name": "load", "sig": "load() -> bool", "tip": "Restore the world from a snapshot previously written by save().", "kind": "builtin", "page": "fn-load.html", "section": "Builtin functions"}, "fn-len": {"name": "len", "sig": "len(x) -> int", "tip": "The number of elements in a slice, or the byte length of a string.", "kind": "builtin", "page": "fn-len.html", "section": "Builtin functions"}, "fn-push": {"name": "push", "sig": "push(slice, x)", "tip": "Append one element to the end of a growable slice.", "kind": "builtin", "page": "fn-push.html", "section": "Builtin functions"}, "fn-abs": {"name": "abs", "sig": "abs(a) -> int", "tip": "The absolute value of an integer (its magnitude, never negative).", "kind": "builtin", "page": "fn-abs.html", "section": "Builtin functions"}, "fn-clamp": {"name": "clamp", "sig": "clamp(v, lo, hi) -> int", "tip": "Constrain a value to the inclusive range [lo, hi].", "kind": "builtin", "page": "fn-clamp.html", "section": "Builtin functions"}, "fn-panic": {"name": "panic", "sig": "panic(msg: string)", "tip": "Abort with a located error message instead of crashing.", "kind": "builtin", "page": "fn-panic.html", "section": "Builtin functions"}, "fn-assert": {"name": "assert", "sig": "assert(cond: bool, msg: string)", "tip": "Abort with a located message when an invariant is false.", "kind": "builtin", "page": "fn-assert.html", "section": "Builtin functions"}, "fn-ok": {"name": "ok", "sig": "ok(v) -> result", "tip": "Wrap a success payload in a result — the happy half of try/else.", "kind": "builtin", "page": "fn-ok.html", "section": "Builtin functions"}, "fn-err": {"name": "err", "sig": "err(msg: string) -> result", "tip": "Wrap a failure message in a result — the sad half, recovered by try/else.", "kind": "builtin", "page": "fn-err.html", "section": "Builtin functions"}, "fn-is_ok": {"name": "is_ok", "sig": "is_ok(r: result) -> bool", "tip": "True when a result carries a success payload.", "kind": "builtin", "page": "fn-is_ok.html", "section": "Builtin functions"}, "fn-is_err": {"name": "is_err", "sig": "is_err(r: result) -> bool", "tip": "True when a result carries a failure.", "kind": "builtin", "page": "fn-is_err.html", "section": "Builtin functions"}, "fn-some": {"name": "some", "sig": "some(v) -> option", "tip": "Wrap a present value in an option.", "kind": "builtin", "page": "fn-some.html", "section": "Builtin functions"}, "fn-none": {"name": "none", "sig": "none() -> option", "tip": "The empty option — a missing value.", "kind": "builtin", "page": "fn-none.html", "section": "Builtin functions"}, "fn-is_some": {"name": "is_some", "sig": "is_some(o: option) -> bool", "tip": "True when an option holds a value.", "kind": "builtin", "page": "fn-is_some.html", "section": "Builtin functions"}, "fn-is_none": {"name": "is_none", "sig": "is_none(o: option) -> bool", "tip": "True when an option is empty.", "kind": "builtin", "page": "fn-is_none.html", "section": "Builtin functions"}, "fn-unwrap_or": {"name": "unwrap_or", "sig": "unwrap_or(o: option, fallback) -> int", "tip": "The option value, or a fallback if empty.", "kind": "builtin", "page": "fn-unwrap_or.html", "section": "Builtin functions"}, "fn-exit": {"name": "exit", "sig": "exit(code)", "tip": "Terminate the process immediately with a status code.", "kind": "builtin", "page": "fn-exit.html", "section": "Builtin functions"}, "fn-run": {"name": "run", "sig": "run(cmd)", "tip": "Run a string as a shell command.", "kind": "builtin", "page": "fn-run.html", "section": "Builtin functions"}, "fn-getenv": {"name": "getenv", "sig": "getenv(name) -> string", "tip": "Read an environment variable, returning empty when it is unset.", "kind": "builtin", "page": "fn-getenv.html", "section": "Builtin functions"}, "fn-read_char": {"name": "read_char", "sig": "read_char() -> int", "tip": "Read one byte from standard input, or -1 at end of input.", "kind": "builtin", "page": "fn-read_char.html", "section": "Builtin functions"}, "fn-arg": {"name": "arg", "sig": "arg(i) -> string", "tip": "The i-th command-line argument as a string.", "kind": "builtin", "page": "fn-arg.html", "section": "Builtin functions"}, "fn-arg_count": {"name": "arg_count", "sig": "arg_count() -> int", "tip": "The number of command-line arguments, counting the program name.", "kind": "builtin", "page": "fn-arg_count.html", "section": "Builtin functions"}, "fn-bytes": {"name": "bytes", "sig": "bytes(n) -> pointer", "tip": "Allocate a raw buffer of n bytes and return a pointer to it.", "kind": "builtin", "page": "fn-bytes.html", "section": "Builtin functions"}, "fn-file_stderr": {"name": "file_stderr", "sig": "file_stderr() -> pointer", "tip": "The standard-error stream handle for use with file_write.", "kind": "builtin", "page": "fn-file_stderr.html", "section": "Builtin functions"}, "fn-file_stdout": {"name": "file_stdout", "sig": "file_stdout() -> pointer", "tip": "The standard-output stream handle for use with file_write.", "kind": "builtin", "page": "fn-file_stdout.html", "section": "Builtin functions"}, "fn-file_write": {"name": "file_write", "sig": "file_write(handle, buf, len)", "tip": "Write a run of raw bytes to a stream handle.", "kind": "builtin", "page": "fn-file_write.html", "section": "Builtin functions"}, "fn-fixed": {"name": "fixed", "sig": "fixed(x) -> fixed", "tip": "Convert an int (or a float) into a Q16.16 fixed-point value.", "kind": "builtin", "page": "fn-fixed.html", "section": "Builtin functions"}, "fn-floor": {"name": "floor", "sig": "floor(x) -> int", "tip": "Floor a fixed-point value down to the nearest integer.", "kind": "builtin", "page": "fn-floor.html", "section": "Builtin functions"}, "fn-max": {"name": "max", "sig": "max(a, b) -> int", "tip": "The larger of two integers.", "kind": "builtin", "page": "fn-max.html", "section": "Builtin functions"}, "fn-min": {"name": "min", "sig": "min(a, b) -> int", "tip": "The smaller of two integers.", "kind": "builtin", "page": "fn-min.html", "section": "Builtin functions"}, "fn-ui_build": {"name": "ui_build", "sig": "ui_build()", "tip": "Build the declared UI tree so it can be opened and rendered.", "kind": "builtin", "page": "fn-ui_build.html", "section": "Builtin functions"}, "fn-words": {"name": "words", "sig": "words(n) -> words", "tip": "Allocate a raw buffer of n 32-bit words, indexable with [i].", "kind": "builtin", "page": "fn-words.html", "section": "Builtin functions"}, "fn-float": {"name": "float", "sig": "float(x) -> float / double(x) -> double", "tip": "Convert any number to a float (or double).", "kind": "builtin", "page": "fn-float.html", "section": "Builtin functions"}, "fn-int": {"name": "int", "sig": "int(x) -> int / long(x) -> long", "tip": "Convert a number to a whole number, truncating toward zero.", "kind": "builtin", "page": "fn-int.html", "section": "Builtin functions"}, "fn-float_bits": {"name": "float_bits", "sig": "float_bits(x) -> int / float_from_bits(bits) -> float", "tip": "A float's IEEE bit pattern as an int, and back.", "kind": "builtin", "page": "fn-float_bits.html", "section": "Builtin functions"}, "set-new": {"name": "Set.new", "sig": "Set.new() -> Set", "tip": "Create an empty string set.", "kind": "namespace-method", "page": "set-new.html", "section": "Set"}, "set-add": {"name": "Set.add", "sig": "Set.add(s, key)", "tip": "Add a member (duplicates ignored).", "kind": "namespace-method", "page": "set-add.html", "section": "Set"}, "set-has": {"name": "Set.has", "sig": "Set.has(s, key) -> bool", "tip": "Is a member present?", "kind": "namespace-method", "page": "set-has.html", "section": "Set"}, "set-remove": {"name": "Set.remove", "sig": "Set.remove(s, key)", "tip": "Remove a member.", "kind": "namespace-method", "page": "set-remove.html", "section": "Set"}, "set-size": {"name": "Set.size", "sig": "Set.size(s) -> int", "tip": "How many members.", "kind": "namespace-method", "page": "set-size.html", "section": "Set"}, "set-clear": {"name": "Set.clear", "sig": "Set.clear(s)", "tip": "Remove every member.", "kind": "namespace-method", "page": "set-clear.html", "section": "Set"}, "set-members": {"name": "Set.members", "sig": "Set.members(s) -> []pointer", "tip": "Every member, as a slice of strings.", "kind": "namespace-method", "page": "set-members.html", "section": "Set"}, "annot-queries": {"name": "@Queries", "sig": "@Queries(these: [Position, Velocity])", "tip": "Declare the properties a handler operates on, binding their fields by name in the body.", "kind": "annotation", "page": "annot-queries.html", "section": "Annotations"}, "annot-computed": {"name": "@Computed", "sig": "@Computed on a property field", "tip": "A derived field expanded inline wherever it is read, never stored.", "kind": "annotation", "page": "annot-computed.html", "section": "Annotations"}, "annot-on": {"name": "@On", "sig": "@On(Event) handler Name { … }", "tip": "Register a compile-time listener that runs whenever an event is emitted.", "kind": "annotation", "page": "annot-on.html", "section": "Annotations"}, "annot-export": {"name": "@export", "sig": "@export function name(…) -> R", "tip": "Expose a function as a native symbol so a host can call it.", "kind": "annotation", "page": "annot-export.html", "section": "Annotations"}, "annot-sync": {"name": "@Sync", "sig": "@Sync property … / @Owned", "tip": "Mark fields as replicated and models as owned so the compiler generates networking.", "kind": "annotation", "page": "annot-sync.html", "section": "Annotations"}, "annot-handles": {"name": "@Handles", "sig": "@Handles(Event) handler Name { … }", "tip": "Declarative hint naming the event or subsystem a handler is responsible for.", "kind": "annotation", "page": "annot-handles.html", "section": "Annotations"}, "annot-onattach": {"name": "@OnAttach", "sig": "@OnAttach(Property) handler Name { … }", "tip": "Run a handler when a property is structurally attached to a live instance.", "kind": "annotation", "page": "annot-onattach.html", "section": "Annotations"}, "annot-ondespawn": {"name": "@OnDespawn", "sig": "@OnDespawn(Model, reason: r) handler Name { … }", "tip": "Run a handler when a model instance is torn down, optionally knowing why.", "kind": "annotation", "page": "annot-ondespawn.html", "section": "Annotations"}, "annot-ondetach": {"name": "@OnDetach", "sig": "@OnDetach(Property) handler Name { … }", "tip": "Run a handler when a property is structurally detached from a live instance.", "kind": "annotation", "page": "annot-ondetach.html", "section": "Annotations"}, "annot-ondisable": {"name": "@OnDisable", "sig": "@OnDisable(Property) handler Name { … }", "tip": "Run a handler when a property is paused (disabled) on an instance.", "kind": "annotation", "page": "annot-ondisable.html", "section": "Annotations"}, "annot-onenable": {"name": "@OnEnable", "sig": "@OnEnable(Property) handler Name { … }", "tip": "Run a handler when a paused property is re-enabled on an instance.", "kind": "annotation", "page": "annot-onenable.html", "section": "Annotations"}, "annot-onquit": {"name": "@OnQuit", "sig": "@OnQuit handler Name { … }", "tip": "Run a handler once at shutdown, after the last frame.", "kind": "annotation", "page": "annot-onquit.html", "section": "Annotations"}, "annot-onspawn": {"name": "@OnSpawn", "sig": "@OnSpawn(Model) handler Name { … }", "tip": "Run a handler once each time an instance of a model is spawned.", "kind": "annotation", "page": "annot-onspawn.html", "section": "Annotations"}, "annot-onstart": {"name": "@OnStart", "sig": "@OnStart handler Name { … }", "tip": "Run a handler once at boot instead of assigning it a frame phase.", "kind": "annotation", "page": "annot-onstart.html", "section": "Annotations"}, "annot-owned": {"name": "@Owned", "sig": "@Owned model Name { … }", "tip": "Give a model a network owner slot so its instances can be assigned to a peer.", "kind": "annotation", "page": "annot-owned.html", "section": "Annotations"}, "annot-predicted": {"name": "@Predicted", "sig": "@Predicted handler Name { … }", "tip": "Run a control handler on the owning client speculatively and on the server authoritatively.", "kind": "annotation", "page": "annot-predicted.html", "section": "Annotations"}, "annot-public": {"name": "@Public", "sig": "@Public @OnSpawn(Model) handler … { … }", "tip": "Promote a lifecycle hook to a public event other modules can listen for.", "kind": "annotation", "page": "annot-public.html", "section": "Annotations"}, "annot-reads": {"name": "@Reads", "sig": "@Reads(Property)", "tip": "Declare that a handler reads a property — an analysis and scheduling hint.", "kind": "annotation", "page": "annot-reads.html", "section": "Annotations"}, "annot-server": {"name": "@Server", "sig": "@Server handler Name { … }", "tip": "Run a handler only on the authority; clients receive the result via @Sync.", "kind": "annotation", "page": "annot-server.html", "section": "Annotations"}, "annot-toclients": {"name": "@ToClients", "sig": "@ToClients event Name { … }", "tip": "A remote event broadcast from the server to clients — a server→clients notification.", "kind": "annotation", "page": "annot-toclients.html", "section": "Annotations"}, "annot-toserver": {"name": "@ToServer", "sig": "@ToServer event Name { … }", "tip": "A remote event sent from a client to the server — a client→server request.", "kind": "annotation", "page": "annot-toserver.html", "section": "Annotations"}, "annot-writes": {"name": "@Writes", "sig": "@Writes(Property)", "tip": "Declare that a handler writes a property — an analysis and scheduling hint.", "kind": "annotation", "page": "annot-writes.html", "section": "Annotations"}, "annot-enginesystem": {"name": "@EngineSystem", "sig": "\"@EngineSystem(Component, Phase) function esys_name() { … }\"", "tip": "Register a package's engine-owned system so the frame loop runs it each phase.", "kind": "annotation", "page": "annot-enginesystem.html", "section": "Annotations"}, "annot-namespace": {"name": "@Namespace", "sig": "\"@Namespace(Name) function name_method(…) -> T { … }\"", "tip": "Let a package provide a Name.method(…) namespace that dispatches to name_method.", "kind": "annotation", "page": "annot-namespace.html", "section": "Annotations"}, "annot-clearcolor": {"name": "\"@ClearColor\"", "sig": "\"@ClearColor(0xRRGGBB) handler Draw phase Render { … }\"", "tip": "Declare a clear colour so the Render phase auto-clears + auto-presents for you.", "kind": "annotation", "page": "annot-clearcolor.html", "section": "Annotations"}, "annot-system": {"name": "@System", "sig": "\"@System(Phase) function name() { … }\"", "tip": "Register a prebuilt binary module's system with the host at load, per phase.", "kind": "annotation", "page": "annot-system.html", "section": "Annotations"}, "huge-from": {"name": "Huge.from", "sig": "Huge.from(value) -> Huge", "tip": "Turn an int into a Huge.", "kind": "namespace-method", "page": "huge-from.html", "section": "Huge"}, "huge-add": {"name": "Huge.add", "sig": "Huge.add(a, b) -> Huge", "tip": "Sum of two big numbers.", "kind": "namespace-method", "page": "huge-add.html", "section": "Huge"}, "huge-sub": {"name": "Huge.sub", "sig": "Huge.sub(a, b) -> Huge", "tip": "Difference of two big numbers.", "kind": "namespace-method", "page": "huge-sub.html", "section": "Huge"}, "huge-mul": {"name": "Huge.mul", "sig": "Huge.mul(a, b) -> Huge", "tip": "Product of two big numbers.", "kind": "namespace-method", "page": "huge-mul.html", "section": "Huge"}, "huge-neg": {"name": "Huge.neg", "sig": "Huge.neg(a) -> Huge", "tip": "Negate a big number.", "kind": "namespace-method", "page": "huge-neg.html", "section": "Huge"}, "huge-cmp": {"name": "Huge.cmp", "sig": "Huge.cmp(a, b) -> int", "tip": "Compare two big numbers: -1, 0, or 1.", "kind": "namespace-method", "page": "huge-cmp.html", "section": "Huge"}, "huge-sign": {"name": "Huge.sign", "sig": "Huge.sign(a) -> int", "tip": "The sign: -1, 0, or 1.", "kind": "namespace-method", "page": "huge-sign.html", "section": "Huge"}, "huge-mantissa": {"name": "Huge.mantissa", "sig": "Huge.mantissa(a) -> fixed", "tip": "The mantissa in [1, 10).", "kind": "namespace-method", "page": "huge-mantissa.html", "section": "Huge"}, "huge-exp": {"name": "Huge.exp", "sig": "Huge.exp(a) -> int", "tip": "The base-10 exponent.", "kind": "namespace-method", "page": "huge-exp.html", "section": "Huge"}, "huge-str": {"name": "Huge.str", "sig": "Huge.str(a) -> string", "tip": "Render as scientific text like 1.23e45.", "kind": "namespace-method", "page": "huge-str.html", "section": "Huge"}, "angle-from_degrees": {"name": "Angle.from_degrees", "sig": "Angle.from_degrees(d) -> fixed", "tip": "Degrees to a wrapped radian angle.", "kind": "namespace-method", "page": "angle-from_degrees.html", "section": "Angle"}, "angle-to_degrees": {"name": "Angle.to_degrees", "sig": "Angle.to_degrees(a) -> fixed", "tip": "Radians back to degrees.", "kind": "namespace-method", "page": "angle-to_degrees.html", "section": "Angle"}, "angle-wrap": {"name": "Angle.wrap", "sig": "Angle.wrap(a) -> fixed", "tip": "Normalize any radian value to [-pi, pi).", "kind": "namespace-method", "page": "angle-wrap.html", "section": "Angle"}, "angle-sin": {"name": "Angle.sin", "sig": "Angle.sin(a) -> fixed", "tip": "Sine of an angle.", "kind": "namespace-method", "page": "angle-sin.html", "section": "Angle"}, "angle-cos": {"name": "Angle.cos", "sig": "Angle.cos(a) -> fixed", "tip": "Cosine of an angle.", "kind": "namespace-method", "page": "angle-cos.html", "section": "Angle"}, "angle-add": {"name": "Angle.add", "sig": "Angle.add(a, b) -> fixed", "tip": "Add two angles (wrapped).", "kind": "namespace-method", "page": "angle-add.html", "section": "Angle"}, "angle-diff": {"name": "Angle.diff", "sig": "Angle.diff(a, b) -> fixed", "tip": "Shortest signed rotation from a to b.", "kind": "namespace-method", "page": "angle-diff.html", "section": "Angle"}, "angle-lerp": {"name": "Angle.lerp", "sig": "Angle.lerp(a, b, t) -> fixed", "tip": "Interpolate along the shortest arc.", "kind": "namespace-method", "page": "angle-lerp.html", "section": "Angle"}, "angle-diff_degrees": {"name": "Angle.diff_degrees", "sig": "Angle.diff_degrees(a: int, b: int) -> int", "tip": "The signed difference between two headings in whole degrees.", "kind": "namespace-method", "page": "angle-diff_degrees.html", "section": "Angle"}, "percent-clamp": {"name": "Percent.clamp", "sig": "Percent.clamp(v) -> fixed", "tip": "Clamp any fixed into [0, 1].", "kind": "namespace-method", "page": "percent-clamp.html", "section": "Percent"}, "percent-of": {"name": "Percent.of", "sig": "Percent.of(num, den) -> fixed", "tip": "Clamped ratio num / den.", "kind": "namespace-method", "page": "percent-of.html", "section": "Percent"}, "percent-lerp": {"name": "Percent.lerp", "sig": "Percent.lerp(a, b, t) -> fixed", "tip": "Interpolate a..b by a clamped t.", "kind": "namespace-method", "page": "percent-lerp.html", "section": "Percent"}, "percent-apply": {"name": "Percent.apply", "sig": "Percent.apply(value, p) -> fixed", "tip": "Scale a value by a clamped percent.", "kind": "namespace-method", "page": "percent-apply.html", "section": "Percent"}, "regex-compile": {"name": "Regex.compile", "sig": "Regex.compile(pattern) -> Regex", "tip": "Compile a pattern once for reuse; returns an error value (null) if it is invalid.", "kind": "namespace-method", "page": "regex-compile.html", "section": "Regex"}, "regex-valid": {"name": "Regex.valid", "sig": "Regex.valid(pattern) -> bool", "tip": "True if the pattern is well-formed (compiles without error).", "kind": "namespace-method", "page": "regex-valid.html", "section": "Regex"}, "regex-matches": {"name": "Regex.matches", "sig": "Regex.matches(text, pattern) -> bool", "tip": "True if the pattern matches anywhere in the text (a search).", "kind": "namespace-method", "page": "regex-matches.html", "section": "Regex"}, "regex-test": {"name": "Regex.test", "sig": "Regex.test(text, re) -> bool", "tip": "Like matches, but reuses an already-compiled Regex.", "kind": "namespace-method", "page": "regex-test.html", "section": "Regex"}, "regex-find": {"name": "Regex.find", "sig": "Regex.find(text, pattern) -> Match", "tip": "The first match of the pattern in the text (a Match, or null if none).", "kind": "namespace-method", "page": "regex-find.html", "section": "Regex"}, "regex-exec": {"name": "Regex.exec", "sig": "Regex.exec(text, re) -> Match", "tip": "Like find, but with an already-compiled Regex.", "kind": "namespace-method", "page": "regex-exec.html", "section": "Regex"}, "regex-next": {"name": "Regex.next", "sig": "Regex.next(text, re, from) -> Match", "tip": "The next match at or after byte offset from — the basis of a find-all loop.", "kind": "namespace-method", "page": "regex-next.html", "section": "Regex"}, "regex-replace": {"name": "Regex.replace", "sig": "Regex.replace(text, pattern, replacement) -> string", "tip": "Replace every match; the replacement expands \\0..\\9 group references.", "kind": "namespace-method", "page": "regex-replace.html", "section": "Regex"}, "regex-group": {"name": "Regex.group", "sig": "Regex.group(match, n) -> string", "tip": "The text of capture group n (group 0 is the whole match); empty if unset.", "kind": "namespace-method", "page": "regex-group.html", "section": "Regex"}, "regex-group_count": {"name": "Regex.group_count", "sig": "Regex.group_count(match) -> int", "tip": "How many capture groups the match's pattern has.", "kind": "namespace-method", "page": "regex-group_count.html", "section": "Regex"}, "regex-start": {"name": "Regex.start", "sig": "Regex.start(match, n) -> int", "tip": "The start byte offset of group n, or -1 if it did not participate.", "kind": "namespace-method", "page": "regex-start.html", "section": "Regex"}, "regex-end": {"name": "Regex.end", "sig": "Regex.end(match, n) -> int", "tip": "The end byte offset of group n, or -1 if it did not participate.", "kind": "namespace-method", "page": "regex-end.html", "section": "Regex"}, "regex-ok": {"name": "Regex.ok", "sig": "Regex.ok(match) -> bool", "tip": "True if the match succeeded (the Match is non-null).", "kind": "namespace-method", "page": "regex-ok.html", "section": "Regex"}, "grid-line": {"name": "Grid.line", "sig": "Grid.line(x0, y0, x1, y1) -> []Cell", "tip": "Every cell a straight line from (x0,y0) to (x1,y1) crosses (Bresenham).", "kind": "namespace-method", "page": "grid-line.html", "section": "Grid"}, "grid-blocked": {"name": "Grid.blocked", "sig": "Grid.blocked(x, y, wall) -> bool", "tip": "True if the cell is out of bounds or holds the wall tile.", "kind": "namespace-method", "page": "grid-blocked.html", "section": "Grid"}, "grid-line_of_sight": {"name": "Grid.line_of_sight", "sig": "Grid.line_of_sight(x0, y0, x1, y1, wall) -> bool", "tip": "True if the straight line between two cells crosses no wall.", "kind": "namespace-method", "page": "grid-line_of_sight.html", "section": "Grid"}, "grid-flood": {"name": "Grid.flood", "sig": "Grid.flood(x, y, wall) -> []Cell", "tip": "Every passable cell reachable from (x,y), 4-connected, in BFS order.", "kind": "namespace-method", "page": "grid-flood.html", "section": "Grid"}, "grid-a_star": {"name": "Grid.a_star", "sig": "Grid.a_star(x0, y0, x1, y1, wall) -> []Cell", "tip": "The shortest 4-connected path between two cells (A*), or an empty list.", "kind": "namespace-method", "page": "grid-a_star.html", "section": "Grid"}, "anim-frame": {"name": "Anim.frame", "sig": "Anim.frame(timer, fps, count) -> int", "tip": "The looping frame index for an elapsed timer at a given fps.", "kind": "namespace-method", "page": "anim-frame.html", "section": "Anim"}, "anim-once": {"name": "Anim.once", "sig": "Anim.once(timer, fps, count) -> int", "tip": "A non-looping frame index that clamps on the last frame.", "kind": "namespace-method", "page": "anim-once.html", "section": "Anim"}, "anim-pingpong": {"name": "Anim.pingpong", "sig": "Anim.pingpong(timer, fps, count) -> int", "tip": "A frame index that bounces 0..count-1..0 and repeats.", "kind": "namespace-method", "page": "anim-pingpong.html", "section": "Anim"}, "anim-finished": {"name": "Anim.finished", "sig": "Anim.finished(timer, fps, count) -> bool", "tip": "True once a one-shot clip has run past its last frame.", "kind": "namespace-method", "page": "anim-finished.html", "section": "Anim"}, "anim-duration": {"name": "Anim.duration", "sig": "Anim.duration(fps, count) -> fixed", "tip": "Seconds for one full cycle of a clip: count / fps.", "kind": "namespace-method", "page": "anim-duration.html", "section": "Anim"}, "anim-cell_x": {"name": "Anim.cell_x", "sig": "Anim.cell_x(frame, cols, cell_w) -> int", "tip": "The source x (pixels) of a frame on a grid spritesheet.", "kind": "namespace-method", "page": "anim-cell_x.html", "section": "Anim"}, "anim-cell_y": {"name": "Anim.cell_y", "sig": "Anim.cell_y(frame, cols, cell_h) -> int", "tip": "The source y (pixels) of a frame on a grid spritesheet.", "kind": "namespace-method", "page": "anim-cell_y.html", "section": "Anim"}, "anim-play": {"name": "Anim.play", "sig": "Anim.play(entity, clip) | Anim.play(entity, fps, frames, mode)", "tip": "Start (or restart) a spritesheet clip on an entity in one call.", "kind": "namespace-method", "page": "anim-play.html", "section": "Anim"}, "anim-clip": {"name": "Anim.clip", "sig": "Anim.clip(name, frames, fps, mode)", "tip": "Register a named spritesheet clip so Anim.play can play it by name.", "kind": "namespace-method", "page": "anim-clip.html", "section": "Anim"}, "anim-on_frame": {"name": "Anim.on_frame", "sig": "Anim.on_frame(entity, frame)", "tip": "Arm a frame event — the engine flags the tick a clip lands on this frame.", "kind": "namespace-method", "page": "anim-on_frame.html", "section": "Anim"}, "anim-fired": {"name": "Anim.fired", "sig": "Anim.fired(entity) -> bool", "tip": "Did the entity's clip land on its armed frame event this tick?", "kind": "namespace-method", "page": "anim-fired.html", "section": "Anim"}, "motion-to": {"name": "Motion.to", "sig": "Motion.to(entity, from, to, dur, ease)", "tip": "Start a value tween on an entity's Motion component in one call.", "kind": "namespace-method", "page": "motion-to.html", "section": "Motion"}, "tween-progress": {"name": "Tween.progress", "sig": "Tween.progress(timer, duration) -> fixed", "tip": "A one-shot 0..1 amount, clamped, for timer over duration.", "kind": "namespace-method", "page": "tween-progress.html", "section": "Tween"}, "tween-loop": {"name": "Tween.loop", "sig": "Tween.loop(timer, duration) -> fixed", "tip": "A repeating 0..1 sawtooth amount over duration.", "kind": "namespace-method", "page": "tween-loop.html", "section": "Tween"}, "tween-yoyo": {"name": "Tween.yoyo", "sig": "Tween.yoyo(timer, duration) -> fixed", "tip": "A repeating 0..1..0 triangle amount over duration.", "kind": "namespace-method", "page": "tween-yoyo.html", "section": "Tween"}, "tween-done": {"name": "Tween.done", "sig": "Tween.done(timer, duration) -> bool", "tip": "True once a one-shot tween's timer reaches its duration.", "kind": "namespace-method", "page": "tween-done.html", "section": "Tween"}, "tween-ease": {"name": "Tween.ease", "sig": "Tween.ease(t, mode) -> fixed", "tip": "Shape a 0..1 amount through an easing curve chosen by a literal mode.", "kind": "namespace-method", "page": "tween-ease.html", "section": "Tween"}, "tween-number": {"name": "Tween.number", "sig": "Tween.number(from, to, t) -> fixed", "tip": "Linear blend of two fixeds by amount t.", "kind": "namespace-method", "page": "tween-number.html", "section": "Tween"}, "tween-round": {"name": "Tween.round", "sig": "Tween.round(from, to, t) -> int", "tip": "Linear blend of two ints by amount t, rounded to the nearest int.", "kind": "namespace-method", "page": "tween-round.html", "section": "Tween"}, "tween-point": {"name": "Tween.point", "sig": "Tween.point(from, to, t) -> Vector", "tip": "Component-wise blend of two Vectors by amount t.", "kind": "namespace-method", "page": "tween-point.html", "section": "Tween"}, "tween-tint": {"name": "Tween.tint", "sig": "Tween.tint(from, to, t) -> int", "tip": "Per-channel blend of two colors by amount t.", "kind": "namespace-method", "page": "tween-tint.html", "section": "Tween"}, "tween-to": {"name": "Tween.to", "sig": "Tween.to(from, to, dur, ease) -> handle", "tip": "Start a fluent, engine-advanced tween and return a handle.", "kind": "namespace-method", "page": "tween-to.html", "section": "Tween"}, "tween-chain": {"name": "Tween.chain", "sig": "Tween.chain(handle, to, dur, ease) -> handle", "tip": "Append a tween segment that runs after the handle's current queue.", "kind": "namespace-method", "page": "tween-chain.html", "section": "Tween"}, "tween-delay": {"name": "Tween.delay", "sig": "Tween.delay(handle, ticks) -> handle", "tip": "Append a pause to a tween handle's sequence.", "kind": "namespace-method", "page": "tween-delay.html", "section": "Tween"}, "tween-value": {"name": "Tween.value", "sig": "Tween.value(handle) -> int", "tip": "The current value of a fluent tween handle this frame.", "kind": "namespace-method", "page": "tween-value.html", "section": "Tween"}, "tween-stop": {"name": "Tween.stop", "sig": "Tween.stop(handle)", "tip": "Stop and dispose a tween handle, freezing its value.", "kind": "namespace-method", "page": "tween-stop.html", "section": "Tween"}, "tween-parallel": {"name": "Tween.parallel", "sig": "Tween.parallel(a, b) -> bool", "tip": "Are two tween handles both finished? — a parallel completion query.", "kind": "namespace-method", "page": "tween-parallel.html", "section": "Tween"}, "query-count": {"name": "Query.count", "sig": "Query.count(prop) -> int", "tip": "How many live entities carry a property.", "kind": "namespace-method", "page": "query-count.html", "section": "Query"}, "query-first": {"name": "Query.first", "sig": "Query.first(prop) -> int", "tip": "The lowest-id live entity carrying a property, or -1.", "kind": "namespace-method", "page": "query-first.html", "section": "Query"}, "query-nearest": {"name": "Query.nearest", "sig": "Query.nearest(prop, pos, x_field, y_field, x, y) -> int", "tip": "The bearer of prop closest to a point, by squared distance.", "kind": "namespace-method", "page": "query-nearest.html", "section": "Query"}, "query-within": {"name": "Query.within", "sig": "Query.within(prop, pos, x, y, radius, x_field, y_field) -> []int", "tip": "Every bearer of prop inside a radius of a point.", "kind": "namespace-method", "page": "query-within.html", "section": "Query"}, "reflect-prop": {"name": "Reflect.prop", "sig": "Reflect.prop(name) -> int", "tip": "The property id for a property name, or -1 if unknown.", "kind": "namespace-method", "page": "reflect-prop.html", "section": "Reflect"}, "reflect-field": {"name": "Reflect.field", "sig": "Reflect.field(prop, name) -> int", "tip": "The field id of a named field within a property, or -1.", "kind": "namespace-method", "page": "reflect-field.html", "section": "Reflect"}, "reflect-prop_count": {"name": "Reflect.prop_count", "sig": "Reflect.prop_count() -> int", "tip": "How many properties the world schema defines.", "kind": "namespace-method", "page": "reflect-prop_count.html", "section": "Reflect"}, "reflect-prop_name": {"name": "Reflect.prop_name", "sig": "Reflect.prop_name(index) -> string", "tip": "The name of the property at an index (or \"\").", "kind": "namespace-method", "page": "reflect-prop_name.html", "section": "Reflect"}, "reflect-field_count": {"name": "Reflect.field_count", "sig": "Reflect.field_count(prop) -> int", "tip": "How many fields a property has.", "kind": "namespace-method", "page": "reflect-field_count.html", "section": "Reflect"}, "reflect-field_name": {"name": "Reflect.field_name", "sig": "Reflect.field_name(prop, index) -> string", "tip": "The name of the field at an index within a property.", "kind": "namespace-method", "page": "reflect-field_name.html", "section": "Reflect"}, "reflect-field_type": {"name": "Reflect.field_type", "sig": "Reflect.field_type(prop, index) -> string", "tip": "The type name of the field at an index within a property.", "kind": "namespace-method", "page": "reflect-field_type.html", "section": "Reflect"}, "reflect-get": {"name": "Reflect.get", "sig": "Reflect.get(entity, prop, field) -> int", "tip": "Read one field of an entity by (prop, field) id.", "kind": "namespace-method", "page": "reflect-get.html", "section": "Reflect"}, "reflect-set": {"name": "Reflect.set", "sig": "Reflect.set(entity, prop, field, value)", "tip": "Write one field of an entity by (prop, field) id.", "kind": "namespace-method", "page": "reflect-set.html", "section": "Reflect"}, "reflect-has": {"name": "Reflect.has", "sig": "Reflect.has(entity, prop) -> bool", "tip": "Does an entity carry a property?", "kind": "namespace-method", "page": "reflect-has.html", "section": "Reflect"}, "reflect-kind": {"name": "Reflect.kind", "sig": "Reflect.kind(entity) -> int", "tip": "The model id of an entity.", "kind": "namespace-method", "page": "reflect-kind.html", "section": "Reflect"}, "reflect-model": {"name": "Reflect.model", "sig": "Reflect.model(name) -> int", "tip": "The model id for a model name, or -1 if unknown.", "kind": "namespace-method", "page": "reflect-model.html", "section": "Reflect"}, "reflect-serialize": {"name": "Reflect.serialize", "sig": "Reflect.serialize(entity) -> value", "tip": "Walk an entity's components into a value tree.", "kind": "namespace-method", "page": "reflect-serialize.html", "section": "Reflect"}, "reflect-apply": {"name": "Reflect.apply", "sig": "Reflect.apply(entity, value) -> int", "tip": "Write a value tree's fields back into an entity.", "kind": "namespace-method", "page": "reflect-apply.html", "section": "Reflect"}, "camera-set": {"name": "Camera.set", "sig": "Camera.set(x, y)", "tip": "Place the camera at a world-space offset.", "kind": "namespace-method", "page": "camera-set.html", "section": "Camera"}, "camera-follow": {"name": "Camera.follow", "sig": "Camera.follow(x, y, lerp)", "tip": "Ease the camera toward centring a target point.", "kind": "namespace-method", "page": "camera-follow.html", "section": "Camera"}, "camera-shake": {"name": "Camera.shake", "sig": "Camera.shake(amount)", "tip": "Jitter the camera by up to +/- amount pixels (seeded RNG).", "kind": "namespace-method", "page": "camera-shake.html", "section": "Camera"}, "camera-zoom": {"name": "Camera.zoom", "sig": "Camera.zoom(scale)", "tip": "Scale the whole view about the screen centre by a Q16.16 factor (1.0 = none).", "kind": "namespace-method", "page": "camera-zoom.html", "section": "Camera"}, "camera-shake_for": {"name": "Camera.shake_for", "sig": "Camera.shake_for(amount: px, frames: n)", "tip": "Shake for a number of frames, then stop, with no bookkeeping.", "kind": "namespace-method", "page": "camera-shake_for.html", "section": "Camera"}, "light-ambient": {"name": "Light.ambient", "sig": "Light.ambient(color)", "tip": "Multiply the whole scene by a tint — the night/cave modulate.", "kind": "namespace-method", "page": "light-ambient.html", "section": "Light"}, "light-point": {"name": "Light.point", "sig": "Light.point(x, y, radius, color, energy)", "tip": "Add a radial glow that falls off with distance.", "kind": "namespace-method", "page": "light-point.html", "section": "Light"}, "light-occlude": {"name": "Light.occlude", "sig": "Light.occlude(x, y, width, height)", "tip": "Register a rectangle that blocks light — a hard shadow caster.", "kind": "namespace-method", "page": "light-occlude.html", "section": "Light"}, "light-clear_occluders": {"name": "Light.clear_occluders", "sig": "Light.clear_occluders()", "tip": "Forget every occluder — call once per frame before re-registering.", "kind": "namespace-method", "page": "light-clear_occluders.html", "section": "Light"}, "light-spot": {"name": "Light.spot", "sig": "Light.spot(x, y, radius, color, energy, direction, spread)", "tip": "A cone / flashlight light aimed at a direction with a half-angle spread.", "kind": "namespace-method", "page": "light-spot.html", "section": "Light"}, "light-falloff": {"name": "Light.falloff", "sig": "Light.falloff(exponent)", "tip": "Set the brightness-ramp exponent for later lights (1 linear, 2 quadratic…).", "kind": "namespace-method", "page": "light-falloff.html", "section": "Light"}, "light-soft": {"name": "Light.soft", "sig": "Light.soft(radius)", "tip": "Soft shadows — an occluder edge fades through a penumbra of this radius.", "kind": "namespace-method", "page": "light-soft.html", "section": "Light"}, "light-gel": {"name": "Light.gel", "sig": "Light.gel(color)", "tip": "A colour cookie — later lights gel from their centre colour to this rim colour.", "kind": "namespace-method", "page": "light-gel.html", "section": "Light"}, "light-clear_gel": {"name": "Light.clear_gel", "sig": "Light.clear_gel()", "tip": "Clear the gel — later lights are a flat single colour again.", "kind": "namespace-method", "page": "light-clear_gel.html", "section": "Light"}, "light-normal": {"name": "Light.normal", "sig": "Light.normal(x, y, width, height, nx, ny)", "tip": "Stamp a surface normal over a rectangle so lights shade it by facing (N·L).", "kind": "namespace-method", "page": "light-normal.html", "section": "Light"}, "light-clear_normals": {"name": "Light.clear_normals", "sig": "Light.clear_normals()", "tip": "Forget every stamped normal — call once per frame before re-stamping.", "kind": "namespace-method", "page": "light-clear_normals.html", "section": "Light"}, "light-height": {"name": "Light.height", "sig": "Light.height(height)", "tip": "Set the virtual height of lights above the surface, for normal-map shading.", "kind": "namespace-method", "page": "light-height.html", "section": "Light"}, "light-time_of_day": {"name": "Light.time_of_day", "sig": "Light.time_of_day(t)", "tip": "Set the ambient tint from a 0..1 time-of-day — a day/night cycle in one value.", "kind": "namespace-method", "page": "light-time_of_day.html", "section": "Light"}, "sprite-sheet": {"name": "Sprite.sheet", "sig": "Sprite.sheet(path, cellw, cellh) -> int", "tip": "Load a spritesheet and remember its cell grid; returns a sheet handle.", "kind": "namespace-method", "page": "sprite-sheet.html", "section": "Sprite"}, "sprite-cell": {"name": "Sprite.cell", "sig": "Sprite.cell(sheet, col, row) -> int", "tip": "One cell of a sheet, by grid coords; returns a sprite id.", "kind": "namespace-method", "page": "sprite-cell.html", "section": "Sprite"}, "sprite-cell_span": {"name": "Sprite.cell_span", "sig": "Sprite.cell_span(sheet, col, row, cols, rows) -> int", "tip": "A sprite spanning cols x rows cells (tall/wide art).", "kind": "namespace-method", "page": "sprite-cell_span.html", "section": "Sprite"}, "sprite-define": {"name": "Sprite.define", "sig": "Sprite.define(name, sheet, col, row) -> int", "tip": "Name a cell for later lookup; returns its sprite id.", "kind": "namespace-method", "page": "sprite-define.html", "section": "Sprite"}, "sprite-named": {"name": "Sprite.named", "sig": "Sprite.named(name) -> int", "tip": "Look up a named sprite's id, or -1.", "kind": "namespace-method", "page": "sprite-named.html", "section": "Sprite"}, "sprite-draw": {"name": "Sprite.draw", "sig": "Sprite.draw(id, x, y)", "tip": "Blit an atlas sprite at (x, y) through the camera/zoom/clip.", "kind": "namespace-method", "page": "sprite-draw.html", "section": "Sprite"}, "sprite-draw_scaled": {"name": "Sprite.draw_scaled", "sig": "Sprite.draw_scaled(id, x, y, scale)", "tip": "Blit an atlas sprite scaled by an integer factor.", "kind": "namespace-method", "page": "sprite-draw_scaled.html", "section": "Sprite"}, "sprite-width": {"name": "Sprite.width", "sig": "Sprite.width(id) -> int", "tip": "The atlas sprite's width in pixels.", "kind": "namespace-method", "page": "sprite-width.html", "section": "Sprite"}, "sprite-height": {"name": "Sprite.height", "sig": "Sprite.height(id) -> int", "tip": "The atlas sprite's height in pixels.", "kind": "namespace-method", "page": "sprite-height.html", "section": "Sprite"}, "sprite-strip": {"name": "Sprite.strip", "sig": "Sprite.strip(sheet, col, row, count, rows) -> int", "tip": "A run of animation frames as consecutive sprite ids.", "kind": "namespace-method", "page": "sprite-strip.html", "section": "Sprite"}, "sprite-draw_meter": {"name": "Sprite.draw_meter", "sig": "Sprite.draw_meter(x:, y:, value:, max:, per_icon:, spacing:, full:, half:, empty:)", "tip": "A value as a row of full / half / empty icons.", "kind": "namespace-method", "page": "sprite-draw_meter.html", "section": "Sprite"}, "assets-image": {"name": "Assets.image", "sig": "Assets.image(path) -> int", "tip": "Load a whole image file as one sprite; returns its id.", "kind": "namespace-method", "page": "assets-image.html", "section": "Assets"}, "assets-load": {"name": "Assets.load", "sig": "Assets.load(path) -> int", "tip": "Alias of Assets.image.", "kind": "namespace-method", "page": "assets-load.html", "section": "Assets"}, "assets-get": {"name": "Assets.get", "sig": "Assets.get(name) -> int", "tip": "Look up a named sprite's id (alias of Sprite.named).", "kind": "namespace-method", "page": "assets-get.html", "section": "Assets"}, "assets-enqueue": {"name": "Assets.enqueue", "sig": "Assets.enqueue(name, path)", "tip": "Queue a named image file to preload later.", "kind": "namespace-method", "page": "assets-enqueue.html", "section": "Assets"}, "assets-pump": {"name": "Assets.pump", "sig": "Assets.pump(max) -> int", "tip": "Load up to max queued assets this frame; returns how many it loaded.", "kind": "namespace-method", "page": "assets-pump.html", "section": "Assets"}, "assets-total": {"name": "Assets.total", "sig": "Assets.total() -> int", "tip": "How many assets are enqueued.", "kind": "namespace-method", "page": "assets-total.html", "section": "Assets"}, "assets-loaded": {"name": "Assets.loaded", "sig": "Assets.loaded() -> int", "tip": "How many enqueued assets have loaded so far.", "kind": "namespace-method", "page": "assets-loaded.html", "section": "Assets"}, "assets-ready": {"name": "Assets.ready", "sig": "Assets.ready() -> int", "tip": "1 once every enqueued asset has loaded.", "kind": "namespace-method", "page": "assets-ready.html", "section": "Assets"}, "assets-font": {"name": "Assets.font", "sig": "Assets.font(name: s) -> int", "tip": "A font loaded through the preload queue, by name.", "kind": "namespace-method", "page": "assets-font.html", "section": "Assets"}, "assets-progress": {"name": "Assets.progress", "sig": "Assets.progress() -> int", "tip": "Loading progress as a 0..100 percent.", "kind": "namespace-method", "page": "assets-progress.html", "section": "Assets"}, "assets-enqueue_dir": {"name": "Assets.enqueue_dir", "sig": "Assets.enqueue_dir(path: dir)", "tip": "Enqueue every file of a directory, named by its file name.", "kind": "namespace-method", "page": "assets-enqueue_dir.html", "section": "Assets"}, "kw-test": {"name": "test", "sig": "test \"name\" { … }", "tip": "A named test block, run automatically with pass/fail reporting.", "kind": "keyword", "page": "kw-test.html", "section": "Testing"}, "pool-live": {"name": "Pool.live", "sig": "Pool.live() -> int", "tip": "How many entities are currently alive.", "kind": "namespace-method", "page": "pool-live.html", "section": "Pool"}, "pool-free": {"name": "Pool.free", "sig": "Pool.free() -> int", "tip": "How many freed slots are waiting to be reused.", "kind": "namespace-method", "page": "pool-free.html", "section": "Pool"}, "pool-reserved": {"name": "Pool.reserved", "sig": "Pool.reserved() -> int", "tip": "High-water: how many slots have ever been allocated.", "kind": "namespace-method", "page": "pool-reserved.html", "section": "Pool"}, "pool-capacity": {"name": "Pool.capacity", "sig": "Pool.capacity() -> int", "tip": "The maximum number of entities.", "kind": "namespace-method", "page": "pool-capacity.html", "section": "Pool"}, "value-null": {"name": "Value.null", "sig": "Value.null() -> value", "tip": "An empty null node.", "kind": "namespace-method", "page": "value-null.html", "section": "Value"}, "value-int": {"name": "Value.int", "sig": "Value.int(n: int) -> value", "tip": "Wrap an int in a value node.", "kind": "namespace-method", "page": "value-int.html", "section": "Value"}, "value-fixed": {"name": "Value.fixed", "sig": "Value.fixed(f: fixed) -> value", "tip": "Wrap a fixed in a value node.", "kind": "namespace-method", "page": "value-fixed.html", "section": "Value"}, "value-bool": {"name": "Value.bool", "sig": "Value.bool(b: bool) -> value", "tip": "Wrap a bool in a value node.", "kind": "namespace-method", "page": "value-bool.html", "section": "Value"}, "value-str": {"name": "Value.str", "sig": "Value.str(s: string) -> value", "tip": "Wrap a string in a value node.", "kind": "namespace-method", "page": "value-str.html", "section": "Value"}, "value-list": {"name": "Value.list", "sig": "Value.list() -> value", "tip": "An empty list node.", "kind": "namespace-method", "page": "value-list.html", "section": "Value"}, "value-object": {"name": "Value.object", "sig": "Value.object() -> value", "tip": "An empty object node.", "kind": "namespace-method", "page": "value-object.html", "section": "Value"}, "value-add": {"name": "Value.add", "sig": "Value.add(list, item) -> value", "tip": "Append an item to a list; returns the list.", "kind": "namespace-method", "page": "value-add.html", "section": "Value"}, "value-put": {"name": "Value.put", "sig": "Value.put(obj, key: string, item) -> value", "tip": "Set a key on an object; returns the object.", "kind": "namespace-method", "page": "value-put.html", "section": "Value"}, "value-get": {"name": "Value.get", "sig": "Value.get(obj, key: string) -> value", "tip": "Read a member of an object by key.", "kind": "namespace-method", "page": "value-get.html", "section": "Value"}, "value-has": {"name": "Value.has", "sig": "Value.has(obj, key: string) -> bool", "tip": "Whether an object has a member.", "kind": "namespace-method", "page": "value-has.html", "section": "Value"}, "value-at": {"name": "Value.at", "sig": "Value.at(list, index: int) -> value", "tip": "Read a list item by index.", "kind": "namespace-method", "page": "value-at.html", "section": "Value"}, "value-key_at": {"name": "Value.key_at", "sig": "Value.key_at(obj, index: int) -> string", "tip": "The key of an object member by position.", "kind": "namespace-method", "page": "value-key_at.html", "section": "Value"}, "value-count": {"name": "Value.count", "sig": "Value.count(value) -> int", "tip": "Number of items/members in a list or object.", "kind": "namespace-method", "page": "value-count.html", "section": "Value"}, "value-kind": {"name": "Value.kind", "sig": "Value.kind(value) -> int", "tip": "The node's kind tag.", "kind": "namespace-method", "page": "value-kind.html", "section": "Value"}, "value-as_int": {"name": "Value.as_int", "sig": "Value.as_int(value) -> int", "tip": "Read a scalar node as an int.", "kind": "namespace-method", "page": "value-as_int.html", "section": "Value"}, "value-as_str": {"name": "Value.as_str", "sig": "Value.as_str(value) -> string", "tip": "Read a str node's text.", "kind": "namespace-method", "page": "value-as_str.html", "section": "Value"}, "json-encode": {"name": "Json.encode", "sig": "Json.encode(value) -> string", "tip": "Serialize a value tree to compact JSON text.", "kind": "namespace-method", "page": "json-encode.html", "section": "Json"}, "json-parse": {"name": "Json.parse", "sig": "Json.parse(text: string) -> value", "tip": "Parse JSON text into a value tree.", "kind": "namespace-method", "page": "json-parse.html", "section": "Json"}, "job-defer": {"name": "Job.defer", "sig": "Job.defer() -> Job", "tip": "A future you resolve yourself later.", "kind": "namespace-method", "page": "job-defer.html", "section": "Job"}, "job-run": {"name": "Job.run", "sig": "Job.run(kind, arg) -> Job", "tip": "Start a background compute job.", "kind": "namespace-method", "page": "job-run.html", "section": "Job"}, "job-fulfill": {"name": "Job.fulfill", "sig": "Job.fulfill(handle, value) -> void", "tip": "Resolve a pending job with a value.", "kind": "namespace-method", "page": "job-fulfill.html", "section": "Job"}, "job-fail": {"name": "Job.fail", "sig": "Job.fail(handle, error) -> void", "tip": "Resolve a pending job as failed.", "kind": "namespace-method", "page": "job-fail.html", "section": "Job"}, "job-cancel": {"name": "Job.cancel", "sig": "Job.cancel(handle) -> void", "tip": "Cancel a job before it finishes.", "kind": "namespace-method", "page": "job-cancel.html", "section": "Job"}, "job-pump": {"name": "Job.pump", "sig": "Job.pump(budget) -> int", "tip": "Advance background jobs; collect results.", "kind": "namespace-method", "page": "job-pump.html", "section": "Job"}, "job-done": {"name": "Job.done", "sig": "Job.done(handle) -> bool", "tip": "Has the job resolved (any outcome)?", "kind": "namespace-method", "page": "job-done.html", "section": "Job"}, "job-ok": {"name": "Job.ok", "sig": "Job.ok(handle) -> bool", "tip": "Did the job succeed?", "kind": "namespace-method", "page": "job-ok.html", "section": "Job"}, "job-failed": {"name": "Job.failed", "sig": "Job.failed(handle) -> bool", "tip": "Did the job fail?", "kind": "namespace-method", "page": "job-failed.html", "section": "Job"}, "job-cancelled": {"name": "Job.cancelled", "sig": "Job.cancelled(handle) -> bool", "tip": "Was the job cancelled?", "kind": "namespace-method", "page": "job-cancelled.html", "section": "Job"}, "job-result": {"name": "Job.result", "sig": "Job.result(handle) -> int", "tip": "The success value of a done job.", "kind": "namespace-method", "page": "job-result.html", "section": "Job"}, "job-error": {"name": "Job.error", "sig": "Job.error(handle) -> int", "tip": "The error code of a failed job.", "kind": "namespace-method", "page": "job-error.html", "section": "Job"}, "job-pending": {"name": "Job.pending", "sig": "Job.pending() -> int", "tip": "How many jobs are still unresolved.", "kind": "namespace-method", "page": "job-pending.html", "section": "Job"}, "job-free": {"name": "Job.free", "sig": "Job.free(handle) -> void", "tip": "Release a job slot back to the pool.", "kind": "namespace-method", "page": "job-free.html", "section": "Job"}, "job-parallel_for": {"name": "Job.parallel_for", "sig": "Job.parallel_for(count, work, ctx) -> void", "tip": "Run work(i, ctx) for every i in [0, count) across all cores; returns when every call is done.", "kind": "namespace-method", "page": "job-parallel_for.html", "section": "Job"}, "job-is_worker": {"name": "Job.is_worker", "sig": "Job.is_worker() -> bool", "tip": "True on a Job.parallel_for pool thread, false on the main thread.", "kind": "namespace-method", "page": "job-is_worker.html", "section": "Job"}, "promise-all": {"name": "Promise.all", "sig": "Promise.all(handles) -> Job", "tip": "Succeeds when every member succeeds.", "kind": "namespace-method", "page": "promise-all.html", "section": "Promise"}, "promise-race": {"name": "Promise.race", "sig": "Promise.race(handles) -> Job", "tip": "Succeeds when the first member does.", "kind": "namespace-method", "page": "promise-race.html", "section": "Promise"}, "promise-count_done": {"name": "Promise.count_done", "sig": "Promise.count_done(handles) -> int", "tip": "How many members have resolved.", "kind": "namespace-method", "page": "promise-count_done.html", "section": "Promise"}, "promise-all_done": {"name": "Promise.all_done", "sig": "Promise.all_done(handles) -> bool", "tip": "Have all members resolved?", "kind": "namespace-method", "page": "promise-all_done.html", "section": "Promise"}, "sync-mutex": {"name": "Sync.mutex", "sig": "Sync.mutex() -> int", "tip": "Create a cooperative lock.", "kind": "namespace-method", "page": "sync-mutex.html", "section": "Sync"}, "sync-lock": {"name": "Sync.lock", "sig": "Sync.lock(mutex) -> void", "tip": "Take the lock.", "kind": "namespace-method", "page": "sync-lock.html", "section": "Sync"}, "sync-unlock": {"name": "Sync.unlock", "sig": "Sync.unlock(mutex) -> void", "tip": "Release the lock.", "kind": "namespace-method", "page": "sync-unlock.html", "section": "Sync"}, "sync-try_lock": {"name": "Sync.try_lock", "sig": "Sync.try_lock(mutex) -> bool", "tip": "Take the lock only if it is free.", "kind": "namespace-method", "page": "sync-try_lock.html", "section": "Sync"}, "sync-atomic": {"name": "Sync.atomic", "sig": "Sync.atomic() -> int", "tip": "Create an atomic counter (starts at 0).", "kind": "namespace-method", "page": "sync-atomic.html", "section": "Sync"}, "sync-get": {"name": "Sync.get", "sig": "Sync.get(atomic) -> int", "tip": "Read the counter.", "kind": "namespace-method", "page": "sync-get.html", "section": "Sync"}, "sync-set": {"name": "Sync.set", "sig": "Sync.set(atomic, value) -> void", "tip": "Store a value in the counter.", "kind": "namespace-method", "page": "sync-set.html", "section": "Sync"}, "sync-add": {"name": "Sync.add", "sig": "Sync.add(atomic, delta) -> int", "tip": "Add to the counter; return the new value.", "kind": "namespace-method", "page": "sync-add.html", "section": "Sync"}, "sync-cas": {"name": "Sync.cas", "sig": "Sync.cas(atomic, expect, next) -> bool", "tip": "Compare-and-set the counter.", "kind": "namespace-method", "page": "sync-cas.html", "section": "Sync"}, "sync-channel": {"name": "Sync.channel", "sig": "Sync.channel() -> int", "tip": "Create a bounded int FIFO channel.", "kind": "namespace-method", "page": "sync-channel.html", "section": "Sync"}, "sync-send": {"name": "Sync.send", "sig": "Sync.send(channel, value) -> bool", "tip": "Enqueue a value (false if full).", "kind": "namespace-method", "page": "sync-send.html", "section": "Sync"}, "sync-recv": {"name": "Sync.recv", "sig": "Sync.recv(channel) -> int", "tip": "Dequeue the oldest value.", "kind": "namespace-method", "page": "sync-recv.html", "section": "Sync"}, "sync-can_recv": {"name": "Sync.can_recv", "sig": "Sync.can_recv(channel) -> bool", "tip": "Is there a value waiting?", "kind": "namespace-method", "page": "sync-can_recv.html", "section": "Sync"}, "sync-len": {"name": "Sync.len", "sig": "Sync.len(channel) -> int", "tip": "How many values are queued.", "kind": "namespace-method", "page": "sync-len.html", "section": "Sync"}, "sync-cpu_count": {"name": "Sync.cpu_count", "sig": "Sync.cpu_count() -> int", "tip": "The machine's logical cores (1 to 64); Job.parallel_for uses one thread per core.", "kind": "namespace-method", "page": "sync-cpu_count.html", "section": "Sync"}, "xml-parse": {"name": "Xml.parse", "sig": "Xml.parse(text: string) -> xml", "tip": "Parse XML text into an element tree.", "kind": "namespace-method", "page": "xml-parse.html", "section": "Xml"}, "xml-tag": {"name": "Xml.tag", "sig": "Xml.tag(node) -> string", "tip": "The element's tag name.", "kind": "namespace-method", "page": "xml-tag.html", "section": "Xml"}, "xml-text": {"name": "Xml.text", "sig": "Xml.text(node) -> string", "tip": "The element's character data.", "kind": "namespace-method", "page": "xml-text.html", "section": "Xml"}, "xml-attr": {"name": "Xml.attr", "sig": "Xml.attr(node, key: string) -> string", "tip": "An attribute's value by name.", "kind": "namespace-method", "page": "xml-attr.html", "section": "Xml"}, "xml-attr_int": {"name": "Xml.attr_int", "sig": "Xml.attr_int(node, key: string, dflt: int) -> int", "tip": "An attribute parsed as an integer.", "kind": "namespace-method", "page": "xml-attr_int.html", "section": "Xml"}, "xml-has": {"name": "Xml.has", "sig": "Xml.has(node, key: string) -> int", "tip": "Whether an attribute is present.", "kind": "namespace-method", "page": "xml-has.html", "section": "Xml"}, "xml-attr_count": {"name": "Xml.attr_count", "sig": "Xml.attr_count(node) -> int", "tip": "How many attributes the element has.", "kind": "namespace-method", "page": "xml-attr_count.html", "section": "Xml"}, "xml-child_count": {"name": "Xml.child_count", "sig": "Xml.child_count(node) -> int", "tip": "How many child elements.", "kind": "namespace-method", "page": "xml-child_count.html", "section": "Xml"}, "xml-child": {"name": "Xml.child", "sig": "Xml.child(node, index: int) -> xml", "tip": "A child element by index.", "kind": "namespace-method", "page": "xml-child.html", "section": "Xml"}, "xml-find": {"name": "Xml.find", "sig": "Xml.find(node, tag: string) -> xml", "tip": "The first child with a given tag.", "kind": "namespace-method", "page": "xml-find.html", "section": "Xml"}, "xml-count": {"name": "Xml.count", "sig": "Xml.count(node, tag: string) -> int", "tip": "How many children have a given tag.", "kind": "namespace-method", "page": "xml-count.html", "section": "Xml"}, "base64-decode": {"name": "Base64.decode", "sig": "Base64.decode(src: string) -> string", "tip": "Decode standard base64 text to bytes.", "kind": "namespace-method", "page": "base64-decode.html", "section": "Base64"}, "base64-encode": {"name": "Base64.encode", "sig": "Base64.encode(src: string) -> string", "tip": "Encode bytes as standard base64 text.", "kind": "namespace-method", "page": "base64-encode.html", "section": "Base64"}, "tiled-read": {"name": "Tiled.read", "sig": "Tiled.read(path: string) -> value", "tip": "Read a map file into the intermediate value tree.", "kind": "namespace-method", "page": "tiled-read.html", "section": "Tiled"}, "tiled-read_tsx": {"name": "Tiled.read_tsx", "sig": "Tiled.read_tsx(path: string) -> value", "tip": "Read a tileset file into a value object.", "kind": "namespace-method", "page": "tiled-read_tsx.html", "section": "Tiled"}, "tiled-load": {"name": "Tiled.load", "sig": "Tiled.load(path: string) -> map", "tip": "Load a map file into the runtime map model.", "kind": "namespace-method", "page": "tiled-load.html", "section": "Tiled"}, "tiled-gid": {"name": "Tiled.gid", "sig": "Tiled.gid(map, layer: int, x: int, y: int) -> int", "tip": "The raw GID at a cell in a tile layer.", "kind": "namespace-method", "page": "tiled-gid.html", "section": "Tiled"}, "tiled-resolve": {"name": "Tiled.resolve", "sig": "Tiled.resolve(map, gid: int) -> gidinfo", "tip": "Decode a GID into tileset, local id and flip flags.", "kind": "namespace-method", "page": "tiled-resolve.html", "section": "Tiled"}, "tiled-width": {"name": "Tiled.width", "sig": "Tiled.width(map) -> int", "tip": "The map width in tiles.", "kind": "namespace-method", "page": "tiled-width.html", "section": "Tiled"}, "tiled-height": {"name": "Tiled.height", "sig": "Tiled.height(map) -> int", "tip": "The map height in tiles.", "kind": "namespace-method", "page": "tiled-height.html", "section": "Tiled"}, "tiled-layer_count": {"name": "Tiled.layer_count", "sig": "Tiled.layer_count(map) -> int", "tip": "How many layers the map has.", "kind": "namespace-method", "page": "tiled-layer_count.html", "section": "Tiled"}, "tiled-layer_name": {"name": "Tiled.layer_name", "sig": "Tiled.layer_name(map, index: int) -> string", "tip": "A layer's name by index.", "kind": "namespace-method", "page": "tiled-layer_name.html", "section": "Tiled"}, "tiled-draw": {"name": "Tiled.draw", "sig": "Tiled.draw(map, camx: int, camy: int) -> void", "tip": "Draw every visible tile layer.", "kind": "namespace-method", "page": "tiled-draw.html", "section": "Tiled"}, "tiled-project": {"name": "Tiled.project", "sig": "Tiled.project(map, layer: int) -> void", "tip": "Project a collision layer to the byte tilemap.", "kind": "namespace-method", "page": "tiled-project.html", "section": "Tiled"}, "tiled-tree": {"name": "Tiled.tree", "sig": "Tiled.tree(map) -> value", "tip": "The underlying intermediate value tree.", "kind": "namespace-method", "page": "tiled-tree.html", "section": "Tiled"}, "tiled-tile_prop": {"name": "Tiled.tile_prop", "sig": "Tiled.tile_prop(map, gid: int, name: string) -> int", "tip": "Whether a GID's tile carries a bool property.", "kind": "namespace-method", "page": "tiled-tile_prop.html", "section": "Tiled"}, "tiled-collide": {"name": "Tiled.collide", "sig": "Tiled.collide(map, layer: int) -> void", "tip": "Drive collision from per-tile metadata.", "kind": "namespace-method", "page": "tiled-collide.html", "section": "Tiled"}, "tiled-collision_kind": {"name": "Tiled.collision_kind", "sig": "Tiled.collision_kind(map, gid: int) -> int", "tip": "Classify a GID's collision from its tile metadata.", "kind": "namespace-method", "page": "tiled-collision_kind.html", "section": "Tiled"}, "tiled-tile_shapes": {"name": "Tiled.tile_shapes", "sig": "Tiled.tile_shapes(map, gid: int) -> int", "tip": "Whether a GID's tile has a collision shape.", "kind": "namespace-method", "page": "tiled-tile_shapes.html", "section": "Tiled"}, "tiled-draw_anim": {"name": "Tiled.draw_anim", "sig": "Tiled.draw_anim(map, camx: int, camy: int, frame: int) -> void", "tip": "Draw with animated tiles advanced to a frame.", "kind": "namespace-method", "page": "tiled-draw_anim.html", "section": "Tiled"}, "tiled-frame_gid": {"name": "Tiled.frame_gid", "sig": "Tiled.frame_gid(map, gid: int, frame: int) -> int", "tip": "The current GID of an animated tile at a frame.", "kind": "namespace-method", "page": "tiled-frame_gid.html", "section": "Tiled"}, "tiled-animated": {"name": "Tiled.animated", "sig": "Tiled.animated(map, gid: int) -> int", "tip": "Whether a GID's tile is animated.", "kind": "namespace-method", "page": "tiled-animated.html", "section": "Tiled"}, "tiled-object_count": {"name": "Tiled.object_count", "sig": "Tiled.object_count(map, layer: int) -> int", "tip": "How many objects an object layer holds.", "kind": "namespace-method", "page": "tiled-object_count.html", "section": "Tiled"}, "tiled-object": {"name": "Tiled.object", "sig": "Tiled.object(map, layer: int, index: int) -> value", "tip": "An object on an object layer by index.", "kind": "namespace-method", "page": "tiled-object.html", "section": "Tiled"}, "tiled-object_shape": {"name": "Tiled.object_shape", "sig": "Tiled.object_shape(object) -> string", "tip": "Classify an object's shape.", "kind": "namespace-method", "page": "tiled-object_shape.html", "section": "Tiled"}, "tiled-prop": {"name": "Tiled.prop", "sig": "Tiled.prop(container, name: string) -> string", "tip": "A custom property's value, with class-default fallback.", "kind": "namespace-method", "page": "tiled-prop.html", "section": "Tiled"}, "tiled-prop_int": {"name": "Tiled.prop_int", "sig": "Tiled.prop_int(container, name: string) -> int", "tip": "A custom property parsed as an integer.", "kind": "namespace-method", "page": "tiled-prop_int.html", "section": "Tiled"}, "tiled-prop_type": {"name": "Tiled.prop_type", "sig": "Tiled.prop_type(container, name: string) -> string", "tip": "A custom property's declared type.", "kind": "namespace-method", "page": "tiled-prop_type.html", "section": "Tiled"}, "tiled-load_types": {"name": "Tiled.load_types", "sig": "Tiled.load_types(path: string) -> int", "tip": "Load a project custom-type table.", "kind": "namespace-method", "page": "tiled-load_types.html", "section": "Tiled"}, "tiled-template": {"name": "Tiled.template", "sig": "Tiled.template(path: string) -> value", "tip": "Read a template file into an object value.", "kind": "namespace-method", "page": "tiled-template.html", "section": "Tiled"}, "tiled-spawn": {"name": "Tiled.spawn", "sig": "Tiled.spawn(map, object, model: string) -> int", "tip": "Spawn a Ludic entity from an object.", "kind": "namespace-method", "page": "tiled-spawn.html", "section": "Tiled"}, "tiled-spawn_layer": {"name": "Tiled.spawn_layer", "sig": "Tiled.spawn_layer(map, layer: int, model: string) -> int", "tip": "Spawn every object on a layer.", "kind": "namespace-method", "page": "tiled-spawn_layer.html", "section": "Tiled"}, "tiled-cell_x": {"name": "Tiled.cell_x", "sig": "Tiled.cell_x(map, x: int, y: int) -> int", "tip": "The screen x of a tile cell for the map orientation.", "kind": "namespace-method", "page": "tiled-cell_x.html", "section": "Tiled"}, "tiled-cell_y": {"name": "Tiled.cell_y", "sig": "Tiled.cell_y(map, x: int, y: int) -> int", "tip": "The screen y of a tile cell for the map orientation.", "kind": "namespace-method", "page": "tiled-cell_y.html", "section": "Tiled"}, "tiled-layer_kind": {"name": "Tiled.layer_kind", "sig": "Tiled.layer_kind(map, layer: int) -> int", "tip": "A layer's kind.", "kind": "namespace-method", "page": "tiled-layer_kind.html", "section": "Tiled"}, "tiled-layer_opacity": {"name": "Tiled.layer_opacity", "sig": "Tiled.layer_opacity(map, layer: int) -> string", "tip": "A layer's opacity.", "kind": "namespace-method", "page": "tiled-layer_opacity.html", "section": "Tiled"}, "tiled-layer_tint": {"name": "Tiled.layer_tint", "sig": "Tiled.layer_tint(map, layer: int) -> string", "tip": "A layer's tint colour.", "kind": "namespace-method", "page": "tiled-layer_tint.html", "section": "Tiled"}, "tiled-layer_offsetx": {"name": "Tiled.layer_offsetx", "sig": "Tiled.layer_offsetx(map, layer: int) -> int", "tip": "A layer's horizontal offset.", "kind": "namespace-method", "page": "tiled-layer_offsetx.html", "section": "Tiled"}, "tiled-layer_offsety": {"name": "Tiled.layer_offsety", "sig": "Tiled.layer_offsety(map, layer: int) -> int", "tip": "A layer's vertical offset.", "kind": "namespace-method", "page": "tiled-layer_offsety.html", "section": "Tiled"}, "tiled-world": {"name": "Tiled.world", "sig": "Tiled.world(path: string) -> value", "tip": "Read a .world file.", "kind": "namespace-method", "page": "tiled-world.html", "section": "Tiled"}, "tiled-world_count": {"name": "Tiled.world_count", "sig": "Tiled.world_count(world) -> int", "tip": "How many maps a world stitches.", "kind": "namespace-method", "page": "tiled-world_count.html", "section": "Tiled"}, "tiled-world_map": {"name": "Tiled.world_map", "sig": "Tiled.world_map(world, index: int) -> value", "tip": "A world member map by index.", "kind": "namespace-method", "page": "tiled-world_map.html", "section": "Tiled"}, "ui-build": {"name": "Ui.build", "sig": "Ui.build()", "tip": "Construct every declared ui block (loads skins, measures fonts).", "kind": "namespace-method", "page": "ui-build.html", "section": "Ui"}, "ui-open": {"name": "Ui.open", "sig": "Ui.open(id: UI_Name)", "tip": "Make one menu active and focus its first button.", "kind": "namespace-method", "page": "ui-open.html", "section": "Ui"}, "ui-close": {"name": "Ui.close", "sig": "Ui.close()", "tip": "Deactivate the menu: no menu is open.", "kind": "namespace-method", "page": "ui-close.html", "section": "Ui"}, "ui-tick": {"name": "Ui.tick", "sig": "Ui.tick(key: k)", "tip": "Advance navigation by one key (the frame loop does this for you).", "kind": "namespace-method", "page": "ui-tick.html", "section": "Ui"}, "ui-clicked": {"name": "Ui.clicked", "sig": "Ui.clicked(id: UI_Name) -> bool", "tip": "Was this control activated this frame? (polled form of UiClicked)", "kind": "namespace-method", "page": "ui-clicked.html", "section": "Ui"}, "ui-set_text": {"name": "Ui.set_text", "sig": "Ui.set_text(id: UI_Name, text: s)", "tip": "Replace a label's or button's text.", "kind": "namespace-method", "page": "ui-set_text.html", "section": "Ui"}, "ui-render": {"name": "Ui.render", "sig": "Ui.render()", "tip": "Draw the active menu.", "kind": "namespace-method", "page": "ui-render.html", "section": "Ui"}, "file-open": {"name": "File.open", "sig": "File.open(path: p, mode: m) -> pointer", "tip": "Open a file (fopen); null when it cannot be opened.", "kind": "namespace-method", "page": "file-open.html", "section": "File"}, "file-read": {"name": "File.read", "sig": "File.read(file: f, buffer: b, count: n) -> int", "tip": "Read up to n bytes into a buffer; returns the bytes read.", "kind": "namespace-method", "page": "file-read.html", "section": "File"}, "file-write": {"name": "File.write", "sig": "File.write(file: f, buffer: b, count: n) -> int", "tip": "Write n bytes from a buffer; returns the bytes written.", "kind": "namespace-method", "page": "file-write.html", "section": "File"}, "file-seek": {"name": "File.seek", "sig": "File.seek(file: f, offset: o, whence: w)", "tip": "Move the file cursor (0 start, 1 current, 2 end).", "kind": "namespace-method", "page": "file-seek.html", "section": "File"}, "file-tell": {"name": "File.tell", "sig": "File.tell(file: f) -> int", "tip": "The cursor position in bytes.", "kind": "namespace-method", "page": "file-tell.html", "section": "File"}, "file-close": {"name": "File.close", "sig": "File.close(file: f)", "tip": "Close a handle from File.open.", "kind": "namespace-method", "page": "file-close.html", "section": "File"}, "font-load": {"name": "Font.load", "sig": "Font.load(path: p) -> int", "tip": "Load a TrueType font; returns a font handle.", "kind": "namespace-method", "page": "font-load.html", "section": "Font"}, "fx-sparks": {"name": "Fx.sparks", "sig": "Fx.sparks(x: px, y: px, color: c, count: n)", "tip": "A burst of sparks flying out of a point.", "kind": "namespace-method", "page": "fx-sparks.html", "section": "Fx"}, "fx-number": {"name": "Fx.number", "sig": "Fx.number(x: px, y: px, value: n, color: c)", "tip": "A number that floats up from a point and fades.", "kind": "namespace-method", "page": "fx-number.html", "section": "Fx"}, "fx-clear": {"name": "Fx.clear", "sig": "Fx.clear()", "tip": "Drop every spark and number at once.", "kind": "namespace-method", "page": "fx-clear.html", "section": "Fx"}, "prefab-spawn": {"name": "Prefab.spawn", "sig": "Prefab.spawn(name: s) -> entity", "tip": "Spawn a prefab chosen by name at runtime; -1 if none has that name.", "kind": "namespace-method", "page": "prefab-spawn.html", "section": "Prefab"}, "prefab-spawn_at": {"name": "Prefab.spawn_at", "sig": "Prefab.spawn_at(name: s, at: IVec2) -> entity", "tip": "Spawn a prefab by name and place it.", "kind": "namespace-method", "page": "prefab-spawn_at.html", "section": "Prefab"}, "app-splash_hide": {"name": "App.splash_hide", "sig": "App.splash_hide() -> void", "tip": "Dismiss the boot splash.", "kind": "namespace-method", "page": "app-splash_hide.html", "section": "App"}, "app-set_icon": {"name": "App.set_icon", "sig": "App.set_icon(path) -> void", "tip": "Set the Dock icon from an image the game ships.", "kind": "namespace-method", "page": "app-set_icon.html", "section": "App"}, "app-window_hide": {"name": "App.window_hide", "sig": "App.window_hide() -> void", "tip": "Take the game's window off the screen.", "kind": "namespace-method", "page": "app-window_hide.html", "section": "App"}, "app-window_show": {"name": "App.window_show", "sig": "App.window_show() -> void", "tip": "Bring the game's window back.", "kind": "namespace-method", "page": "app-window_show.html", "section": "App"}, "phase-start": {"name": "Start", "sig": "phase Start", "tip": "Runs once at boot, before the game loop — the place to set up initial state.", "kind": "phase", "page": "phase-start.html", "section": "Phases"}, "phase-input": {"name": "Input", "sig": "phase Input", "tip": "The first per-frame phase — read the keyboard and record the player's intent.", "kind": "phase", "page": "phase-input.html", "section": "Phases"}, "phase-fixedupdate": {"name": "FixedUpdate", "sig": "phase FixedUpdate", "tip": "The deterministic simulation step — physics and gameplay meant to be reproducible.", "kind": "phase", "page": "phase-fixedupdate.html", "section": "Phases"}, "phase-update": {"name": "Update", "sig": "phase Update", "tip": "The ordinary per-frame game-logic step, run after Input and FixedUpdate.", "kind": "phase", "page": "phase-update.html", "section": "Phases"}, "phase-lateupdate": {"name": "LateUpdate", "sig": "phase LateUpdate", "tip": "Runs each frame after Update and before Render.", "kind": "phase", "page": "phase-lateupdate.html", "section": "Phases"}, "phase-render": {"name": "Render", "sig": "phase Render", "tip": "The last per-frame phase — draw the world, then call Screen.show() once.", "kind": "phase", "page": "phase-render.html", "section": "Phases"}, "phase-overlay": {"name": "Overlay", "sig": "phase Overlay", "tip": "The HUD pass — runs after Render and after every engine-owned drawing system.", "kind": "phase", "page": "phase-overlay.html", "section": "Phases"}, "ns-angle": {"name": "Angle", "sig": "Angle.*", "kind": "namespace", "tip": "An auto-wrapping angle in radians, so you never juggle % TAU by hand.", "page": "ns-angle.html", "section": "Namespaces"}, "ns-anim": {"name": "Anim", "sig": "Anim.*", "kind": "namespace", "tip": "Spritesheet frame animation off the fixed frame clock.", "page": "ns-anim.html", "section": "Namespaces"}, "ns-app": {"name": "App", "sig": "App.*", "kind": "namespace", "tip": "The running application, as distinct from its window.", "page": "ns-app.html", "section": "Namespaces"}, "ns-assets": {"name": "Assets", "sig": "Assets.*", "kind": "namespace", "tip": "Loading and lookup for whole-file assets, paired with the Sprite.* atlas API.", "page": "ns-assets.html", "section": "Namespaces"}, "ns-audio": {"name": "Audio", "sig": "Audio.*", "kind": "namespace", "tip": "Sound effects and music.", "page": "ns-audio.html", "section": "Namespaces"}, "ns-base64": {"name": "Base64", "sig": "Base64.*", "kind": "namespace", "tip": "Standard base64 (RFC 4648) — Base64.decode reads base64 text into the bytes it stands for, and Base64.encode is the inverse.", "page": "ns-base64.html", "section": "Namespaces"}, "ns-bigint": {"name": "BigInt", "sig": "BigInt.*", "kind": "namespace", "tip": "Arbitrary-precision integers with no upper bound, for idle/incremental counters, exact huge currencies, and score arithmetic that a 32- or 64-bit int would…", "page": "ns-bigint.html", "section": "Namespaces"}, "ns-camera": {"name": "Camera", "sig": "Camera.*", "kind": "namespace", "tip": "A world-space camera — a draw offset threaded through the render path (the same offset Screen.camera sets).", "page": "ns-camera.html", "section": "Namespaces"}, "ns-clock": {"name": "Clock", "sig": "Clock.*", "kind": "namespace", "tip": "A game-controlled simulated clock: a single seconds counter the game owns.", "page": "ns-clock.html", "section": "Namespaces"}, "ns-collision": {"name": "Collision", "sig": "Collision.*", "kind": "namespace", "tip": "2D overlap tests on integer coordinates (pixels or tiles).", "page": "ns-collision.html", "section": "Namespaces"}, "ns-color": {"name": "Color", "sig": "Color.*", "kind": "namespace", "tip": "The named color palette.", "page": "ns-color.html", "section": "Namespaces"}, "ns-crypto": {"name": "Crypto", "sig": "Crypto.*", "kind": "namespace", "tip": "Secure, test-vector-backed hashing for the handful of security-sensitive things a game actually does: signing a save or leaderboard payload so casual tampering…", "page": "ns-crypto.html", "section": "Namespaces"}, "ns-date": {"name": "Date", "sig": "Date.*", "kind": "namespace", "tip": "Calendar days on the proleptic Gregorian calendar (UTC).", "page": "ns-date.html", "section": "Namespaces"}, "ns-datetime": {"name": "DateTime", "sig": "DateTime.*", "kind": "namespace", "tip": "Instants on the wall-clock timeline (UTC), stored as a plain int: the count of seconds since 1970-01-01, matching Time.now.", "page": "ns-datetime.html", "section": "Namespaces"}, "ns-decimal": {"name": "Decimal", "sig": "Decimal.*", "kind": "namespace", "tip": "Exact base-10 fixed-point numbers for game economies — prices, balances and taxes on values like 0.10 that binary floating point cannot represent, so they…", "page": "ns-decimal.html", "section": "Namespaces"}, "ns-dict": {"name": "Dict", "sig": "Dict.*", "kind": "namespace", "tip": "A hash map from string keys to int values — the everyday lookup a game needs, like resource counts or an id registry by name.", "page": "ns-dict.html", "section": "Namespaces"}, "ns-duration": {"name": "Duration", "sig": "Duration.*", "kind": "namespace", "tip": "Spans of real time, measured in whole seconds and carried in a plain int — so a duration adds, subtracts and compares with the ordinary operators…", "page": "ns-duration.html", "section": "Namespaces"}, "ns-ease": {"name": "Ease", "sig": "Ease.*", "kind": "namespace", "tip": "Tween curves — the \"juice\" layer.", "page": "ns-ease.html", "section": "Namespaces"}, "ns-file": {"name": "File", "sig": "File.*", "kind": "namespace", "tip": "Raw file access over the C stdio calls, for programs that read and write their own formats.", "page": "ns-file.html", "section": "Namespaces"}, "ns-font": {"name": "Font", "sig": "Font.*", "kind": "namespace", "tip": "TrueType fonts for the retained UI and for Screen.draw_text-style drawing.", "page": "ns-font.html", "section": "Namespaces"}, "ns-fs": {"name": "Fs", "sig": "Fs.*", "kind": "namespace", "tip": "The filesystem, wrapped into one safe, ergonomic API — no file descriptors, no byte buffers, no half-written files.", "page": "ns-fs.html", "section": "Namespaces"}, "ns-fx": {"name": "Fx", "sig": "Fx.*", "kind": "namespace", "tip": "Engine-owned transient effects.", "page": "ns-fx.html", "section": "Namespaces"}, "ns-grid": {"name": "Grid", "sig": "Grid.*", "kind": "namespace", "tip": "Tile geometry and pathfinding over the Map tilemap.", "page": "ns-grid.html", "section": "Namespaces"}, "ns-hash": {"name": "Hash", "sig": "Hash.*", "kind": "namespace", "tip": "Fast, non-cryptographic hashing for everyday game needs: turning string IDs into integer handles, mixing a few numbers into one deterministic seed, and…", "page": "ns-hash.html", "section": "Namespaces"}, "ns-http": {"name": "Http", "sig": "Http.*", "kind": "namespace", "tip": "A poll-based HTTP / HTTPS client for out-of-band data — leaderboards, cloud saves, remote config, telemetry, downloads.", "page": "ns-http.html", "section": "Namespaces"}, "ns-huge": {"name": "Huge", "sig": "Huge.*", "kind": "namespace", "tip": "Idle/incremental big numbers — magnitudes far past what a 32- or 64-bit integer can hold, for prestige currencies and exponential growth.", "page": "ns-huge.html", "section": "Namespaces"}, "ns-ivec2": {"name": "IVec2", "sig": "IVec2.*", "kind": "namespace", "tip": "Integer 2D vector math for tile and grid coordinates, cell offsets, and integer sizes.", "page": "ns-ivec2.html", "section": "Namespaces"}, "ns-input": {"name": "Input", "sig": "Input.*", "kind": "namespace", "tip": "Reading input.", "page": "ns-input.html", "section": "Namespaces"}, "ns-job": {"name": "Job", "sig": "Job.*", "kind": "namespace", "tip": "Background work that stays out of the frame.", "page": "ns-job.html", "section": "Namespaces"}, "ns-json": {"name": "Json", "sig": "Json.*", "kind": "namespace", "tip": "The text bridge over the Value tree: Json.encode turns a value tree into compact, stable JSON text and Json.parse reads it back.", "page": "ns-json.html", "section": "Namespaces"}, "ns-light": {"name": "Light", "sig": "Light.*", "kind": "namespace", "tip": "A software 2D light-accumulation pass over the framebuffer, run in a render phase after drawing the scene and before Screen.show.", "page": "ns-light.html", "section": "Namespaces"}, "ns-list": {"name": "List", "sig": "List.*", "kind": "namespace", "tip": "Operations over []T slices — length, ends access, push/pop, swap, search, and in-place reverse.", "page": "ns-list.html", "section": "Namespaces"}, "ns-log": {"name": "Log", "sig": "Log.*", "kind": "namespace", "tip": "Levelled, structured logging — the default way to answer \"what is my game doing?\" and \"why did that break?\", and a real step up from scattering print calls…", "page": "ns-log.html", "section": "Namespaces"}, "ns-map": {"name": "Map", "sig": "Map.*", "kind": "namespace", "tip": "A character grid the game paints and reads.", "page": "ns-map.html", "section": "Namespaces"}, "ns-math": {"name": "Math", "sig": "Math.*", "kind": "namespace", "tip": "Deterministic fixed-point math.", "page": "ns-math.html", "section": "Namespaces"}, "ns-memory": {"name": "Memory", "sig": "Memory.*", "kind": "namespace", "tip": "Raw memory — allocate byte and word buffers, copy and fill regions, and peek/poke individual bytes.", "page": "ns-memory.html", "section": "Namespaces"}, "ns-mime": {"name": "Mime", "sig": "Mime.*", "kind": "namespace", "tip": "Content-type detection for assets and downloads: map a filename to its MIME type, or refine the guess by peeking at a file's leading bytes.", "page": "ns-mime.html", "section": "Namespaces"}, "ns-motion": {"name": "Motion", "sig": "Motion.*", "kind": "namespace", "tip": "Ergonomic control of the engine-owned Motion component — the value tween the engine advances each tick (see the ECS engine-systems).", "page": "ns-motion.html", "section": "Namespaces"}, "ns-network": {"name": "Network", "sig": "Network.*", "kind": "namespace", "tip": "The low-level networking seam — send and poll datagrams, serialize and apply entity state, and read ownership and role.", "page": "ns-network.html", "section": "Namespaces"}, "ns-noise": {"name": "Noise", "sig": "Noise.*", "kind": "namespace", "tip": "Procedural noise — the primitive that terrain, caves, biomes, textures, clouds, wind, and object placement are built on.", "page": "ns-noise.html", "section": "Namespaces"}, "ns-os": {"name": "Os", "sig": "Os.*", "kind": "namespace", "tip": "The operating-system interface — the environment *around* the game rather than the game itself: the command line, environment variables, the standard streams,…", "page": "ns-os.html", "section": "Namespaces"}, "ns-path": {"name": "Path", "sig": "Path.*", "kind": "namespace", "tip": "Path manipulation as pure string operations — no disk access, no allocation surprises, just the joining and splitting every save system, mod loader, and asset…", "page": "ns-path.html", "section": "Namespaces"}, "ns-percent": {"name": "Percent", "sig": "Percent.*", "kind": "namespace", "tip": "A value clamped to [0, 1] — health fractions, volumes, and the t of an interpolation, without stray values slipping below 0 or above 1.", "page": "ns-percent.html", "section": "Namespaces"}, "ns-pool": {"name": "Pool", "sig": "Pool.*", "kind": "namespace", "tip": "Entity-pool statistics.", "page": "ns-pool.html", "section": "Namespaces"}, "ns-prefab": {"name": "Prefab", "sig": "Prefab.*", "kind": "namespace", "tip": "A prefab is a model with preset component fields — prefab Grunt: Creature { Stats { hp: 30 }, Weapon { def_id: 1 } } — spawned with spawn Grunt { Position { x:…", "page": "ns-prefab.html", "section": "Namespaces"}, "ns-process": {"name": "Process", "sig": "Process.*", "kind": "namespace", "tip": "Child processes, started and polled — what a launcher is made of.", "page": "ns-process.html", "section": "Namespaces"}, "ns-promise": {"name": "Promise", "sig": "Promise.*", "kind": "namespace", "tip": "Combine several Job futures and resolve the group on the main thread.", "page": "ns-promise.html", "section": "Namespaces"}, "ns-query": {"name": "Query", "sig": "Query.*", "kind": "namespace", "tip": "Spatial and set queries over the live entities that carry a property, built on the World reflection ABI.", "page": "ns-query.html", "section": "Namespaces"}, "ns-random": {"name": "Random", "sig": "Random.*", "kind": "namespace", "tip": "A seeded, deterministic RNG — same seed, same sequence, every run and every platform.", "page": "ns-random.html", "section": "Namespaces"}, "ns-rect": {"name": "Rect", "sig": "Rect.*", "kind": "namespace", "tip": "Axis-aligned rectangles for HUD layout boxes, hitboxes, and camera regions.", "page": "ns-rect.html", "section": "Namespaces"}, "ns-reflect": {"name": "Reflect", "sig": "Reflect.*", "kind": "namespace", "tip": "Runtime reflection over the world schema — inspect properties, fields, and entity state by name and by index.", "page": "ns-reflect.html", "section": "Namespaces"}, "ns-regex": {"name": "Regex", "sig": "Regex.*", "kind": "namespace", "tip": "Regular expressions with PCRE/PECL-compatible syntax over a **linear-time** Thompson NFA (a Pike VM), so a bad pattern from a modder can never trigger…", "page": "ns-regex.html", "section": "Namespaces"}, "ns-save": {"name": "Save", "sig": "Save.*", "kind": "namespace", "tip": "Whole-world save and restore — write a binary snapshot of the ECS world and read it back.", "page": "ns-save.html", "section": "Namespaces"}, "ns-screen": {"name": "Screen", "sig": "Screen.*", "kind": "namespace", "tip": "The 2D drawing surface.", "page": "ns-screen.html", "section": "Namespaces"}, "ns-set": {"name": "Set", "sig": "Set.*", "kind": "namespace", "tip": "A set of string members — membership tests for tags, unlocked achievements, or visited tiles.", "page": "ns-set.html", "section": "Namespaces"}, "ns-sprite": {"name": "Sprite", "sig": "Sprite.*", "kind": "namespace", "tip": "A namespaced spritesheet / atlas API.", "page": "ns-sprite.html", "section": "Namespaces"}, "ns-sync": {"name": "Sync", "sig": "Sync.*", "kind": "namespace", "tip": "The advanced, opt-in tier — here be dragons.", "page": "ns-sync.html", "section": "Namespaces"}, "ns-system": {"name": "System", "sig": "System.*", "kind": "namespace", "tip": "Low-level file and process access — raw file handles, reading a character, and running a shell command.", "page": "ns-system.html", "section": "Namespaces"}, "ns-text": {"name": "Text", "sig": "Text.*", "kind": "namespace", "tip": "String queries and building over string values — length, character access, substrings, search, prefix/suffix tests, and int conversion.", "page": "ns-text.html", "section": "Namespaces"}, "ns-tiled": {"name": "Tiled", "sig": "Tiled.*", "kind": "namespace", "tip": "Load and draw Tiled maps.", "page": "ns-tiled.html", "section": "Namespaces"}, "ns-time": {"name": "Time", "sig": "Time.*", "kind": "namespace", "tip": "The frame clock.", "page": "ns-time.html", "section": "Namespaces"}, "ns-tween": {"name": "Tween", "sig": "Tween.*", "kind": "namespace", "tip": "Value interpolation over a timeline, off the fixed frame clock.", "page": "ns-tween.html", "section": "Namespaces"}, "ns-udp": {"name": "Udp", "sig": "Udp.*", "kind": "namespace", "tip": "Plain IPv4 datagrams, polled — the transport under a game's own netcode: peer-to-peer play, a LAN lobby, a STUN query.", "page": "ns-udp.html", "section": "Namespaces"}, "ns-ui": {"name": "Ui", "sig": "Ui.*", "kind": "namespace", "tip": "The retained-mode menu API over a ui block.", "page": "ns-ui.html", "section": "Namespaces"}, "ns-unicode": {"name": "Unicode", "sig": "Unicode.*", "kind": "namespace", "tip": "Correct-by-default text over UTF-8.", "page": "ns-unicode.html", "section": "Namespaces"}, "ns-uuid": {"name": "Uuid", "sig": "Uuid.*", "kind": "namespace", "tip": "Universally-unique identifiers — stable IDs that don't collide, generated locally with no central authority handing out numbers.", "page": "ns-uuid.html", "section": "Namespaces"}, "ns-value": {"name": "Value", "sig": "Value.*", "kind": "namespace", "tip": "A generic, self-describing value tree — the node type reflection serializes into and JSON round-trips through.", "page": "ns-value.html", "section": "Namespaces"}, "ns-vector": {"name": "Vector", "sig": "Vector.*", "kind": "namespace", "tip": "2D vector math for positions, velocities, and directions.", "page": "ns-vector.html", "section": "Namespaces"}, "ns-world": {"name": "World", "sig": "World.*", "kind": "namespace", "tip": "Runtime reflection over the ECS world — read and write component fields by id, spawn and inspect entities, and register components at runtime.", "page": "ns-world.html", "section": "Namespaces"}, "ns-xml": {"name": "Xml", "sig": "Xml.*", "kind": "namespace", "tip": "A minimal, deterministic XML reader for the element/attribute/CDATA subset the native Tiled formats (TMX/TSX/TX) use.", "page": "ns-xml.html", "section": "Namespaces"}}, "colors_page": "ns-color"}; const KEYWORDS = S.keywords || {}, TYPES = S.types || {}, PHASES = S.phases || {}; const BUILTINS = S.builtins || {}, NSMETHODS = S.nsmethods || {}, ANNOTS = S.annotations || {}; const NAMESPACES = S.namespaces || {}, TIPS = S.tips || {}, CARDS = S.cards || {}; function esc(s){ return s.replace(/&/g,"&").replace(//g,">"); } const isIdStart = c => /[A-Za-z_]/.test(c); const isId = c => /[A-Za-z0-9_]/.test(c); function link(href, id, tip, inner){ const t = tip ? ' title="'+esc(tip).replace(/"/g,""")+'"' : ""; const d = id ? ' data-id="'+id+'"' : ""; return ''+inner+''; } function highlight(src){ let out = "", i = 0; const n = src.length; const stack = []; // call-context stack for named-parameter linking let pending = null; // ctx to push at the next "(" const nextNonSpace = j => { while (j < n && src[j] === " ") j++; return j; }; while (i < n){ const c = src[i]; if (c === "#"){ let j=i; while(j'; i=j; continue; } if (c === '"' || c === "'" || c === "`"){ const q=c; let j=i+1; while(j'; i=j; continue; } if (c === "@"){ let j=i+1; while(j'+esc(at)+''); else out += ''+esc(at)+''; i=j; continue; } if (/[0-9]/.test(c)){ let j=i; while(j'; i=j; continue; } if (isIdStart(c)){ let j=i; while(j'+word+''); out += '.'; if (word === "Color"){ out += link("ns-color.html#"+member.toLowerCase(), "", "Named color "+word+"."+member+".", ''+esc(member)+''); } else { const key=word+"."+member, m=NSMETHODS[key]; if (m){ out += link(m.id+".html", m.id, TIPS[key]||key, ''+esc(member)+''); if (src[nextNonSpace(k)]==="(") pending = {page:m.id, params:new Set(m.params||[])}; } else out += ''+esc(member)+''; } i=k; continue; } const ns = nextNonSpace(j); const callish = src[ns] === "("; const labelish = src[ns] === ":"; const top = stack.length ? stack[stack.length-1] : null; if (KEYWORDS[word]){ out += link(KEYWORDS[word]+".html", KEYWORDS[word], TIPS[word], ''+word+''); } else if (BUILTINS[word] && callish){ const b=BUILTINS[word]; out += link(b.id+".html", b.id, TIPS[word], ''+word+''); pending = {page:b.id, params:new Set(b.params||[])}; } else if (labelish && top && top.params.has(word)){ out += link(top.page+".html#param-"+word, "", "parameter: "+word, ''+word+''); } else if (TYPES[word]){ out += link(TYPES[word]+".html", TYPES[word], TIPS[word]||("The "+word+" type."), ''+word+''); } else if (PHASES[word]){ out += link(PHASES[word]+".html", PHASES[word], TIPS[word]||("The "+word+" phase."), ''+word+''); } else if (callish){ out += ''+esc(word)+''; } else { out += esc(word); } i=j; continue; } if (c === "("){ stack.push(pending); pending=null; out+='('; i++; continue; } if (c === ")"){ stack.pop(); out+=')'; i++; continue; } if (/[{}\[\]=<>+\-*\/%,.:;!&|~]/.test(c)){ out+=''+esc(c)+''; i++; continue; } out += esc(c); i++; } return out; } function highlightAll(){ document.querySelectorAll('pre[data-lang="ludic"]').forEach(pre => { pre.innerHTML = highlight(pre.textContent); }); } /* ---- tooltip cards: click a token to open; click the card to open the --- ---- page in a new tab; click outside (or Escape) to close ------------- */ let cardEl = null, cardAnchor = null; function ensureCard(){ if (cardEl) return cardEl; cardEl = document.createElement("div"); cardEl.className = "hovercard"; cardEl.hidden = true; cardEl.addEventListener("click", () => { const h = cardEl.dataset.href; if (h) window.open(h, "_blank", "noopener"); }); document.body.appendChild(cardEl); return cardEl; } function positionCard(a){ const el = cardEl, r = a.getBoundingClientRect(); const cw = el.offsetWidth, ch = el.offsetHeight; let left = r.left, top = r.bottom + 8; if (left + cw > window.innerWidth - 12) left = window.innerWidth - cw - 12; if (left < 12) left = 12; if (top + ch > window.innerHeight - 12) top = r.top - ch - 8; el.style.left = Math.max(12,left) + "px"; el.style.top = Math.max(12,top) + "px"; } function showCard(a){ const id = a.getAttribute("data-id"); if (!id) return; const c = CARDS[id]; if (!c) return; const el = ensureCard(); el.innerHTML = '
' + (c.kind||"").replace("namespace-method","method") + ''+esc(c.name||"")+'
' + (c.sig ? ''+esc(c.sig)+'' : "") + '
'+esc(c.tip||"")+'
' + '
'+esc(c.section||"")+' · open in new tab ↗
'; el.dataset.href = a.getAttribute("href") || ""; el.hidden = false; cardAnchor = a; positionCard(a); } function hideCard(){ if (cardEl){ cardEl.hidden = true; cardAnchor = null; } } function installCards(){ document.addEventListener("click", e => { const a = e.target.closest && e.target.closest("a.tok[data-id]"); if (a){ e.preventDefault(); showCard(a); return; } // token -> open card if (cardEl && !cardEl.hidden && !(e.target.closest && e.target.closest(".hovercard"))) hideCard(); // outside -> close }); document.addEventListener("keydown", e => { if (e.key === "Escape") hideCard(); }); window.addEventListener("resize", hideCard); window.addEventListener("scroll", () => { if (cardEl && !cardEl.hidden && cardAnchor){ const r = cardAnchor.getBoundingClientRect(); if (r.bottom < 0 || r.top > window.innerHeight) hideCard(); else positionCard(cardAnchor); } }, {passive:true}); } /* ---- flash the scrolled-to target ------------------------------------- */ function flash(el){ if (!el) return; el.classList.remove("flash"); void el.offsetWidth; el.classList.add("flash"); } function flashTarget(){ const go = () => { // Only a deep link gets a flash. The old fallback flashed the page title // on every plain visit, which points at nothing the reader was looking for. const h = location.hash ? decodeURIComponent(location.hash.slice(1)) : ""; if (h) flash(document.getElementById(h)); }; if (document.readyState !== "loading") go(); else document.addEventListener("DOMContentLoaded", go); window.addEventListener("hashchange", () => { const el = document.getElementById(decodeURIComponent(location.hash.slice(1))); flash(el); }); } /* ---- fuzzy search on the API index ------------------------------------ */ function subseq(q, s){ let i=0; for (let k=0;k { const q = box.value.trim().toLowerCase(); let shown = 0; items.forEach(it => { const name = (it.getAttribute("data-name")||"").toLowerCase(); const tip = (it.getAttribute("data-tip")||"").toLowerCase(); const hit = !q || name.includes(q) || tip.includes(q) || subseq(q, name); it.style.display = hit ? "" : "none"; if (hit) shown++; }); secs.forEach(sec => { const any = [...sec.querySelectorAll(".idx-item")].some(i=>i.style.display!=="none"); sec.style.display = any ? "" : "none"; }); if (none) none.hidden = shown !== 0; }; box.addEventListener("input", run); box.addEventListener("keydown", e => { if (e.key === "Enter"){ const first = items.find(i=>i.style.display!=="none"); if (first) location.href = first.getAttribute("href"); } }); } /* ---- mobile nav toggle (auto-wired on every page) ------------------- */ function initNav(){ document.querySelectorAll(".nav-toggle").forEach(btn => { btn.addEventListener("click", () => { const h = btn.closest("header.nav"); if (!h) return; const open = h.classList.toggle("open"); btn.setAttribute("aria-expanded", open ? "true" : "false"); }); }); document.querySelectorAll("header.nav .nav-links a").forEach(a => { a.addEventListener("click", () => { const h = a.closest("header.nav"); if (h){ h.classList.remove("open"); const b = h.querySelector(".nav-toggle"); if (b) b.setAttribute("aria-expanded","false"); } }); }); } if (document.readyState !== "loading") initNav(); else document.addEventListener("DOMContentLoaded", initNav); global.Ludic = { highlight, highlightAll, installCards, flashTarget, installSearch, initNav, SYMBOLS: S }; })(window);