Path: cyberia-client/ · Language: C11/GNU11 → WebAssembly (Emscripten) · Role: presentation runtime for Cyberia
cyberia-client is the rendering and interactive runtime for the Cyberia MMO extension on Underpost Platform. It captures input, predicts the local player, reconciles against authoritative snapshots, interpolates remote entities, and renders the world. It owns the render policy locally.
It is not a world-simulation authority. The authoritative simulation runs on cyberia-server. Persistent content and asset metadata come from engine-cyberia via REST.
Three independent processes, non-overlapping roles. The ecosystem is playable only when all three are running and healthy at the same time.
engine-cyberia cyberia-server cyberia-client
content authority simulation authority presentation runtime
^ REST | WebSocket binary
| atlases, asset | snapshots (server -> client)
| metadata, optional | input cmds (client -> server)
| client hints v
`---------------- Browser tab: prediction, reconciliation, interpolation, render
- Each service owns its own monitor and reconnector.
- The client reconnects to
cyberia-serverover WebSocket and fetches content fromengine-cyberiaover REST. - If any of the three services is unhealthy, the game moves to standby until all three recover.
The client speaks two transports:
- WebSocket to
cyberia-serverfor snapshots and client events (JSON messages in binary frames) - REST to
engine-cyberiafor atlas frames, asset blobs, and optional client-hints overrides
Asset distribution flows through Underpost Platform's static and PWA pipeline.
The render loop runs at vsync. Tick simulation is decoupled from render frames via a fixed-timestep accumulator. Step ordering inside one render frame:
- Reconciliation — replace the own state with the newest snapshot; drop the client events up to
inputConsumedThrough; replay the rest from the snapshotframeto the current frame. - Input capture — drain raw OS events.
- Input dispatch — UI hit-test → push client events (
kind,frame,sequence, payload). - Fixed-timestep prediction — while accumulator ≥
tickDuration, advance one frame; then send the new events once. - View — draw the own player between the last two fixed steps; interpolate remote entities.
- Render — read view models; never mutate world state.
Render frame rate is independent of simulation tick rate. The fixed-timestep accumulator ensures the predicted simulation advances at the authoritative tickRate regardless of FPS.
Each folder under src/ is one concern. Dependencies point from view/ and ui/ inward to sim/ and world/.
src/
main.c, config.h entry point + render loop; TICK_RATE_HZ
world/ entity types, object layers, layer z-order
sim/
game_state.{c,h} world mirror: entity table + component arrays
replication.{c,h} session counters, prediction, interpolation
self_motion.{c,h} the one motion function of the own player
local_player.{c,h} own player state outside motion: inventory,
containers, party, capacity helpers
container_ops.{c,h} item moves of the bag and the containers, sent as item_move
net/
client_event.{c,h} the one uplink: stamp, keep, send, trim
message.{c,h} JSON message decoder (snapshot, combat_text, ...)
game_client.{c,h} WebSocket lifecycle
socket.{c,h} Emscripten WebSocket bridge
content/
presentation_runtime.{c,h} sole owner of presentation: async fetch of
/api/v1/cyberia-client-hints/:CYBERIA_CLIENT_HINTS_CODE
stat_contract_generated.h generated by engine-cyberia stat-contract
data/ REST caches: actions, dialogues, quests, instance map
input/ raw OS input → client events
view/ camera, viewport, render pipeline, entity render
ui/ modals, HUD, inventory bar, FCT, nameplates,
chat log and panes, profile and party views
fx/, audio/ effects and sound
js/ small JS bridges (assets, fullscreen, text input)
| Owner | Owns | Reads | Writes |
|---|---|---|---|
content/presentation_runtime |
the entire presentation surface (palette, entity colour keys, status icons, camera, cell, interpolation). Inline bootstrap fallback while the fetch is in flight. | JSON response from /api/v1/cyberia-client-hints |
own table + one-shot hydration of g_game_state.cell_size, .interpolation_ms, .camera.zoom |
net/client_event |
the client event list | session for frame + sequence | the socket |
sim/replication (prediction) |
the own player: last two fixed steps, newest server state | snapshot self block + client event list | own player state |
sim/replication (interpolation) |
remote entity interp_pos |
snapshot history | remote interp_pos only |
sim/replication (session) |
frame counter, next sequence | — | session counters |
net/message |
wire parser | JSON messages | game_state + prediction (via prediction_on_snapshot) |
sim/game_state |
gameplay world mirror | — | — |
view/, ui/ |
rendering | view models | screen |
game_state holds only the gameplay subset of world state, in an entity table with one array per component (data, transform, appearance, vitals, progress, motion, agent, portal). It does not carry palette state, status-icon visuals, or any other presentation field.
The client owns its render policy. The authoritative server holds no presentation state.
Three layers, strictly inward-dependent:
content/presentation_runtime.{c,h}— sole owner of every presentation value. Fires a single asynchronous GET against/api/v1/cyberia-client-hints/:CYBERIA_CLIENT_HINTS_CODEat startup, polled once per render frame. When the response settles, parses palette, entity colour keys, status-icon visuals, and camera/cell tunings into a process-local table and writes a one-shot hydration intog_game_state(cell_size, interpolation_ms, camera.zoom). The C client carries NO compile-time palette or status table — only a tiny inline neutral-grey bootstrap so the splash screen has something to draw while the fetch is in flight. The canonical schema for the response lives at engine-cyberia'ssrc/client/components/cyberia/SharedDefaultsCyberia.js.- Renderers — call
presentation_runtime_palette("KEY"),presentation_runtime_status_icon(u8),presentation_runtime_status_border(u8),presentation_runtime_entity_fallback_color(entity_type)at each use site.
What lives in this layer:
- Named palette (colors).
- Per-entity-type fallback color keys.
- Status-icon visual table (icon stem + border color per numeric ID).
- Camera smoothing / zoom defaults.
- Interpolation window.
- Dev-overlay flag.
- Viewport screen factors.
What does not travel on the WebSocket init or AOI streams:
- Palette.
- Camera knobs.
- Dev-overlay flag.
- Interpolation window.
- Status-icon visuals.
- Per-entity-type color keys.
The numeric status-icon u8 still rides on the AOI wire — that is the protocol-level half. The icon stem and border color are presentation and are resolved entirely on the client.
GET /api/v1/cyberia-client-hints/:instanceCode (engine-cyberia REST, not cyberia-server) returns a JSON document mirroring the structure of the compile-time defaults. The client is required to function with no successful call to this endpoint:
- 200 with
{ palette, entityColorKeys, statusIcons, cameraSmoothing, cameraZoom, defaultWidthScreenFactor, defaultHeightScreenFactor, interpolationMs, devUi }— overrides applied on top of defaults. - 404 if the instance has no overrides — defaults are used.
- Network error — defaults are used.
No authentication; presentation hints are not secret. The Go authoritative server never calls this endpoint.
sim/replication.{c,h} keeps two per-connection counters:
session_frame()— completed fixed steps in this session.session_frame_advance()is its only writer, once per fixed step.session_next_input_sequence()— monotonic sequence for outgoing client events. Never reused.
Prediction moves the own player only. Every other entity takes the server state. The live step and the replay use one motion function, self_motion_step().
prediction_on_snapshot(state, frame, consumed)— the decoder hands over the self block. A newer state replaces one the reconcile did not apply yet.prediction_reconcile()— phase 1 of the tick: replace the own state with the newest server state, drop the client events up toconsumed, and replay the rest fromframeto the current frame.prediction_step(s)— one fixed step;sis the frame the step completes.prediction_prev(),prediction_self()— the last two fixed steps. The view draws the own player between them. View-only; it never writes simulation state.
interpolation_compute_view() owns remote-entity render-time positions. It is the only writer of remote interp_pos and never touches the local player. It lerps from the previous position to the newest snapshot position over interpolation_ms.
pointer events / keyboard
│
▼
input/ pointer router, steering, keys
│
▼
UI hit-test cascade ──► modal/inventory/HUD consumed?
│ no
▼
client_event_push stamps frame + sequence + time; keeps the event
│
▼
client_event_flush after the fixed steps: sends each new event once
net/client_event is the one uplink. A module pushes an action and touches no stamp, no sequence and no socket. The list keeps each event until a snapshot's inputConsumedThrough passes its sequence (client_event_trim), so the reconcile can replay it, and so it can send it again: input_resend {from} (client_event_resend) rewinds the flush to the first event at or past from when the server refused a batch past a gap (the input command pipeline).
The modal counter (ui/modal) owns the stasis of the player. Its first open sends player_stasis true; its last close sends false; init_data sends the count again. Each change is one sequenced event, so the server and the client agree once the server consumed it.
The pointers move the player in two ways: tap or click a point, or drag a floating joystick. The joystick works on every platform and at every viewport size. ui/hud_joystick.c draws it.
js/pointer_bridge.c is the one source of pointer events: the browser Pointer Events of the canvas, for the mouse, touch and pen. Each finger keeps its browser pointerId from its press to its release, so no touch array order applies. The canvas has touch-action: none, so the browser never takes a finger for a scroll or a zoom; the rest of the page keeps its own gestures. The canvas captures each pointer it presses. The bridge cancels a held pointer on a pointercancel, a lost pointer capture, a focus loss (blur, a hidden page), or a right click while the left button holds the mouse. It merges the moves of one pointer between two frames and never drops a press, a release or a cancel by itself: past 256 waiting events it cancels every pointer the client holds. On a blur, GLFW releases every held key, so key steering stops too.
The splash routes its pointers the same way, as a full-screen surface: it starts on the release of its press, so no world tap follows it.
input/input.c routes each pointer. A press gets a handle and one owner when it lands, and keeps both until it lifts or is cancelled. Another pointer never changes them. A new press goes to the first owner that takes it:
| Order | Owner | Takes the press when | Result |
|---|---|---|---|
| 1 | UI | A full-screen surface blocks the gestures: the expanded Instance Map | The surface reads it, two presses pinch the map. |
| 2 | Claimed | input_claim_fn takes it: a combat control |
The combat cluster follows it with input_pointer_at until it lifts. |
| 3 | UI | The interface covers the press position | The first UI press taps on the press frame and is the UI pointer. A UI press while it is held sends no tap. |
| 4 | World | No other owner takes it | A tap on release, or the joystick. |
| 5 | Pinch | Two world presses that are not the joystick | The camera zooms. Neither press taps or steers until it lifts. |
input_pointer_down and input_pointer_position read only the UI pointer, never a joystick, combat or world press. input/pointer_gesture.c sorts one world press into a tap or the joystick.
| Gesture | Result |
|---|---|
| Tap or click on the world | The player walks to the point. The tap goes out on release, at the press position. |
| Quick press on the world | Released within 150 ms, a press is a tap, however far the pointer moved. A fast click on the move never starts the joystick. |
| Held drag on the world | Held 150 ms and moved past 35 px, a press shows a joystick at the press position. The pointer sets one of eight headings, the same as the arrow keys. |
| Thumb in the inner 15 % | No heading. The player stops. |
| Release after a drag | The joystick hides and the player stops. The drag sends no tap. |
| Second finger on the world while it steers | The joystick keeps steering. The finger cannot pinch with it. Its tap selects a target or an interaction and does not walk. |
| Two fingers on the world | Pinch zoom. Neither finger taps or steers. |
| Finger or click on the UI | The UI owns it. The tap goes out on the press. A drag never starts the joystick. |
| Finger on a combat control | The combat cluster owns it until it lifts. The other thumb keeps the joystick, in either order. |
| Lost finger: cancel, focus loss, right click | A cancelled press acts on nothing: no tap and no cast. A lost joystick sends one stop. A UI surface rolls a lost press back (input_pointer_cancelled): a dragged stack goes back to its slot, and no tap, drop, flip or map selection follows. |
The joystick adds no wire message. It sends the same synthetic steering taps as the keyboard: the same reach, the same refresh at the action cooldown, the same stop. While it steers, the arrow keys wait. The base stays where the drag started. A steering tap only moves the player: it casts no skill. A steering tap and a cast are two sequenced events, so one events message can carry both.
To check a change, use a phone and a desktop browser. A browser driver with multi-touch, such as Puppeteer touchscreen.touchStart, sends real touch events with their own ids; it does not replace a phone.
- Tap the ground. The player walks there. No joystick shows.
- Hold one finger still for a second, then lift it. The player walks to that point.
- Drag from any point of the ground. The joystick shows under the first contact. The player walks in the drag direction, in eight headings.
- Move the thumb back to the base. The player stops. Lift the finger. The joystick hides.
- Put two fingers on the ground and spread them. The camera zooms, and no tap moves the player.
- Steer with one thumb and tap the ground with the other. The player keeps walking; the tap selects only.
- Steer with one thumb and tap a toolbar button with the other. The button responds, and the player keeps walking.
- Drag the Quest Journal list and the thumb of the inventory bar track. They scroll. No joystick shows.
- Open the Instance Map. Drag and pinch it. No joystick shows.
- On a desktop, click the ground: the player walks there on release. Drag the mouse on the ground: the joystick shows and steers. Release: the player stops.
- On a desktop, click toolbar buttons and drag the inventory bar track. They respond on the press, as before. Steer with WASD and zoom with the wheel.
ui/combat_cluster.c shows one round control for each manual skill of the active items, in loadout order, up to four. The skill map gives each skill its skillId, its activation, its targeting and its reach; an automatic or an event skill never gets a control. A control shows the entity the skill summons, the radial sweep and the seconds of the action cooldown, a ping when the cooldown ends, and a ready glow. Ready means ready to attempt: the server still rolls the chance.
The first control sits in the bottom right corner of the screen the HUD leaves to the world: above the inventory bar, left of an open side column. On a wide screen it stays at most 360 px from the character, toward the right. The others ring it from the left to the top. A control keeps its place while the loadout stays the same. Each control is at least 52 px across, with at least 8 px between two rims. The cluster hides in stasis, while the player waits to respawn, and behind the session card.
Every cast names its aim (facing, auto_target or direction, see the server skills). The mouse never aims by itself.
| Input | AUTO TARGET on | AUTO TARGET off |
|---|---|---|
| Tap a control, or hold it with no drag | The server aims at the best target, else facing | Along the facing |
| Keys 1 to 4 | The server aims at the best target, else facing | Along the facing |
| Drag a control past 14 px, release | Along the drag | Along the drag |
| Shift with a key | Toward the mouse | Toward the mouse |
| Release over the cancel zone | Nothing | Nothing |
| Escape or the right button | Cancel the press | Cancel the press |
| Tap a hostile in the world | It becomes the target an auto aim keeps | It becomes the target |
A self skill casts on the player whatever the aim. AUTO TARGET is on by default; the settings card switches it, and the choice holds for the page. The facing is the facing the player sees: the server keeps it when a walk stops (see facing).
sim/auto_target.c predicts the server pick from what the client holds: the kept target while it lives in reach, else the hostile bot ahead of the facing, then the nearest, then the lowest id. The server also ranks the enemies engaged with the player first, which the client does not hold, so the reticle can move when the answer arrives. skill_ack names the target the server took; the cluster keeps it as the target of the next auto aim until it dies or leaves the reach.
Each cast is one skill_activate event. A hold sends nothing until its release. One cast flies at a time. A cast pushed while one waits for its answer, or in the last 250 ms of the cooldown, is queued: three gold segments turn around its control, and it goes once the cooldown ends, with the aim it was given, or is refused when 250 ms pass. Any other cast during the cooldown is refused on the control. The server checks the queued cast again when it arrives. skill_ack answers each cast with its sequence: the control flashes green on a cast, violet on a misfire, and amber on a refusal, and a misfire raises MISFIRE over the player. The ack sets the action cooldown at once; a later answer to a cast that stopped waiting changes only the cooldown. A new session drops the target and the cast in flight.
fx/fx_combat_aim.c draws what the aim does. Each state has its own shape, not only its own colour:
| Mark | Shows |
|---|---|
| Thin cyan brackets, a dot | AUTO TARGET on: the target a tap takes now |
| Bold cyan brackets | The target the server took, or the hostile the player tapped; it closes in when it takes the target |
| Guide | A held or dragged control: a translucent body with an outline, a pulse that runs out, a chevron at the end. It starts at the character, runs the reach of the skill up to the edge of the screen, and takes the exact angle the cast sends |
| Gold brackets, a cross | The end of a manual guide |
| Red guide | The release cancels |
| Fading gold guide | The exact aim the server answered for the last cast |
A mark only shows the aim. The hit shows through the damage numbers and the hit burst of the server.
The own player stands on a ground anchor: a flat cyan ring of art pixels with a notch on each side, under the sprite. Its sprite has a dark outline one art pixel wide (draw_entity_layers with an outline colour) and draws 10 % larger than the others. The world keeps its colours; a roof over the player fades as before.
The inventory bar stays an inventory: every stack shows in its slot, and a tap opens its item modal. Over a slot it previews only what an automatic skill of the item consumes. A manual skill shows only in this cluster.
To check a change on a phone and on a desktop:
- Activate a weapon with a manual skill. One control shows in the bottom right corner. Activate an item with a second manual skill: a second control shows left of the first.
- Walk right, stop, and tap the control with AUTO TARGET off. The projectile flies right. Repeat for each of the eight directions.
- With AUTO TARGET on and a hostile in reach, thin brackets mark it. Tap the control: the projectile flies at it and the brackets turn bold.
- Tap another hostile in the world, then tap the control: the projectile flies at the tapped one.
- Hold a control, drag at any angle, and release. The guide follows the drag at that angle, and the projectile flies along it, not along the nearest of the eight facings.
- Drag to the cancel zone and release. The guide turns red, and nothing is cast.
- Steer with the joystick and tap a control with the other thumb. Then press the control first and steer second. Then drag a control to aim, and drag one to the cancel zone. Each time the player keeps walking, one tap or release casts once, and the cancel zone casts nothing. Lift either thumb first: the other keeps its control.
- Tap the control twice in the cooldown. In the last quarter second the second tap shows the turning segments and goes when the cooldown ends; earlier, the control flashes amber.
- On a desktop, walk right with D, stop, put the mouse on the left side, and press 1 with AUTO TARGET off: the projectile flies right. Press Shift+1: it flies left, toward the mouse.
- On a desktop, steer with a mouse drag and press 1: the skill casts and the player keeps walking. Hold A and click a control: the skill casts. Drag a control with the mouse and right click before the release: nothing is cast.
Every message in both directions is a JSON envelope { "type": ..., "payload": ... } sent in a binary WebSocket frame. net/message.c dispatches on type.
The server sends one snapshot per tick. Its payload carries:
| Field | Meaning |
|---|---|
frame |
the client frame this state stands for; 0 before the first consumed event |
inputConsumedThrough |
highest client event sequence a tick has applied for this client |
entities |
the AOI entities, life rounded up to whole numbers |
self |
the own player block |
The decoder hands the self block, frame and inputConsumedThrough to prediction_on_snapshot(). prediction_reconcile() applies it at the start of the next tick.
The other server messages — init_data, session_end, resume, metadata, combat_text, audio_event, drop_spawn, drop_collect, chat, chat_ack, party_ack, friends, friend_ack, dialog_ack, shop_ack — are not part of the per-tick replication stream.
The first message of every connection is auth: {ticket} with the launch ticket the page took from its address fragment, {} without one. A refusal shows the session card, whose ways open the launch bridge of the portal: Continue as guest or Sign in (accounts and persistent players). An account session keeps the resume ticket of resume {ticket} in memory; after a lost connection or a server restart it reconnects with it and comes back without the portal (resume). A guest card opens a new connection after a lost connection or a restart. The settings button opens the same card as the settings menu: the sound and full-screen toggles, then World select, Play as guest, Sign out, or Sign in to keep progress (leaving).
The client sends one events message per frame with new events. Its payload is { "events": [ ... ] }; each event is an envelope whose payload carries seq, frame and timestamp.
The client speaks REST directly to engine-cyberia for content. None of these calls go through cyberia-server.
The client draws a render by the cid of its definition, never by a label. A label stands for the cid
of the definition the world binds it to: the metadata message sends that definition. A held stack
keeps the cid it was granted with. Renders are cached by cid, so two labels of one definition share
one download. The engine reads a definition from its cache, else from the Object Layer authority, so
a definition no served release holds keeps its render. The primary render is the bytes the
canonical render CID addresses, at one pixel per cell, and the layout describes that same render.
The engine also keeps an upscaled derived render for viewing; the client never downloads it.
The render contract defines these terms.
| Endpoint | Purpose |
|---|---|
GET /api/v1/atlas-sprite-sheet/layout/:cid |
Frame layout JSON of a definition's render |
GET /api/v1/atlas-sprite-sheet/render/:cid |
Primary render PNG, one pixel per cell |
GET /api/v1/cyberia-dialogue/code/default-:itemId |
Dialogue lines for an NPC |
GET /assets/ui-icons/:iconId.png |
Status-bar icons |
GET /api/v1/cyberia-client-hints/:instanceCode |
Optional presentation overrides |
GET /api/v1/cyberia-instance/instance-map/:instanceCode/static |
Instance Map graph (nodes, edges, POIs) |
GET /api/v1/cyberia-universe/instance/:instanceCode |
The universe of this world, with availability |
All requests are CORS-simple GETs (no preflight) and cacheable. None require credentials.
data/engine_client is the one fetch layer and the one cache of bytes and GPU textures. Every other
module asks it by URL and keeps only what it parsed.
| Layer | Key | Owner of residency | Bound and end |
|---|---|---|---|
| Fetch slots, bytes, GPU textures | URL; renders and layouts by CID | The fetch layer; a draw touches its entry | FETCH_QUEUE_CAP slots; 64 MiB resident; least recently touched first, never one touched this frame |
| Decode | URL | The fetch layer | 16 MiB loaded bodies; two image decodes, one kept for the own player |
| Shared bytes | Reference count | Each consumer until fetch_data_release |
Freed with the last reference |
| Instance and universe map | World code, session stamp | The open map view | One graph; a late answer of an older session or world is dropped |
| Action, quest, dialogue metadata | Content code | Its cache module | One entry per code of the engine release the client reads |
| UI icons, fonts | File stem | ui/ui_icon, ui/text |
The bundled set |
A request of a URL already queued or loaded joins it, so concurrent consumers cost one download. A
failed URL waits 5 s before a new try. A map change lowers every queued request to background
priority and keeps what is resident, so a world visited again draws at once. Each frame spends at
most 2 ms (8 ms while the own player or the scene waits) on decode, upload and callbacks, never a
blocking call. --stream-profile traces every load, decode, upload and eviction. The native test
asset_stream_test travels through 40 worlds of 4 MiB textures and holds the resident bytes under
the budget plus the textures in use.
On the server, game/net/content_resolve fetches each label a traveler brings once at a time, from
the release of the world, within 5 s, and a sweep every 30 s drops every resolved definition that
nothing in the world holds. Content never caches player or live entity state.
The Instance Map has two views. WORLD shows the maps of this instance and their portal links.
The engine places the maps in src/projects/cyberia/instance/instance-map-layout.js, the geometry of the world preview.
The static payload gives each node its centre (position) and size (w, h), in layout units: the longest map side of the world is 1.
The client requires position; deploy the engine update before the client update.
Every map uses the same scale and keeps its grid proportions.
Maps on neighbour layout cells touch, whatever their sizes. A run of empty cells stays as one gap. A map with a world origin keeps its physical place. The client gives each map its bounds once per static payload. Edges closer than 1/100 of a map cell take one value, so maps that touch meet on one pixel at every zoom. Two maps join when they share an edge of positive length. A corner or an overlap does not join. Maps that join form one surface: one rim goes around it, and a shared edge has no gap or border. A portal link across a shared edge shows only while one of its maps is selected. A link between maps apart always shows. Each map keeps its own click area. The right and bottom edges belong to the next map when maps meet. The own map, the selected map and the hovered map take their marks inside their bounds, so a mark never opens a gap. A mark is an outline: red on the own map, gold on the selected map, cyan on the hovered map. No mark tints the map picture. The view opens with the whole world as large as the frame allows, until one map cell spans 8 px.
A name plate sits at the centre of each map and each world card. It is blue, so it stands out from the markers, and gold on the selected node. Its text size follows the card, from 10 to 20 px. A long name takes a smaller text first, then ends with an ellipsis. Maps with the same name include their codes. A plate hides when the card is too small to hold it. Matching preview images fill their map bounds. Images with different proportions stay centred within the map.
UNIVERSE shows the worlds of its universe on their cells, the routes between them, and what serves each world now. A world card has the proportions of its world preview (w, h of the view). Both views are for navigation and planning; neither reproduces the gameplay viewport.
One integrated widget with two modes, split across two modules:
- Toolbar (
ui/toolbar) — the top HUD strip: the compact map readout left-aligned, and the right-hand toggle row[chat][social][quest][map][settings]. The quest button shows/hides the Quest Journal and the map button shows/hides the minimap; both are hidden by default and stay open together. A tap on either closes the chat and the social panel. The coordinate readout opens the expanded Instance Map, which morphs to the full screen with an eased transition and retracts the same way on close. - Side stack (
ui/hud_side_stack) — the right-hand column the HUD panels live in, between the toolbar and the inventory bar: the minimap on top and the Quest Journal beneath. The chat or the social panel takes the whole column while it shows, over the minimap and the journal, and the social panel covers the chat. The column sizes to the room the bar leaves. When the journal is open the minimap gives way to at most half of the column, and the journal takes only what its content needs; a map slot under 100 px gives way. Each panel keeps its own state across toggles for the session: the journal its scroll, sections and pages, the minimap its zoom and its texture toggle. - Minimap (
ui/hud_minimap_overlay) — the current map only: its map preview at 55 % over a see-through backdrop, with its border, fitted to the slot at zoom 1, and following the player at a closer zoom up to the map edges. Over it, in this order: the authored bots and resources as faded marks, the entry spawn when it lies on this map, the live bots and resources in the class of their status, the other players as squares, the quest targets of this map in their gold brackets, each portal as a gate where it stands, and the own player with its facing. Every mark is the one of the Instance Map (ui/map_marker) at its smallest size. An exit to another map has an arrow toward that map and a tag with its destination, as the World view names it; a link inside the map has a ring. A tag takes the first side of its gate that is clear of the controls, the markers and the other tags, and the pointer over a gate names its exit in full. The controls stand in the top right corner of the map: open map, the texture toggle, zoom in and zoom out, and the two transparency steps, in a row when the map is short. Open map opens the Instance Map, as the coordinate readout does; the Instance Map hides the minimap and gives it back when it closes. With the texture off, a grid on a see-through fill marks the map and every marker stays. The world shows through the map in both modes; the header, the controls and the markers stay opaque. No other map is drawn. - Container (
ui/modal_map) — compact mode is the always-on readout (map code, position, fps) hosted inside the toolbar; expanded mode is the full-screen morph target. - Content (
ui/modal_instance_map) — renders the Instance Map inside the container: an opaque full-screen canvas with the modal chrome. A header strip under the toolbar holds the WORLD and UNIVERSE tabs, the name of the view and the close button; the details of a selection show on a modal card. A press on the header or on the card never reaches the map under it.
Strict independence from the gameplay renderer:
| Concern | Owner |
|---|---|
| Graph data | data/instance_map_data and data/universe_map_data — engine-cyberia REST only, never the AOI stream |
| Camera | own pan/zoom with smooth exponential interpolation (drag pan, wheel zoom, pinch zoom) |
| Layout | WORLD: the map geometry of the engine; UNIVERSE: the world cards packed on their cells; a view never turns the authored arrangement |
| Selection | tap a mark or a node → detail card: a map, a portal, a place, a bot, a resource or the entry spawn, or a world's thumbnail, status, route and TRAVEL; a tap on a group zooms in; the camera moves a node its card covers |
Data lifecycle:
- Opening the overlay fetches the static payload once: graph nodes with their cells and the bots and resources each map places (
placed), portal edges, theentrySpawnof the world, and authoredpresencePoiscarrying map-cell presence status, their quests with their title andprerequisiteCodes, their actions with their label, the services they configure (shop,craft,storage,market,buyback,burn,talk) and the quests that use them, each bot placed there with its skin, whether a player can kill it and its stat sum as placed (bots), each resource placed there with its item and its stat sum (resources), and the items the cell gives (yields: dropped by what is placed there, sold or assembled by its action). The engine resolves a placement with the spawn rules of the server: the items it wears at spawn, its level, the progression rules and the layer cap of the world. A stat sum is the one the overhead HUD shows for that entity at spawn; it is never a live value. The minimap, the expanded map and the Quest Journal each hold the payload while they show; the last one to hide lets it go. A random portal mode sends no target cell, as the server drops it. The payload holds no content document: quest details load on selection fromquest_cache. The instance code arrives in the simulation server'smetadatamessage. A view switch asks for nothing; a reopen asks for the same URL, and the fetch layer answers with the response it holds. AworldRevisioninmetadata(at join and after each world rebuild) forgets that response; an open map fetches again at once. - The client marks a quest POI active while its quest is acceptable or active in the local quest store, and an action POI active when it stands alone or one of its quests is. It marks them again at each quest store change; no request names the player.
- The UNIVERSE view reads
/cyberia-universe/instance/:instanceCodethe first time it shows, and again every 20 seconds while open, past the response cache (fetch_forget). It loads a world picture only when its card is drawn. - Closing the overlay discards a late response.
- A view whose fetch failed offers RETRY, which forgets the failed response and fetches again at once.
- A refetched graph keeps the selection by the code of its map or world, never by its index.
The UNIVERSE view draws each world with its world preview (world pictures), on a card of the proportions of that preview, and a dotted tile with its initials while the picture loads or when it has none. It outlines this world in the player red and shows the own player mark on its card, marks each world with its status (ONLINE, CLOSING, OFFLINE), and each link between worlds; a one-way link ends in an arrow. A selected world shows the shortest known route from this world over those links, wide in the route colour with a pulse and an arrow the way it is travelled; the other links fade. Its card shows the thumbnail its author set (none when there is no thumbnail: the card already shows the preview), its name, its status, the route (YOU ARE HERE, DIRECT ROUTE FROM YOUR WORLD, ROUTE: 2 JUMPS - FIRST TO <world> or NO KNOWN ROUTE FROM YOUR WORLD) and its entry spawn; it never shows a server address. A world the served release lacks shows dimmed. A selected world offers TRAVEL only when a route leads there from this world and a server of it takes new sessions; otherwise the button names the reason (NO DIRECT LINK FROM HERE, WORLD OFFLINE, WORLD CLOSING, NOT IN THIS RELEASE). Travel goes one link at a time: a longer route names the first world to travel to. TRAVEL closes the overlay and leaves through the session gate, which names each step: the final save of this world, then the entry of the target. An account whose target runs the server build it plays on enters the target in the page; otherwise, or when that fails, the launch bridge of that world opens with the same principal (travel in the page). A route never proves that a server is up; a world stays on the graph while it is offline.
Live player position never travels through this API — engine-cyberia holds no simulation state. The overlay marks the player's node (and cell fraction within it) from the client's own predicted position, refreshed every frame.
The marks of the Instance Map and the minimap come from one module, ui/map_marker. Each role has its own shape, so a mark reads without its colour, and every icon keeps the colours of its PNG:
| Mark | Shape |
|---|---|
| Own player | a red disc with a white rim, a pulse ring and an arrow for its facing; drawn over every mark |
| Portal | a cyan diamond gate with a white core where the portal stands; purple for a link in one map |
| Portal link | a thin line from the gate to an arrow on the cell it leads to |
| Random portal | a dashed link to a ring that roams over the target map; the view names no cell |
| Action | a pin on its cell with the icon of its first service and a badge with the count of its services |
| Quest | a gold badge with the icon of its state: available, in progress, locked or completed; locked and done fade; a quest the player can take bobs |
| Talk target | a round gold-rimmed badge with the chat icon on the corner of an NPC an active talk objective names |
| Entry spawn | a green hexagon with a ring and the home icon on its cell; only the own player draws over it |
| Passive bot | a light circle |
| Hostile bot | a red triangle, over the other bots and resources |
| Resource | a green square |
| Quest target | gold corner brackets around the mark; the followed destination in focus adds a slow halo |
| Route | a wide amber line with a dark outline over each portal of the route, an arrow at each arrival and an amber ring around each gate it uses |
A place is a cell with actions or quests: it has one mark, an action pin with its quest badge on the corner, and the badge shows the count of its quests. A cell with neither is a placed bot or resource. Its class is the one of the server status icons: hostile for a bot whose bound behavior is hostile or, with none, that carries a weapon; passive for any other bot; resource. The action and quest capabilities never replace a class. The gate of a portal always shows; the line of a link across a shared map edge shows only while one of its maps is selected or the portal is in focus.
Each mark takes its screen size from the screen size of one map cell (map_marker_size): its minimum while a cell is 2 px or less, its maximum from 12 px, and an even ramp between. Zoom moves a mark with its map; it never grows a mark past its maximum. A bot or a resource keeps 7 to 13 px, a gate a radius of 7 to 12 px, an action pin 16 to 28 px, a quest badge and a talk badge 20 to 28 px, the entry spawn 18 to 26 px and the own player a radius of 7 to 12 px. The minimap draws each mark at its minimum. Far out, bots and resources of one class that overlap on screen draw as one mark with a count beside it; a tap on a group zooms in on it. The selected mark never joins a group.
A portal is in focus while it is selected or hovered. Its link turns bright with a pulse, its destination cell takes a frame and its destination map an outline; while a portal is selected, the other links fade. A touch shows no hover.
A selected map shows the shortest known portal route to it from the player's map; with no selection, the route goes to the destination in focus of the followed objective. data/map_route searches the portal graph breadth first in portal order: the fewest portals win, and among equal routes the one whose portals come first in the world's portal list. A portal is travelled only the way it leads, and maps change only through portals. A random portal still leads to its map, so a route can pass it, but the view never names its arrival cell. The tree is built again only when the player's map or the world graph changes; the route marks only when its map or the tree changes. A map with no known route shows none, and its card says so; the player's own map needs none.
Each gate in view takes a destination label: an arrow, the map and the cell it leads to (East Market (1, 8)), This map (x, y) inside one map, or - random cell. A fixed entry spawn in view takes the label ENTRY SPAWN: Sap-Logic Array (35, 55). A quest giver takes the first quest the player can take there (NEW QUEST: Strata Patrol), and each quest target what the player does there (DEFEAT elara-voss-kalu, TALK TO Jiro, BUY/ASSEMBLE potion). Once the cells read (9 px a cell, where the player's tag shows), each NPC takes the label of its action, and each bot and resource its item and its stat sum as placed (elara-voss-kalu [stack] 44), in the colour of its class; a selected bot or resource takes it at any zoom. Labels take their places in this order:
- the destinations of the followed objective, the one in focus at any zoom;
- the quests the player can take, and the NPCs a
talkobjective names; - the portal in focus and the portals of the route;
- the entry spawn and the selected bot or resource;
- the other quest targets;
- the NPCs, then the bots and the resources;
- the portals of the player's map and of the selected map, then the rest.
A label takes the first free side of its mark and never covers a mark, a name plate, the player, the detail card, the OBJECTIVE button or another label; a placement takes one label. The followed destination in focus, the portals of the route and the entry spawn lead: when no side is free, they may cover bots and resources.
A tap selects a map, a portal, a place, a bot, a resource or the entry spawn. The header shows where the player is (YOU: map (x, y)), apart from what the view inspects. The detail card shows the selection:
- Map: the sector and its size, the route from the player's map (
ROUTE: 2 PORTALS - TAKE (35, 38): the portals and the cell of the first one,ROUTE: YOU ARE HEREorNO KNOWN FIXED ROUTE FROM YOUR MAP), the portals and the maps they link, where the portals lead, the services its actions configure, its quest givers, FOR YOU: the quests and services open to the player now, one line per class with the count of bots and resources it places, and the entry spawn: its cell on its own map, or on every map when it is random or unresolved. - Portal: FROM the map and the cell, TO the destination, its kind, and the return portal of the destination map when there is one.
- Place: a row per quest, then per action; a row opens one, and a single item opens at once.
- Action: its code and place, each configured service with its icon, the quests it fronts with their state, and FOR YOU when it is open now. A configured service is not an open one: the interaction modal and the server decide.
- Quest: its code and place, the player's state, the prerequisites with the done ones marked, the description, the current step or the first one, the rewards, and the quests of this world it unlocks. The metadata comes from
quest_cacheon selection. - Bot or resource: its item as the title, its class, its stat sum as placed, its map and cell, and that the mark is its placement: a bot moves in play, a resource stays on its cell.
- Entry spawn: its map and cell, or a random cell; that new players enter there, that saved players return to their last cell and that a defeat revives in place.
- Objective: the followed quest objective with the count the server keeps and its step, how many places it has (
ALL 3 PLACES - NEAREST FIRST, orPLACES 7-12 OF 27 - NEAREST FIRSTfor one page), then one row per destination of the page with its portal hops and its way (1 PORTAL - LOOT (1, 2) Amethyst Foliage Expanse); a row puts that destination in focus,MORE: 13-18 OF 27shows the next page andBACK TO NEARESTthe first, and the last row stops following. A page holds as many rows as the card has room for, and the page that opens holds the destination in focus.
A map card also counts the quest objectives it holds, and the card of a bot, a resource or an NPC names the objectives it serves.
The placed counts and the marks are authored content, never live entities: the steady population of each map. The engine counts each placed entity once; the marks show one per cell, with the higher class where two share a cell.
The entry spawn follows the server rule for a new player. The engine resolves the config of the world (playerSpawn) into one of three modes. Fixed: the config names a map of the world and a cell on its grid; the server uses that cell while it is walkable, else a random cell. Random: the config asks for it or names no map; the server uses a random walkable cell of a random map, and the view names no cell. Unresolved: the config names a map out of the world or a cell off its map; the server uses a random cell, and the card says so. A player with a saved position returns there. A defeat never moves a player: it revives where it fell, so the entry spawn is no revive point.
The player's state of a quest follows the server rule: active or completed from the quest store; else available when every prerequisite is completed, else locked. A failed quest can be taken again. A detail card keeps 20 px from the canvas edges and stays under the header.
data/quest_target resolves where the player can advance each actionable objective: the objectives of the step an active quest is on whose count is under the required one. It reads the counts the server keeps (stepId and objectives of each quest snapshot) and the authored placements of the world payload; it never decides progress.
| Objective | Its destinations: the cells of this world with |
|---|---|
kill |
a mortal bot that wears the skin the objective names (an immortal provider never counts) |
talk |
a bot that wears that skin; the NPC takes the label of its action |
collect |
a drop of what is placed there, or a shop that sells or an assembly that makes the item |
Destinations come nearest first: those a portal route from the player's map reaches, by portal hops, then in map and cell order. An objective is found, unreachable (its cells lie on maps no known portal route reaches), absent (no such bot in this world) or without a source (nothing in this world gives the item); it waits while the world map loads. The world payload names placements of this world only: a target in another world reads as absent.
The Quest Journal lists, under the current step of each active quest, its code and world, and each objective with its count and where it leads (2 places - nearest Gate (3, 4), Not in this world). An objective that leads somewhere has a LOCATE button: a 92 × 30 px button with the target icon and its word, centred in a tap band that is the full height of the objective and at least 44 px. LOCATE follows the objective and opens the WORLD view on its card and its nearest destination, centred close up (a map cell of 14 px); the route to a destination on another map shows. The followed objective reads FOLLOWING; its button opens the view on the destination in focus again, never on a nearer one. The objective card pages through every destination; a row puts its destination in focus, and a destination the player picks stays in focus while it serves the objective. On the card of a cell, the row of an objective follows it with that cell in focus. While the objective card is away, an OBJECTIVE button in the bottom right corner of the view brings it back. The followed quest keeps the focus on its next objective when one is done, and stops when the quest ends. A world rebuild resolves the destinations again from the new payload.
The own player holds the first bubble of the interaction column. A tap opens the own profile; a tap on another player opens its public profile; an NPC keeps its capability tabs (player identity and profile).
| Module | Owns |
|---|---|
ui/save_status |
The one line under the toolbar that says how far an account player's progress is saved, from the durability the server reports |
ui/player_panel |
The Profile tab of any player, and the Friends, Requests and Party views of the social panel |
ui/container_panel |
The grid of the open container, an NPC vault or the personal storage: one cell per slot, locked cells |
ui/stack_move |
How a dropped stack lands in the bar and the containers, with the quantity picker |
sim/container_ops |
The item move rules, applied at once and replayed after each snapshot |
ui/trade_panel |
The Trade tab of a player and the request prompt: both offers, the confirmations, Cancel and Confirm |
ui/merchant_panel |
The Buyback and Salvage tabs of a merchant: payout or fee per unit, salvage, units held |
ui/world_drop |
A stack dropped on the ground: the target ring, the reach, the quantity prompt |
world/economy |
The economy the server sent: fees, wallet maximum and the policy of each item |
ui/chat_log |
The chat history by conversation, and the unread counts |
ui/chat_pane |
One conversation in a content rect: its lines, the emoji menu and Send; every pane shares the one DOM text input |
ui/chat_panel |
The HUD chat: World, Party and Direct in the whole right-hand column, with the unread badges |
ui/social_panel |
The social panel: Friends, Requests and Party in the whole right-hand column, opened by the social button |
ui/hud_panel |
The chrome of the column panels: fill, border, the header row of tabs and the close button |
ui/ui_tabs |
The tab group of every panel: equal tabs in rows of at most four, shared evenly; icons show only while every tab fits them |
ui/emoji |
Emoji tokens in a chat line: the icon of each token, wrapped with the words |
ui/identity_icon |
The icon of a player in social views: the latest identity preview of its name, else the default icon |
ui/session_gate |
The session card and the settings card: why a session ended or was refused, the portal, sound and full-screen rows, each way on |
- The inventory bar shows every cell the capacity rule can open: stacks, open slots, then locked
slots with the
lockicon and their level (inventory capacity). Each cell is a bag slot; a tap opens a stack and a drag moves it (moving stacks). A drag onto the own offer of an open trade offers it; a drag onto the world drops it on the ground (off-chain economy). The item card equips and unequips the stack it shows, and drops it, or offers it while a trade is open. - The toolbar row reads
[chat][social][quest][map][settings]; settings (theengineicon) is the rightmost button. It opens the settings card: CYBERIA PORTAL leaves for the portal, SOUND ON or OFF and FULL SCREEN ON or OFF act at once, then the other ways out of the session. The chat button carries the unread count of every conversation and opens the HUD chat. The social button (friendsicon) carries the friend requests and party invites to answer and opens the social panel. Neither opens a modal. Party shows thepartyicon everywhere: the chat tab, the profile row, the invite buttons, the mark over a party member and the invite on a bubble. - A pending party invite never blocks play: the own bubble counts invites and the inviter's bubble carries the party mark (chat and parties).
- The shop and the assembler show "Bag full" on a card whose result has no free slot.
To check a change, use a desktop browser and a phone (or touch emulation):
- Tap the own bubble. The own profile opens on Profile, with Storage and Stats. No dialogue opens.
- Open Storage. Drag a stack from the bar into an open cell and back. A locked cell turns the drop back and, on a tap, names its level.
- Tap a locked bag slot. A toast names the level that opens it.
- With two clients, open the other player's profile and invite it. Accept from the Party tab of the other client's social panel. Both Party tabs list two members.
- Open the HUD chat. Send on World and on Party; type WASD into the input: the player does not move.
- Close the other client. The party ends on the first client.
- On an account world, add the other player as a friend and accept. Both nameplates show a heart;
a direct line with
:smile:shows the icon in the chat and in the bubble preview. - Open the world in a second tab. The first tab shows the session card with PLAY HERE.
Every living entity's overhead HUD shows [stats] lv.<level> and [stack] <stats sum> above its nameplate, and a gold XP bar under its HP bar. The local player's bar fills with its progress through the current level and carries an XP n / m label in a smaller font; entities whose XP the client cannot read show an empty, unlabeled bar.
A destructible obstacle shows only the HP bar, filled from the life and maxLife of its snapshot, and only while it stands. An ordinary obstacle sends maxLife 0 and shows none. A depleted obstacle draws its dead items, or nothing when it has none.
The Stats tab of the interact modal draws one shared stat panel per block: the stats icon, the signed sum, and a two-column grid with one icon per stat. Every entity gets its effective stats. The local player also gets the OL modifiers, base stats, and temporary modifiers from the self snapshot. The inventory modal draws the same panel for one item.
An XP award floats as gold +N XP combat text over the earner only. A server level increment triggers a LEVEL UP aura: shaded gold sparks stream from the entity's feet up past its head for 3 s under a spinning star and a label, and the whole effect follows the entity as it moves, for any entity in view. First sight, repeated snapshots, and lower levels do not trigger it.
An item_consume event whose behavior is consume-on-pickup-heal triggers the heal aura on the consumer: shaded green sparks turn on a ring around its feet while more sparks and pixel plus marks rise through its body for 1.8 s, following the entity. It plays for a world loot pickup and for a held unit the zero-waste heal consumes alike, for any entity in view. Any other behavior triggers nothing.
A player standing on a portal shows a blue transport bar at the top of its overhead stack, with Transporting... centered inside. The teleport charge fills it. While the charge runs, shaded blue sparks circle the player's feet and climb a spiral through its body; the charge raises the column and adds sparks, so the aura gathers as the jump nears. The snapshot carries onPortal and portalHoldProgress for every player, so every viewer sees both on every player in view.
Every damage combat_text throws a hit burst at its point: a few shaded red sparks jump up, fall back and shrink away in under half a second. It marks each hit, a projectile on any entity in view above all, without hiding the fight.
A defeat of a player or bot triggers the death cue: shaded red sparks burst out of the body and fall while a skull icon rises over it for 2.6 s, following the body. It fires once, when an entity seen alive in the prior snapshot is dead in this one. An entity first seen dead, or still dead, triggers nothing. A resource is extracted, not slain: it goes straight to its extracted state with no cue.
While either cue runs, the entity's whole overhead stack, presence icon included, yields the space to it and returns when the cue ends.
The cues are visual only. Their sounds arrive as audio_event messages the server broadcasts to every player whose area of interest covers the event, so a defeat, an extraction, or a level gained sounds the same for everyone in reach. The client plays the id through the map's audio bindings.
Item slots badge an object layer with the stack icon and its signed stat sum, red when negative.
An inventory slot whose item has automatic skills shows, above the slot, the entity each one summons. The init_data skill map names the entity (summonedEntityItemId; $active_skin is the player's active skin), and each metadata delta replaces the skills of the definitions it carries, and the preview draws it as the stack the server spawns, through the same stack icon renderer as the rest of the UI. The slot keeps the trigger item's own icon. Distinct entities share one row, up to three. Each preview carries the quantity badge of the units the player holds of its entity; a slot that summons its own item counts the units of that stack alone. An automatic skill runs by itself on every held stack, so it shows over an inactive slot too. A manual skill shows in the combat controls, never over the bar.
One bar under the row shows the consume cooldown from self.consumeReadyInMs. The row takes no input and hides while the player is in stasis.
A consumable has no Use button. Its automatic skill, zero-waste-auto-consume-heal, consumes one unit by itself once the missing life takes the whole heal. Over a consumable slot the preview shows the item itself with the units left in that stack. The server spends one stack at a time, in slot order, so the counts drop on one stack, then on the next. The inventory modal follows its stack by slot, then by item id, so it closes when the last unit is consumed.
The server sends six values in canonical order. The client displays these values and uses the supplied movement speed.
cd cyberia-client
# Development build (BUILD_MODE=DEBUG)
make -f Web.mk clean && make -f Web.mk all
# Release build
make -f Web.mk clean && make -f Web.mk all BUILD_MODE=RELEASE
# Serve it against a local engine and game server
CYBERIA_WS_ORIGIN=ws://localhost:8083 python3 wasm-driver.py --port=8082 --directory=bin \
--data-server-url=http://localhost:4004BUILD_MODE picks debug or release code only. No server URL is a build argument — see
Compile-time configuration.
The build is part of the Underpost Platform static + PWA pipeline; production deploys go through underpost client and underpost deploy.
bin/
index.html — Emscripten HTML container (from shell.html template)
index.wasm — Compiled WebAssembly module
index.js — Emscripten JS glue
index.data — Preloaded data bundle
No server URL is compiled in. The websocket origin has one source:
CYBERIA_WS_ORIGIN, which wasm-driver.py injects as window.CYBERIA_WS_ORIGIN.
The client dials <origin>/ws for the default world and <origin>/<instance>/ws
for any other. instance-build-manifest writes the value of each environment to
the instance env (origins).
The Data Server URL is a command line argument, not a build argument:
wasm-driver.py --data-server-url=<origin>
-> window.CYBERIA_ARGV -> Module.arguments -> main(argc, argv)
config_init() reads --data-server-url=<origin> from argv. Both values are
required: wasm-driver.py refuses to start without them, and the client stops
with a log line if one is absent. There is no fallback, no config file and no
runtime override.
wasm-driver.py appends any other flag to the client argv. fetch_init() reads
two stream diagnostics:
| Flag | Effect |
|---|---|
--stream-disable=<mode>[,<mode>...] |
Turns off audio, audio-network, audio-runtime, atlas or dynamic streaming. |
--stream-profile |
Records stream events in Module.streamTrace (30,000-entry ring, read in DevTools). |
| Constant | Default | Description |
|---|---|---|
CYBERIA_CLIENT_HINTS_CODE |
cyberia-main |
Lookup key for the optional client-hints fetch (presentation override key — never an instance/server identifier) |
MAX_TEXTURE_CACHE_SIZE |
512 |
Atlas texture LRU cap |
MAX_LAYER_CACHE_SIZE |
256 |
ObjectLayer metadata LRU cap |
MAX_ATLAS_CACHE_SIZE |
256 |
Atlas metadata LRU cap |
DEFAULT_FRAME_DURATION_MS |
100 |
Default animation frame duration |