Zloy Backend

{
  "version": 1,
  "cubes": {
    "lobby": {"cube": "room", "props": {"capacity": 8, "min_start": 8}},
    "chat":  {"cube": "chat"}
  },
  "links": [
    {"from": "lobby.onJoin", "to": "chat.announce",
     "with": {"channel": "room", "room": "{room}",
              "text": "{name} вошёл"}}
  ],
  "ui": {
    "lobby": {"x": 40,  "y": 40},
    "chat":  {"x": 320, "y": 40}
  }
}

{
  "cubes": {
    "hall":  {"cube": "room",
              "props": {"capacity": 64, "min_start": 64}},
    "lobby": {"cube": "room",
              "props": {"capacity": 8, "min_start": 8,
                        "auto_start": true}},
    "chat":  {"cube": "chat", "props": {"rate_per_10s": 5}}
  }
}

# Общий холл: просто попасть куда-нибудь
send_op("hall", "quick")

# Боевая комната на восьмерых
send_op("lobby", "quick")
send_op("lobby", "ready", {"v": true})

// Общий холл: просто попасть куда-нибудь
await zloy.rt.op('hall', 'quick');

// Боевая комната на восьмерых
const {room} = await zloy.rt.op('lobby', 'quick');
await zloy.rt.op('lobby', 'ready', {v: true});

const hall = await zloy.rt.op<{room: string}>('hall', 'quick');
const game = await zloy.rt.op<{room: string; slot: number}>('lobby', 'quick');

await zloy.rt.op('lobby', 'ready', {v: true});

{
  "channel": "room",
  "room": "{room}",
  "text": "{name} вошёл в комнату"
}

func _on_event(env: Dictionary) -> void:
    if env.cube == "chat" and env.op == "message":
        var m: Dictionary = env.payload
        if m.kind == "SYSTEM":
            chat_log.add_system(m.text)
        else:
            chat_log.add_line(m.from.name, m.text)

zloy.rt.on('chat', 'message', (m) => {
  if (m.kind === 'SYSTEM') addSystemLine(m.text);
  else addPlayerLine(m.from.name, m.text);
});

// Лента после входа второго игрока:
//   SYSTEM  Алиса вошла в комнату
//   SYSTEM  Все в сборе — начинаем!
//   PLAYER  Алиса: погнали

interface ChatMessage {
  channel: string;
  room?: string;
  from: {user_id: number; name: string} | null;  // null у системных
  kind: 'PLAYER' | 'SYSTEM';
  text: string;
  ts: number;
}

zloy.rt.on('chat', 'message', (m: ChatMessage) => render(m));

[
  {"from": "lobby.onStart", "to": "match.start"},
  {"from": "lobby.onStart", "to": "timer.after",
   "with": {"sec": 900, "tag": "match_end",
              "data": {"room": "{room}"}}},

  {"from": "timer.fired",   "to": "match.advance"},

  {"from": "match.result",  "to": "board.submit",
   "with": {"board": "kills"}},
  {"from": "match.ended",   "to": "lobby.close",
   "with": {"room": "{room}"}},

  {"from": "lobby.onEmpty", "to": "timer.cancel",
   "with": {"tag": "match_end"}},
  {"from": "lobby.onEmpty", "to": "bank.refund",
   "with": {"room": "{room}"}}
]

{
  "version": 1,
  "cubes": {
    "lobby": {"cube": "room",
              "props": {"capacity": 8, "min_start": 8,
                        "auto_start": true}},
    "chat":  {"cube": "chat"},
    "timer": {"cube": "timer"},
    "match": {"cube": "session", "props": {"min_players": 8}},
    "board": {"cube": "board", "props": {"client_submit": false}}
  },
  "links": [
    {"from": "lobby.onJoin",  "to": "chat.announce",
     "with": {"channel": "room", "room": "{room}",
              "text": "{name} в комнате"}},
    {"from": "lobby.onStart", "to": "chat.announce",
     "with": {"channel": "room", "room": "{room}",
              "text": "Матч начался — 15 минут!"}},
    {"from": "lobby.onStart", "to": "match.start"},
    {"from": "lobby.onStart", "to": "timer.after",
     "with": {"sec": 900, "tag": "match_end",
              "data": {"room": "{room}"}}},
    {"from": "timer.fired",   "to": "match.advance"},
    {"from": "match.result",  "to": "board.submit",
     "with": {"board": "kills"}}
  ]
}

func _ready() -> void:
    _connect()          # см. раздел «Подключение»

func _on_connected() -> void:
    send_op("lobby", "quick")

func _on_event(env: Dictionary) -> void:
    match [env.cube, env.op]:
        ["chat", "message"]:
            chat_log.add(env.payload)
        ["room", "state"]:
            lobby_ui.update(env.payload)     # кто в комнате, кто готов
        ["session", "phase"]:
            hud.set_deadline(env.payload.ends_at)
        ["session", "ended"]:
            show_results(env.payload.result)

func _on_ready_pressed() -> void:
    send_op("lobby", "ready", {"v": true})

await zloy.rt.connect();
await zloy.rt.op('lobby', 'quick');

zloy.rt.on('chat', 'message', (m) => chat.add(m));
zloy.rt.on('lobby', 'state', (s) => lobbyUi.update(s));

// Матч: сервер сам скажет, когда начался и сколько осталось
zloy.rt.on('match', 'phase', (p) => hud.setDeadline(p.ends_at));
zloy.rt.on('match', 'ended', (p) => showResults(p.result));

readyBtn.onclick = () => zloy.rt.op('lobby', 'ready', {v: true});

interface PhasePayload { room: string; phase: string; round: number; ends_at: number }
interface EndedPayload { room: string; result: Record<string, unknown> }

await zloy.rt.connect();
await zloy.rt.op('lobby', 'quick');

zloy.rt.on('match', 'phase', (p: PhasePayload) => hud.setDeadline(p.ends_at));
zloy.rt.on('match', 'ended', (p: EndedPayload) => showResults(p.result));

// Таблица рекордов — обычное чтение, писать в неё игра не может
const top = await zloy.rt.op<{rows: BoardRow[]}>('board', 'top', {board: 'kills', limit: 20});

Вы:
Сделай лобби на 8 человек с чатом: объявляй вход и выход,
матч на 15 минут, результат — в таблицу рекордов.

Агент:
→ backend_cubes
→ add_backend_cube  {cube: "room",    instance: "lobby",
                     props: {capacity: 8, min_start: 8}}
→ add_backend_cube  {cube: "chat"}
→ add_backend_cube  {cube: "timer"}
→ add_backend_cube  {cube: "board",
                     props: {client_submit: false}}
→ link_backend_cubes {from: "lobby.onJoin", to: "chat.announce",
                      with: {channel: "room", room: "{room}",
                             text: "{name} в комнате"}}
→ link_backend_cubes {from: "lobby.onStart", to: "timer.after",
                      with: {sec: 900, tag: "match_end"}}
Готово: 4 кубика, 3 связи. В превью — сразу, в прод — с публикацией.

# Godot 4: WebSocketPeer + параметры из адреса страницы
extends Node

var ws := WebSocketPeer.new()
var seq := 0

func _ready() -> void:
    var q := JavaScriptBridge.eval("location.search.slice(1)", true)
    ws.connect_to_url("wss://api.zloy.net/rt/ws?" + str(q))

func _process(_dt: float) -> void:
    ws.poll()
    while ws.get_available_packet_count() > 0:
        var env: Dictionary = JSON.parse_string(
            ws.get_packet().get_string_from_utf8())
        _on_event(env)

func send_op(cube: String, op: String, payload: Dictionary = {}) -> int:
    seq += 1
    ws.send_text(JSON.stringify({
        "cube": cube, "op": op, "seq": seq, "payload": payload,
    }))
    return seq

func _on_event(env: Dictionary) -> void:
    match env.get("op"):
        "hello":
            print("я игрок ", env.payload.user_id,
                  ", кубики: ", env.payload.cubes)

<script src="https://zloy.net/assets/zloy-sdk.js"></script>
<script>
  // SDK сам берёт подписанные параметры из адреса страницы
  zloy.rt.connect();

  zloy.rt.on('', 'hello', (p) => {
    console.log('я игрок', p.user_id, 'кубики:', p.cubes);
  });

  // Вызов операции — промис с ответом сервера
  const rooms = await zloy.rt.op('room', 'list');
</script>

import 'https://zloy.net/assets/zloy-sdk.js';

declare const zloy: {
  rt: {
    connect(): void;
    close(): void;
    connected(): boolean;
    on(cube: string, op: string, fn: (payload: any) => void): void;
    op<T = any>(cube: string, op: string, payload?: object): Promise<T>;
    onReconnect: ((hello: HelloPayload) => void) | null;
  };
};

interface HelloPayload {
  user_id: number;
  name: string;
  env: 'dev' | 'prod';
  cubes: string[];
}

zloy.rt.connect();
zloy.rt.on('', 'hello', (p: HelloPayload) => {
  console.log('я игрок', p.user_id, 'кубики:', p.cubes);
});

# запрос
{"cube": "room", "op": "join", "seq": 7, "payload": {"code": "AB12CD"}}

# ответ (тот же seq)
{"cube": "room", "op": "joined", "seq": 7, "payload": {"room": "r1"}}

# событие (seq = 0, приходит само)
{"cube": "room", "op": "state", "seq": 0, "payload": {"room": {...}}}

# ошибка
{"cube": "room", "op": "error", "seq": 7,
 "payload": {"code": "room_full", "message": "комната заполнена"}}

// Промис завершится ответом с тем же seq
try {
  const r = await zloy.rt.op('room', 'join', {code: 'AB12CD'});
  console.log('вошли в', r.room);
} catch (e) {
  console.warn('не вышло:', e.code, e.message);
}

// События — подпиской
zloy.rt.on('room', 'state', (p) => render(p.room));

interface RoomJoined { room: string }
interface RtError { code: string; message: string }

try {
  const r = await zloy.rt.op<RoomJoined>('room', 'join', {code: 'AB12CD'});
  console.log('вошли в', r.room);
} catch (e) {
  const err = e as RtError;
  console.warn('не вышло:', err.code, err.message);
}

zloy.rt.on('room', 'state', (p: {room: RoomState}) => render(p.room));

func _on_event(env: Dictionary) -> void:
    if env.get("op") == "error":
        var p: Dictionary = env.payload
        match p.code:
            "rate_limited": _show("Слишком часто, подождите")
            "room_full":    _show("Комната заполнена")
            _:              push_warning("ошибка: %s" % p.message)

zloy.rt.op('chat', 'send', {text}).catch((e) => {
  if (e.code === 'rate_limited') showToast('Слишком часто');
  else if (e.code === 'not_in_room') showToast('Сначала войдите в комнату');
  else console.error(e);
});

type ErrCode = 'rate_limited' | 'not_in_room' | 'no_cube' | 'internal';

zloy.rt.op('chat', 'send', {text}).catch((e: {code: ErrCode}) => {
  if (e.code === 'rate_limited') showToast('Слишком часто');
});

{
  "version": 1,
  "cubes": {
    "lobby": {"cube": "room", "props": {"capacity": 10, "min_start": 4}},
    "chat":  {"cube": "chat", "props": {"rate_per_10s": 5}},
    "save":  {"cube": "store"},
    "bank":  {"cube": "bank", "props": {"allow_bets": true}}
  },
  "links": [
    {"from": "lobby.onJoin", "to": "chat.announce",
     "with": {"channel": "room", "text": "{name} вошёл"}},
    {"from": "lobby.onStart", "to": "session.start"}
  ]
}

{
  "version": 1,
  "cubes": {
    "lobby": {"cube": "room", "props": {"capacity": 10, "min_start": 4}},
    "chat":  {"cube": "chat", "props": {"rate_per_10s": 5}},
    "save":  {"cube": "store"},
    "bank":  {"cube": "bank", "props": {"allow_bets": true}}
  },
  "links": [
    {"from": "lobby.onJoin", "to": "chat.announce",
     "with": {"channel": "room", "text": "{name} вошёл"}},
    {"from": "lobby.onStart", "to": "session.start"}
  ]
}

// Обращение к инстансу — по его имени из манифеста:
await zloy.rt.op('lobby', 'quick');

// Тот же zloy_server.json; в коде инстанс адресуется по имени:
await zloy.rt.op('lobby', 'quick');
await zloy.rt.op('save', 'set', {scope: 'player', key: 'progress', value});

{
  "cubes": {
    "lobby": {"cube": "room", "props": {"capacity": 8, "min_start": 8}},
    "chat":  {"cube": "chat"}
  },
  "links": [
    {"from": "lobby.onJoin",  "to": "chat.announce",
     "with": {"channel": "room", "room": "{room}",
              "text": "{name} вошёл в комнату"}},

    {"from": "lobby.onLeave", "to": "chat.announce",
     "with": {"channel": "room", "room": "{room}",
              "text": "{name} вышел ({reason})"}},

    {"from": "lobby.onFull",  "to": "chat.announce",
     "with": {"channel": "room", "room": "{room}",
              "text": "Все в сборе — начинаем!"}},

    {"from": "lobby.onStart", "to": "chat.announce",
     "with": {"channel": "room", "room": "{room}",
              "text": "Матч начался. Удачи!"}}
  ]
}

// Игра ничего не делает для объявлений — просто слушает чат:
zloy.rt.on('chat', 'message', (m) => {
  // системные приходят с kind: 'SYSTEM' и from: null
  appendMessage(m.kind === 'SYSTEM' ? {...m, system: true} : m);
});

// Вход в комнату — обычная операция; объявление напишет связь
await zloy.rt.op('lobby', 'quick');

// Ожидаемая лента:
//   SYSTEM  Алиса вошла в комнату
//   SYSTEM  Все в сборе — начинаем!
//   PLAYER  Алиса: погнали

interface ChatMessage {
  channel: string;
  from: {user_id: number; name: string} | null;   // null у системных
  kind: 'PLAYER' | 'SYSTEM';
  text: string;
  ts: number;
}

zloy.rt.on('chat', 'message', (m: ChatMessage) => {
  if (m.kind === 'SYSTEM') showSystemLine(m.text);
  else showPlayerLine(m.from!.name, m.text);
});

{
  "links": [
    {"from": "lobby.onStart", "to": "session.start"},
    {"from": "lobby.onStart", "to": "timer.after",
     "with": {"sec": 900, "tag": "match_end",
              "data": {"room": "{room}"}}},

    {"from": "timer.fired",   "to": "session.advance"},

    {"from": "lobby.onEmpty", "to": "timer.cancel",
     "with": {"tag": "match_end"}},
    {"from": "lobby.onEmpty", "to": "bank.refund",
     "with": {"room": "{room}"}}
  ]
}

// То же самое, но глазами игры: она видит только результаты.
zloy.rt.on('session', 'phase', (p) => setPhase(p.phase, p.ends_at));
zloy.rt.on('session', 'ended', (p) => showResults(p.result));
zloy.rt.on('bank', 'changed', (p) => updateBalance(p.balance));

interface PhasePayload {
  room: string; phase: string; round: number; ends_at: number;
}

zloy.rt.on('session', 'phase', (p: PhasePayload) => {
  setPhase(p.phase, p.ends_at);   // ends_at — серверное время окончания
});

# 1. быстрый вход: найдёт незаполненную комнату или создаст новую
send_op("room", "quick")

# 2. состав комнаты приходит событием
func _on_event(env):
    if env.cube == "room" and env.op == "state":
        _render_players(env.payload.room.players)

# 3. готовность и старт
send_op("room", "ready", {"v": true})
send_op("room", "start")          # только хост

# 4. чат комнаты
send_op("chat", "send", {"channel": "room", "text": "Погнали!"})

await zloy.rt.op('room', 'quick');

zloy.rt.on('room', 'state', (p) => renderPlayers(p.room.players));
zloy.rt.on('chat', 'message', (m) => appendMessage(m));

await zloy.rt.op('room', 'ready', {v: true});
await zloy.rt.op('room', 'start');           // только хост

await zloy.rt.op('chat', 'send', {channel: 'room', text: 'Погнали!'});

interface Slot { user_id: number; name: string; ready: boolean;
  connected: boolean; data?: Record<string, unknown> }
interface RoomState { id: string; host_id: number; started: boolean;
  capacity: number; players: Slot[] }

await zloy.rt.op('room', 'quick');
zloy.rt.on('room', 'state', (p: {room: RoomState}) => renderPlayers(p.room.players));

# сохранить прогресс
send_op("store", "set", {"scope": "player", "key": "save",
    "value": {"level": 7, "coins": 120}})

# загрузить при старте
send_op("store", "get", {"scope": "player", "key": "save"})

# общий счётчик сыгранных матчей
send_op("store", "incr", {"scope": "world", "key": "games_played", "by": 1})

# рекорд и таблица
send_op("board", "submit", {"score": 4500})
send_op("board", "top", {"limit": 10})

await zloy.rt.op('store', 'set',
  {scope: 'player', key: 'save', value: {level: 7, coins: 120}});

const {value} = await zloy.rt.op('store', 'get',
  {scope: 'player', key: 'save'});

await zloy.rt.op('board', 'submit', {score: 4500});
const {rows} = await zloy.rt.op('board', 'top', {limit: 10});

interface Save { level: number; coins: number }
interface TopRow { rank: number; user_id: number; name: string; score: number }

await zloy.rt.op('store', 'set',
  {scope: 'player', key: 'save', value: {level: 7, coins: 120} as Save});

const {rows} = await zloy.rt.op<{rows: TopRow[]}>('board', 'top', {limit: 10});

# ставка (op_id обязателен — защищает от двойного списания)
send_op("bank", "bet", {"currency": "gold", "amount": 100,
    "op_id": "bet-%d" % match_id})

# посмотреть котёл
send_op("bank", "pot")

# баланс и выписка
send_op("bank", "balance")
send_op("bank", "statement", {"limit": 20})

await zloy.rt.op('bank', 'bet',
  {currency: 'gold', amount: 100, op_id: `bet-${matchId}`});

const pot = await zloy.rt.op('bank', 'pot');
console.log('в котле', pot.total);

zloy.rt.on('bank', 'changed', (p) =>
  showBalance(p.currency, p.balance, p.delta));

interface Pot { room: string; currency: string; total: number;
  players: Record<string, number> }

await zloy.rt.op('bank', 'bet',
  {currency: 'gold', amount: 100, op_id: `bet-${matchId}`});
const pot = await zloy.rt.op<Pot>('bank', 'pot');

# что вокруг меня: свои сущности целиком, чужие — публичные поля
send_op("session", "view")

# действие мира: посадить пшеницу на грядку
send_op("session", "do", {"action": "plant", "target": "plot-1",
    "params": {"crop": "wheat"}})

# ночью можно украсть у соседа
send_op("session", "do", {"action": "steal", "target": "plot-9"})

# события мира
func _on_event(env):
    if env.cube != "session": return
    match env.op:
        "state":   _render(env.payload.mine, env.payload.others)
        "phase":   _set_phase(env.payload.phase, env.payload.ends_at)
        "private": _show_secret(env.payload.kind, env.payload.data)

const view = await zloy.rt.op('session', 'view');
render(view.mine, view.others, view.phase);

await zloy.rt.op('session', 'do',
  {action: 'plant', target: 'plot-1', params: {crop: 'wheat'}});

zloy.rt.on('session', 'phase', (p) => setPhase(p.phase, p.ends_at));
zloy.rt.on('session', 'private', (p) => showSecret(p.kind, p.data));
zloy.rt.on('session', 'ended', (p) => showResult(p.result));

interface Entity { id: string; type: string; owner: number;
  state: string; ready_at?: number; props: Record<string, unknown> }
interface WorldView { room: string; phase: string; round: number;
  ends_at: number; mine: Entity[]; others: Entity[] }

const view = await zloy.rt.op<WorldView>('session', 'view');
await zloy.rt.op('session', 'do',
  {action: 'plant', target: view.mine[0].id, params: {crop: 'wheat'}});

{
  "version": 1,
  "cubes": {
    "hall":  {"cube": "room",
              "props": {"capacity": 64, "min_start": 64}},
    "lobby": {"cube": "room",
              "props": {"capacity": 8, "min_start": 8,
                        "auto_start": true}},
    "chat":  {"cube": "chat", "props": {"rate_per_10s": 5}},
    "sync":  {"cube": "sync", "props": {"tick_hz": 15,
                                        "max_state_bytes": 256}},
    "match": {"cube": "session", "props": {"min_players": 8}},
    "timer": {"cube": "timer"},
    "board": {"cube": "board",
              "props": {"period": "week", "client_submit": false}}
  },
  "links": [
    {"from": "lobby.onJoin",  "to": "chat.announce",
     "with": {"channel": "room", "room": "{room}",
              "text": "{name} присоединился ({players}/8)"}},

    {"from": "lobby.onStart", "to": "match.start"},
    {"from": "lobby.onStart", "to": "timer.after",
     "with": {"sec": 900, "tag": "match_end",
              "data": {"room": "{room}"}}},
    {"from": "lobby.onStart", "to": "chat.announce",
     "with": {"channel": "room", "room": "{room}",
              "text": "Бой начался! 15 минут."}},

    {"from": "timer.fired",   "to": "match.advance"},

    {"from": "match.result",  "to": "board.submit",
     "with": {"board": "kills"}},
    {"from": "match.ended",   "to": "chat.announce",
     "with": {"channel": "room", "room": "{room}",
              "text": "Бой окончен."}},
    {"from": "match.ended",   "to": "lobby.close",
     "with": {"room": "{room}"}}
  ]
}

// Холл при запуске игры
await zloy.rt.op('hall', 'quick');
zloy.rt.on('chat', 'message', renderChat);

// Список открытых комнат и создание своей
const {rooms} = await zloy.rt.op('lobby', 'list');
await zloy.rt.op('lobby', 'create', {name: 'Ковры 8x8'});
await zloy.rt.op('lobby', 'ready', {v: true});   // 8-й запустит матч сам

// В бою: своё состояние — 15 раз в секунду
setInterval(() => {
  zloy.rt.op('sync', 'set', {state: {x, y, z, yaw, hp, anim}});
}, 66);
zloy.rt.on('sync', 'snapshot', (p) => renderOthers(p.players));

// Попадание засчитывает мир (действие с проверками на сервере)
await zloy.rt.op('match', 'do', {action: 'hit', target: String(victimId)});
zloy.rt.on('session', 'acted', (e) => showKillFeed(e));

// Конец матча
zloy.rt.on('match', 'ended', async (p) => {
  showScoreboard(p.entities);
  await zloy.rt.op('hall', 'quick');            // возвращаемся в холл
});

interface FighterProps { frags: number; deaths: number; hp: number }
interface Fighter {
  id: string; type: 'fighter'; owner: number;
  state: 'alive' | 'dead'; props: FighterProps;
}

// Состояние полёта — маленький объект, 15 раз в секунду
interface FlyState { x: number; y: number; z: number; yaw: number; hp: number }

const tick = () => zloy.rt.op('sync', 'set', {state: flyState as FlyState});

// Мир матча (редактор мира во вкладке «Бекенд»)
{
  "entities": {
    "fighter": {
      "per_user": true,
      "props": {"frags": 0, "deaths": 0},
      "states": ["alive", "dead"],
      "initial_state": "alive",
      "public": ["frags", "deaths"]
    }
  },
  "clock": {"phases": [{"name": "battle", "seconds": 900,
                        "next": "over"},
                       {"name": "over", "seconds": 15,
                        "next": "battle"}]},
  "actions": {
    "hit": {
      "requires": {"state": "alive"},
      "target": {"type": "fighter", "own": false,
                 "state": "alive"},
      "phases": ["battle"],
      "cooldown_sec": 1,
      "public": true,
      "effects": [
        {"op": "state", "to": "dead", "then": "alive", "after": 3},
        {"op": "add", "on": "actor",  "props": {"frags": 1}},
        {"op": "add", "props": {"deaths": 1}},
        {"op": "notify", "event": "killed",
         "data": {"by": "$actor.owner"}}
      ]
    }
  },
  "rules": [
    {"when": "phase_enter", "phase": "over",
     "then": [{"op": "end", "result": "match_over"}]}
  ],
  "score": {"entity": "fighter", "prop": "frags"}
}

// Клиент считает попадание и сообщает серверу
function onProjectileHit(victimId) {
  zloy.rt.op('match', 'do', {action: 'hit', target: String(victimId)})
    .catch((e) => {
      // сервер не засчитал: цель мертва, кулдаун, не та фаза
      if (e.code !== 'bad_target') console.warn(e.code);
    });
}

// Смерть и респавн приходят состоянием сущности
zloy.rt.on('match', 'state', (v) => {
  const me = v.mine.find((e) => e.type === 'fighter');
  if (me.state === 'dead') showRespawnTimer(me.ready_at);
  updateScore(v.mine.concat(v.others));
});

interface WorldView {
  phase: string; ends_at: number;
  mine: Fighter[]; others: Fighter[];
}

zloy.rt.on('match', 'state', (v: WorldView) => {
  const me = v.mine[0];
  if (me.state === 'dead' && me.ready_at) {
    showRespawnIn((me.ready_at - Date.now()) / 1000);
  }
});

# Итоговая таблица приходит в событии ended
func _on_event(env):
    if env.cube == "match" and env.op == "ended":
        var rows := []
        for e in env.payload.entities:
            if e.type == "fighter":
                rows.append({
                    "user": e.owner,
                    "frags": e.props.frags,
                    "deaths": e.props.deaths,
                })
        rows.sort_custom(func(a, b): return a.frags > b.frags)
        _show_scoreboard(rows)
        send_op("hall", "quick")   # обратно в холл

zloy.rt.on('match', 'ended', async (p) => {
  const table = p.entities
    .filter((e) => e.type === 'fighter')
    .sort((a, b) => b.props.frags - a.props.frags);
  showScoreboard(table);

  const top = await zloy.rt.op('board', 'top', {limit: 10});
  showLeaderboard(top.rows);

  await zloy.rt.op('hall', 'quick');   // назад в общий холл
});

interface EndedPayload {
  room: string; result: string; entities: Fighter[];
}

zloy.rt.on('match', 'ended', async (p: EndedPayload) => {
  const table = p.entities
    .filter((e) => e.type === 'fighter')
    .sort((a, b) => b.props.frags - a.props.frags);
  showScoreboard(table);
  await zloy.rt.op('hall', 'quick');
});

# Godot: WebSocketPeer сообщает о закрытии — переподключаемся сами
func _process(_dt):
    ws.poll()
    if ws.get_ready_state() == WebSocketPeer.STATE_CLOSED and not reconnecting:
        reconnecting = true
        await get_tree().create_timer(1.0).timeout
        _connect_and_resync()

func _connect_and_resync():
    ws.connect_to_url(url)
    reconnecting = false
    # после hello — обновляем состояние
    send_op("room", "list")
    send_op("chat", "history", {"channel": "room"})
    send_op("session", "view")

zloy.rt.onReconnect = async () => {
  // связь восстановлена — забираем актуальное состояние
  const [history, view] = await Promise.all([
    zloy.rt.op('chat', 'history', {channel: 'room'}),
    zloy.rt.op('session', 'view'),
  ]);
  restoreChat(history.messages);
  render(view);
};

zloy.rt.onReconnect = async (hello: HelloPayload): Promise<void> => {
  const view = await zloy.rt.op<WorldView>('session', 'view');
  render(view);
};