0xDocs 0x.limo

Docs / JavaScript SDK

@0xlimo/net API

Generated from the typings of @0xlimo/net 0.1.2: every exported type, class and function.

Generated from @0xlimo/net typings at build 3a4a58e45c+dirty. Do not edit by hand.

Typings: src/index.d.ts. For concepts and examples see the package guide.

#@0xlimo/net

js
import { ... } from "@0xlimo/net";

#PlayerId

type

Player ids are u64 as decimal strings; tickets 16 bytes as hex.

ts
type PlayerId = string;

#ServiceServer

interface

The game server's side of the 0x1 broadcast service.

ts
interface ServiceServer {
  /** Add or move a player (one group at a time). */
  register(player: PlayerId, group: number, ticket: string | Uint8Array): void;
  unregister(player: PlayerId): void;
  /** One copy per group; the service fans it out, in order, minus `except`. */
  broadcast(group: number, channel: number, data: Uint8Array, except?: PlayerId[]): void;
  unicast(player: PlayerId, channel: number, data: Uint8Array): void;
  flush(): void;
  on(ev: "up" | "down", fn: (player: PlayerId) => void): () => void;
  on(ev: "from", fn: (player: PlayerId, channel: number, data: Uint8Array) => void): () => void;
  off(ev: string, fn: (...a: any[]) => void): void;
  close(): void;
}

#ServicePlayer

interface

A player's side: what the service delivers, and messages to the game server.

ts
interface ServicePlayer {
  readonly player: PlayerId;
  on(ev: "data", fn: (channel: number, data: Uint8Array) => void): () => void;
  on(ev: "close", fn: () => void): () => void;
  off(ev: string, fn: (...a: any[]) => void): void;
  send(channel: number, data: Uint8Array): void;
  close(): void;
}

#connectMeshPlayer

function

The service's own player client (wasm): WebRTC links to other players, broadcasts through its trees.

ts
function connectMeshPlayer(o: {
  url: string; player: PlayerId; ticket: string;
  wasm: { WasmClient: unknown };
  /** Join the player trees over WebRTC (default false: every broadcast direct from the service). */
  mesh?: boolean;
  rtcConfig?: RTCConfiguration; WebSocket?: unknown; RTCPeerConnection?: unknown; retries?: number; timeoutMs?: number;
}): Promise<ServicePlayer & { stats(): { direct: number; fanout: number; framesFromPeers: number; badFrames: number; links: number } }>;

#loadBroadcastWasm

function

Loads and initialises the wasm client from base (…/x1/net/wasm/).

ts
function loadBroadcastWasm(base: string): Promise<{ WasmClient: unknown }>;

#JoinTicket

interface

ts
interface JoinTicket {
  player: PlayerId;
  ticket: string;
  url: string;
}

#createMemoryService

function

ts
function createMemoryService(): {
  server(): ServiceServer;
  player(o: { player: PlayerId; ticket: string }): Promise<ServicePlayer>;
  stats(): { broadcasts: number; unicasts: number; delivered: number; serverBytes: number; refused: number; players: number };
};

#connectServiceServer

function

Without url: the hosted service from X1_BCAST_TOKEN (+ X1_BCAST_INSTANCE, X1_BCAST_URL, X1_BCAST_PLAYER_URL).

ts
function connectServiceServer(o?: { url?: string; token?: string | Uint8Array; WebSocket?: unknown; timeoutMs?: number }): Promise<ServiceServer & { playerUrl?: string }>;

#HOSTED_BCAST

const

ts
const HOSTED_BCAST: { server: string; player: string };

#hostedService

function

ts
function hostedService(env?: Record<string, string | undefined>): { url: string; playerUrl: string; token: string } | null;

#connectServicePlayer

function

ts
function connectServicePlayer(o: { url: string; player: PlayerId; ticket: string; WebSocket?: unknown; retries?: number; timeoutMs?: number }): Promise<ServicePlayer>;

#groupId

function

A room or match name as the service's u32 group id (FNV-1a).

ts
function groupId(name: string): number;

#newPlayer

function

ts
function newPlayer(): { player: PlayerId; ticket: string };

#CHANNEL_SOCKETIO

const

ts
const CHANNEL_SOCKETIO: number;

#CHANNEL_COLYSEUS

const

ts
const CHANNEL_COLYSEUS: number;

#routeSocketIoBroadcasts

function

ts
function routeSocketIoBroadcasts(
  io: unknown,
  o: {
    service: ServiceServer;
    /** The service's player endpoint, handed to clients. */
    playerUrl?: string;
    /** Which rooms are interest groups (a player is in one at a time). Default: none, the namespace is the group. */
    groups?: (room: string) => boolean;
    events?: string[] | ((ev: string) => boolean);
    channel?: number;
  },
): { stats(): { routed: number; copies: number; socketio: number; direct: number; players: number } };

#x1SocketIo

function

ts
function x1SocketIo<S>(socket: S, o?: { connect?: (j: JoinTicket) => Promise<ServicePlayer>; url?: string; channel?: number }): S;

#routeColyseusBroadcasts

function

ts
function routeColyseusBroadcasts(
  room: unknown,
  o: { service: ServiceServer; playerUrl?: string; types?: Array<string | number> | ((t: string | number) => boolean); channel?: number },
): { group: number; stats(): { routed: number; colyseus: number; direct: number; players: number } };

#x1Colyseus

function

ts
function x1Colyseus<R>(room: R, o?: { connect?: (j: JoinTicket) => Promise<ServicePlayer>; url?: string; channel?: number }): R;