Мультиплеер

// Один бандл, каждая роль: `lecodes serve` = выделенный сервер, `lecodes desktop run --connect
// 127.0.0.1:40000` = клиент, просто `lecodes desktop run` = офлайн (та же игра, один игрок).
const scene = new Scene({ skybox: "#8fb2d9" })
scene.add(Light.sun({ direction: [-0.4, -0.9, -0.35] }))
scene.camera.position = [0, 12, 14]
scene.camera.lookAt([0, 0, 0])

// Общий словарь: ввод этого тика и реплицируемый тип сущности.
const Move = Net.input({ x: 0, z: 0 })
const PlayerKind = Net.kind("player", { pos: [0, 0, 0] }, {
  transform: "pos",                          // state.pos зеркалит node.position
  client: (rep, scene) => {                  // клиент рождает свой прокси, когда сервер спавнит сущность
    const node = makePlayer(rep.isMine)
    scene?.add(node)
    return node
  },
})

function makePlayer(mine: boolean): Node {
  return Mesh.box({ size: 1, material: Material.lit({ color: mine ? "#e0743c" : "#4f7cff" }) })
    .aspect(Walk)
}

// Ввод: раз в тик, на каждой машине с локальным игроком.
class Controls extends System<"controls"> {
  updateFixed() {
    if (Net.role === "server") return        // у выделенного сервера нет своего игрока
    const x = (Input.key("KeyD") ? 1 : 0) - (Input.key("KeyA") ? 1 : 0)
    const z = (Input.key("KeyS") ? 1 : 0) - (Input.key("KeyW") ? 1 : 0)
    Net.setInput(Move, { x, z })
  }
}
scene.system(Controls)

// Симуляция: один и тот же код на сервере (каждый игрок) и на клиенте (его собственный игрок).
class Walk extends Aspect<"walk", Node> {
  static after = [Controls]
  updateFixed(dt: number) {
    const rep = this.node.get(Replicated)
    if (!rep?.simulated) return              // чужой игрок: SDK двигает прокси сам
    const move = rep.input(Move)
    this.node.x += move.x * 4 * dt
    this.node.z += move.z * 4 * dt
  }
}

// Сервер решает, что существует: узел с Replicated существует на каждом клиенте.
const spawn = (p: NetPlayer) => scene.add(makePlayer(p.isMe).aspect(Replicated, { kind: PlayerKind, owner: p }))
Net.on("join", (p) => { if (Net.isServer) spawn(p) })

scene.open()
const launch = Net.launch
if (launch?.role === "server") Net.listen({ port: launch.port, maxClients: launch.maxClients })
else if (launch?.role === "client") Net.connect({ address: launch.address }, { name: "Guest" })
else spawn(Net.me)                           // офлайн

lecodes serve                                   # dedicated server, windowless (port 40000, 16 slots)
lecodes serve --connect 127.0.0.1:40000         # a headless client: a bot, a scripted test player
lecodes desktop run --connect 127.0.0.1:40000   # a client window
lecodes desktop run                             # offline

Net.launch: NetLaunch | null     // как был запущен exe; null = без флага мультиплеера
Net.listen(opts?): boolean       // слушать; false + событие "error", когда не получилось
Net.connect({ address }, opts?): Promise<void>   // резолвится, когда сервер нас принял
Net.disconnect(): void
Net.role: NetRole                // "offline" | "host" | "client" | "server"
Net.status: NetStatus            // "idle" | "connecting" | "online" | "error"
Net.isServer / Net.isClient / Net.supported: boolean

Net.on("connect", () => …)             // клиент: принят · хост/сервер: слушает (срабатывает внутри listen())
Net.on("join", (player) => …)           // кто-то присоединился (на клиенте: другой игрок)
Net.on("leave", (player, reason) => …)  // например "disconnected", "timed out", "kicked", "server closed"
Net.on("disconnect", (reason) => …)     // клиент: сессия завершилась ("disconnected by server", …)
Net.on("error", (message) => …)         // неудавшийся connect или listen
Net.on("reject", (reason) => …)         // см. примечание ниже
Net.off(event, cb)                      // on / off возвращают Net

// сервер
Net.listen({
  port: 40000,
  accept: (hello, who) => (hello as { build?: number })?.build === 7 ? null : `${who.name}: update the game`,
})
// клиент
Net.connect({ address: "192.168.1.10:40000" }, { name: "Den", hello: { build: 7 } })
  .catch((e) => console.log("could not join:", e.message))

Net.me: NetPlayer                      // игрок этой машины; null на выделенном сервере
Net.players: readonly NetPlayer[]      // все в сессии, включая Net.me
Net.player(id): NetPlayer | undefined

player.id: number                      // уникален в сессии, назначается сервером
player.name: string                    // то, что передали connect / listen — не уникально
player.isMe: boolean
player.connectedAt: number             // Date.now() мс, когда эта машина узнала об игроке
player.hello: unknown                  // только сервер: что нёс connect() игрока
player.data: any                       // локальная сумка для игровых фактов — НЕ реплицируется
player.rtt / player.loss: number       // мс / проценты
player.send(msg, data)                 // сервер → этот игрок (см. Сообщения)
player.kick(reason?)                   // сервер: отключить этого игрока (см. примечание выше)
player.on("leave", (player, reason) => …) / player.off("leave", cb)
Net.rtt: number                        // клиент: наш round trip до сервера в мс; 0 в остальных случаях

const Chat = Net.message<{ text: string }>("chat")          // надёжно, по порядку
const Ping = Net.message<{ at: number }>("ping", { unreliable: true })

Net.send(msg, data)                          // → на сервер, с машины, у которой есть игрок
Net.broadcast(msg, data, { except? })        // сервер → каждому игроку (включая собственного игрока хоста)
player.send(msg, data)                       // сервер → одному игроку
Net.on(msg, (data, from) => …)               // from = игрок-отправитель на сервере; null = отправлено сервером
Net.off(msg, cb)

Net.on(Chat, (msg, from) => {
  if (from) Net.broadcast(Chat, { text: `${from.name}: ${msg.text}` })   // сервер: ретранслировать всем
  else console.log(msg.text)                                            // сообщение от сервера
})
Net.send(Chat, { text: "gg" })

const Move = Net.input({ x: 0, z: 0, jump: false })   // ОДИН на игру: значения по умолчанию задают раскладку
Net.setInput(Move, { x, z })        // раз в тик, из updateFixed, на машине с локальным игроком
rep.input(Move)                     // ввод владельца для симулируемого тика
rep.hasInput                        // false до первого ввода владельца (input() до тех пор даёт значения по умолчанию)
Net.tick: number                    // фиксированных шагов с начала сессии; 0 в офлайне
Net.viewTick: number                // клиент: серверный тик, на котором показаны удалённые сущности

const Kind = Net.kind(name, defaults, {
  transform?: "pos" | "pos+rot" | "none",       // по умолчанию "none"
  client?: (rep: NetEntity, scene: Scene | null) => Node | void,
  discrete?: string[],                           // числовые поля, которые никогда не интерполируются
  correction?: Partial<NetCorrection>,           // см. Предсказание
})
node.aspect(Replicated, { kind, owner?: NetPlayer })   // сервер: заспавнить на каждом клиенте
node.destroy()                                          // сервер: удалить везде
Net.entities: readonly NetEntity[]
Net.entity(netId): NetEntity | undefined

node.replicated / node.get(Replicated)     // аспект, одни и те же члены с обеих сторон:
rep.state                  // сервер: пиши его · клиент, чужой: интерполирован · клиент, свой: новейшее авторитативное
rep.netId / rep.isMine / rep.simulated / rep.ownerPlayer / rep.correction / rep.input(inp) / rep.hasInput
rep.entity: NetEntity      // запись: netId, kind, ownerId (0 = собственная сущность сервера), owner, state, node
rep.entity.on("state", (state) => …) / .off("state", cb)   // клиент: состояние обновилось

// узел — симулируемое тело; видимый меш — дочерний узел, несущий коррекцию
class Smooth extends Aspect<"smooth", Node> {
  body!: Node
  update() {
    const c = this.node.get(Replicated)?.correction
    if (c) this.body.position = [c.x, c.y, c.z]
  }
}

Net.stats      // живые счётчики: snapshots, ahead, lead, nudges, corrections / maxCorrection / sumCorrection, missed, bytesOut
Net.simulate({ latency?: ms, jitter?: ms, loss?: percent })   // только для разработки: ухудшить то, что отправляет ЭТА сторона

Net.send(Chat, data)                    // ✗ на выделенном сервере: бросает исключение
Net.broadcast(Chat, data)               // ✓ сервер адресует игроков

node.x += dx                            // ✗ на удалённом прокси: следующая интерполированная поза перезапишет
if (rep.simulated) node.x += dx         // ✓ двигай только то, что симулирует эта машина

rep.state.hp = 0                        // ✗ на клиенте: SDK перезапишет состоянием сервера
Net.send(Hit, { target: rep.netId })    // ✓ попроси сервер; он меняет состояние

Net.connect({ address: "localhost:40000" })   // ✗ "bad address"
Net.connect({ address: "127.0.0.1:40000" })   // ✓