Games — Cookbook

import { Games } from "@clutchcall/sdk/games";

from clutchcall.games import Games

const me = new Games({
  relayHost: "relay.clutchcall.dev",
  token:     await fetchRoomToken("duel-42", "alice"),
  roomId:    "duel-42",
  playerId:  "alice",
});

me = Games(
    relay_host="relay.clutchcall.dev",
    token=await fetch_room_token("duel-42", "alice"),
    room_id="duel-42",
    player_id="alice",
)

const auth = new Games({ relayHost, token, roomId: "duel-42" }); // no playerId

auth = Games(token=tok, room_id="duel-42")   # no player_id

const state = await auth.publishState({ tickHz: 30 });
setInterval(() => state.write(serializeWorld(world)), 1000 / 30);

import asyncio
state = auth.publish_state(tick_hz=30)
async def loop():
    while True:
        state.write(serialize_world(world))
        await asyncio.sleep(1 / 30)

await me.subscribeState((bytes) => render(deserializeState(bytes)));

me.subscribe_state(lambda data: render(deserialize_state(data)))

const input = await me.publishInput();
addEventListener("tick", () => input.write(serializeInput(localInput)));

inp = me.publish_input()
inp.write(serialize_input(local_input))

await auth.subscribeInputs((playerId, bytes) => {
  applyInput(playerId, deserializeInput(bytes));
});

auth.subscribe_inputs(lambda pid, data: apply_input(pid, deserialize_input(data)))

const chat = await me.publishEvent({ channel: "chat" });
chat.write(serialize({ text: "gg" }));

chat = me.publish_event(channel="chat")
chat.write(serialize({"text": "gg"}))

await me.subscribeEvents({ channel: "chat" }, (fromPlayerId, bytes) => {
  appendChat(fromPlayerId, deserialize(bytes));
});

me.subscribe_events(
    channel="chat",
    on_event=lambda pid, data: append_chat(pid, deserialize(data)),
)

const chat   = await me.publishEvent({ channel: "chat" });
const rpc    = await me.publishEvent({ channel: "rpc.use_item" });

await me.subscribeEvents({ channel: "chat" },        onChat);
await me.subscribeEvents({ channel: "rpc.use_item" }, onItemRpc);

chat = me.publish_event(channel="chat")
rpc  = me.publish_event(channel="rpc.use_item")

me.subscribe_events(channel="chat",         on_event=on_chat)
me.subscribe_events(channel="rpc.use_item", on_event=on_item_rpc)

const settle = await auth.publishEvent({ channel: "match.result" });
settle.write(serialize({ winner: "alice", score: [3, 1] }));

settle = auth.publish_event(channel="match.result")
settle.write(serialize({"winner": "alice", "score": [3, 1]}))

const events = await me.publishEvent({ channel: "chat" });
events.write(serialize(urgentLine), 90);   // higher than default 50

events = me.publish_event(channel="chat")
events.write(serialize(urgent_line), priority=90)

const me = new Games({
  relayHost, token, roomId: "duel-42", playerId: "alice",
  onState: (s) => {
    if (s === 1) showOnline();
    if (s === 2) showReconnecting();
  },
});

me = Games(
    token=tok, room_id="duel-42", player_id="alice",
    on_state=lambda s, reason=None: (
        show_online() if s == 1 else show_reconnecting() if s == 2 else None
    ),
)

const sub = await me.subscribeEvents({ channel: "chat" }, onChat);
sub.close();   // stop receiving chat; input/state stay live

sub = me.subscribe_events(channel="chat", on_event=on_chat)
sub.close()

await me.close();

me.close()

if (new TextEncoder().encode(playerId).length > 255) {
  throw new Error("player id too long");
}

if len(player_id.encode("utf-8")) > 255:
    raise ValueError("player id too long")