@lanmower/entrypoint 0.16.0

package/src/sdk/client.js

@@ -0,0 +1,122 @@
+import { MSG } from '../protocol/MessageTypes.js'
+import { pack } from '../protocol/msgpack.js'
+import { QualityMonitor } from '../connection/QualityMonitor.js'
+import { StateInspector } from '../debug/StateInspector.js'
+import { createMessageRouter } from './ClientMessageHandler.js'
+import { EventEmitter } from '../protocol/EventEmitter.js'
+
+export function createClient(config = {}) {
+  const serverUrl = config.serverUrl || 'ws://localhost:8080'
+  const emitter = new EventEmitter()
+  const quality = new QualityMonitor()
+  const stateInspector = new StateInspector()
+
+  const state = {
+    ws: null, transportType: 'websocket',
+    playerId: null, sessionToken: null, tick: 0,
+    entities: new Map(), players: new Map(),
+    connected: false, reconnecting: false, reconnectAttempts: 0,
+    reconnectTimer: null, heartbeatTimer: null
+  }
+
+  function _sendRaw(data) {
+    if (state.ws && state.ws.readyState === 1) { state.ws.send(data); return true }
+    return false
+  }
+
+  function send(type, payload) {
+    const frame = pack({ type, payload })
+    quality.recordBytesOut(frame.length)
+    return _sendRaw(frame)
+  }
+
+  const onMessage = createMessageRouter({
+    emitter, quality, stateInspector, send,
+    getState: (k) => state[k],
+    setState: (k, v) => { state[k] = v }
+  })
+
+  function _startHeartbeats() {
+    state.heartbeatTimer = setInterval(() => {
+      quality.recordHeartbeatSent()
+      send(MSG.HEARTBEAT, { ts: Date.now() })
+    }, 1000)
+  }
+
+  function _attemptReconnect() {
+    if (state.reconnectAttempts >= 10) { emitter.emit('reconnectFailed'); return }
+    state.reconnecting = true
+    const delay = Math.min(100 * Math.pow(2, state.reconnectAttempts), 5000)
+    state.reconnectAttempts++
+    state.reconnectTimer = setTimeout(() => {
+      _connect().then(() => {
+        if (state.sessionToken) send(MSG.RECONNECT, { sessionToken: state.sessionToken })
+      }).catch(() => _attemptReconnect())
+    }, delay)
+  }
+
+  function _connect() {
+    return new Promise((resolve, reject) => {
+      try {
+        const WS = config.WebSocket || (typeof WebSocket !== 'undefined' ? WebSocket : null)
+        if (!WS) return reject(new Error('No WebSocket available'))
+        state.ws = new WS(serverUrl)
+        state.transportType = 'websocket'
+        if (state.ws.binaryType !== undefined) state.ws.binaryType = 'arraybuffer'
+        const onOpen = () => { state.connected = true; _startHeartbeats(); resolve() }
+        const onClose = () => {
+          state.connected = false
+          if (state.heartbeatTimer) clearInterval(state.heartbeatTimer)
+          emitter.emit('disconnect')
+          if (!state.reconnecting && state.sessionToken) _attemptReconnect()
+        }
+        const onErr = (e) => reject(e)
+        if (state.ws.on) {
+          state.ws.on('open', onOpen); state.ws.on('message', onMessage)
+          state.ws.on('close', onClose); state.ws.on('error', onErr)
+        } else {
+          state.ws.onopen = onOpen; state.ws.onmessage = (e) => onMessage(e.data)
+          state.ws.onclose = onClose; state.ws.onerror = onErr
+        }
+      } catch (e) { reject(e) }
+    })
+  }
+
+  const api = {
+    get playerId() { return state.playerId },
+    get tick() { return state.tick },
+    get entities() { return state.entities },
+    get players() { return state.players },
+    get isConnected() { return state.connected },
+    get sessionToken() { return state.sessionToken },
+    get transportType() { return state.transportType },
+    quality, stateInspector,
+    on: emitter.on.bind(emitter),
+    off: emitter.off.bind(emitter),
+    connect() { return _connect() },
+    connectNode(WS) { config.WebSocket = WS; return _connect() },
+    sendInput(input) { send(MSG.INPUT, { input }) },
+    interact(entityId) { send(MSG.APP_EVENT, { entityId }) },
+    disconnect() {
+      state.reconnecting = true
+      if (state.reconnectTimer) clearTimeout(state.reconnectTimer)
+      if (state.heartbeatTimer) clearInterval(state.heartbeatTimer)
+      state.connected = false
+      if (state.ws) state.ws.close()
+    },
+    getStats() {
+      return {
+        quality: quality.getStats(), stateSync: stateInspector.getStats(),
+        transport: state.transportType
+      }
+    },
+    getEntity(id) { return state.entities.get(id) || null },
+    getPlayer(id) { return state.players.get(id) || null }
+  }
+
+  if (typeof globalThis !== 'undefined') {
+    if (!globalThis.__DEBUG__) globalThis.__DEBUG__ = {}
+    globalThis.__DEBUG__.client = api
+  }
+  return api
+}

package/src/sdk/server.js

@@ -0,0 +1,184 @@
+import { join, dirname, resolve } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { MSG } from '../protocol/MessageTypes.js'
+import { ConnectionManager } from '../connection/ConnectionManager.js'
+import { SessionStore } from '../connection/SessionStore.js'
+import { Inspector } from '../debug/Inspector.js'
+import { TickSystem } from '../netcode/TickSystem.js'
+import { PlayerManager } from '../netcode/PlayerManager.js'
+import { NetworkState } from '../netcode/NetworkState.js'
+import { LagCompensator } from '../netcode/LagCompensator.js'
+import { PhysicsIntegration } from '../netcode/PhysicsIntegration.js'
+import { PhysicsWorld } from '../physics/World.js'
+import { AppRuntime } from '../apps/AppRuntime.js'
+import { AppLoader } from '../apps/AppLoader.js'
+import { StageLoader } from '../stage/StageLoader.js'
+import { createTickHandler } from './TickHandler.js'
+import { EventEmitter } from '../protocol/EventEmitter.js'
+import { EventBus } from '../apps/EventBus.js'
+import { EventLog } from '../netcode/EventLog.js'
+import { FSAdapter } from '../storage/FSAdapter.js'
+import { ReloadManager } from './ReloadManager.js'
+import { createReloadHandlers } from './ReloadHandlers.js'
+import { createServerAPI } from './ServerAPI.js'
+import { createConnectionHandlers } from './ServerHandlers.js'
+
+export async function boot(overrides = {}) {
+  const ROOT = join(dirname(fileURLToPath(import.meta.url)), '../..')
+  const worldPath = resolve(ROOT, 'apps/world/index.js')
+  const worldUrl = pathToFileURL(worldPath).href + `?t=${Date.now()}`
+  const worldMod = await import(worldUrl)
+  const worldDef = worldMod.default || worldMod
+  const config = {
+    port: parseInt(process.env.PORT || String(worldDef.port || 8080), 10),
+    tickRate: worldDef.tickRate || 128,
+    appsDir: join(ROOT, 'apps'),
+    gravity: worldDef.gravity,
+    movement: worldDef.movement,
+    staticDirs: [
+      { prefix: '/src/', dir: join(ROOT, 'src') },
+      { prefix: '/world/', dir: join(ROOT, 'world') },
+      { prefix: '/node_modules/', dir: join(ROOT, 'node_modules') },
+      { prefix: '/', dir: join(ROOT, 'client') }
+    ],
+    ...overrides
+  }
+  const server = await createServer(config)
+  await server.loadWorld(worldDef)
+  server.on('playerJoin', ({ id }) => console.log())
+  server.on('playerLeave', ({ id }) => console.log())
+  const info = await server.start()
+  console.log()
+  return server
+}
+
+export async function createServer(config = {}) {
+  const port = config.port || 8080
+  const tickRate = config.tickRate || 128
+  const appsDir = config.appsDir || './apps'
+  const gravity = config.gravity || [0, -9.81, 0]
+  const movement = config.movement || {}
+  const staticDirs = config.staticDirs || []
+
+  const storageDir = config.storageDir || './data'
+  const physics = new PhysicsWorld({ gravity })
+  await physics.init()
+
+  const emitter = new EventEmitter()
+  const eventBus = new EventBus()
+  const eventLog = new EventLog()
+  const storage = new FSAdapter(storageDir)
+  const tickSystem = new TickSystem(tickRate)
+  const playerManager = new PlayerManager()
+  const networkState = new NetworkState()
+  const lagCompensator = new LagCompensator()
+  const physicsIntegration = new PhysicsIntegration({ gravity, physicsWorld: physics })
+  const connections = new ConnectionManager({
+    heartbeatInterval: config.heartbeatInterval || 1000,
+    heartbeatTimeout: config.heartbeatTimeout || 3000
+  })
+  const sessions = new SessionStore({ ttl: config.sessionTTL || 30000 })
+  const inspector = new Inspector()
+  const reloadManager = new ReloadManager()
+
+  const appRuntime = new AppRuntime({ gravity, playerManager, physics, physicsIntegration, connections, eventBus, eventLog, storage })
+  appRuntime.setPlayerManager(playerManager)
+  const appLoader = new AppLoader(appRuntime, { dir: appsDir })
+  const stageLoader = new StageLoader(appRuntime)
+  appRuntime.setStageLoader(stageLoader)
+
+  appLoader._onReloadCallback = (name, code) => {
+    connections.broadcast(MSG.APP_MODULE, { app: name, code })
+  }
+
+  const ctx = {
+    config,
+    port,
+    tickRate,
+    appsDir,
+    gravity,
+    movement,
+    staticDirs,
+    physics,
+    emitter,
+    tickSystem,
+    playerManager,
+    networkState,
+    lagCompensator,
+    physicsIntegration,
+    connections,
+    sessions,
+    inspector,
+    reloadManager,
+    eventBus,
+    eventLog,
+    storage,
+    appRuntime,
+    appLoader,
+    stageLoader,
+    currentWorldDef: null,
+    worldSpawnPoint: [0, 5, 0],
+    snapshotSeq: 0,
+    httpServer: null,
+    wss: null,
+    wtServer: null,
+    handlerState: { fn: null },
+    onTick: (tick, dt) => { if (ctx.handlerState.fn) ctx.handlerState.fn(tick, dt) },
+    setTickHandler: (fn) => { ctx.handlerState.fn = fn }
+  }
+
+  const reloadHandlers = createReloadHandlers({
+    networkState,
+    playerManager,
+    physicsIntegration,
+    lagCompensator,
+    physics,
+    appRuntime,
+    connections
+  })
+  ctx.reloadHandlers = reloadHandlers
+
+  ctx.setTickHandler(createTickHandler({
+    networkState,
+    playerManager,
+    physicsIntegration,
+    lagCompensator,
+    physics,
+    appRuntime,
+    connections,
+    movement,
+    stageLoader,
+    eventLog
+  }))
+
+  const { onClientConnect } = createConnectionHandlers(ctx)
+  ctx.onClientConnect = onClientConnect
+
+  ctx.setupSDKWatchers = () => {
+    const reloadTick = async () => { ctx.setTickHandler(await reloadHandlers.reloadTickHandler()) }
+    const w = [
+      ['tick-handler', './src/sdk/TickHandler.js', reloadTick],
+      ['physics-integration', './src/netcode/PhysicsIntegration.js', reloadHandlers.reloadPhysicsIntegration],
+      ['lag-compensator', './src/netcode/LagCompensator.js', reloadHandlers.reloadLagCompensator],
+      ['player-manager', './src/netcode/PlayerManager.js', reloadHandlers.reloadPlayerManager],
+      ['network-state', './src/netcode/NetworkState.js', reloadHandlers.reloadNetworkState]
+    ]
+    for (const [id, path, reload] of w) reloadManager.addWatcher(id, path, reload)
+    const clientReload = () => { connections.broadcast(MSG.HOT_RELOAD, { timestamp: Date.now() }) }
+    const clientFiles = [
+      ['client-app', './client/app.js'],
+      ['client-camera', './client/camera.js'],
+      ['client-input', './src/client/InputHandler.js'],
+      ['client-network', './src/client/PhysicsNetworkClient.js'],
+      ['client-prediction', './src/client/PredictionEngine.js'],
+      ['client-reconciliation', './src/client/ReconciliationEngine.js'],
+      ['client-index', './src/index.client.js']
+    ]
+    for (const [id, path] of clientFiles) reloadManager.addWatcher(id, path, clientReload)
+  }
+
+  const api = createServerAPI(ctx)
+  if (typeof globalThis.__DEBUG__ === 'undefined') globalThis.__DEBUG__ = {}
+  globalThis.__DEBUG__.server = api
+  return api
+}

package/src/shared/movement.js

@@ -0,0 +1,69 @@
+export function applyMovement(state, input, movement, dt) {
+  const { maxSpeed, groundAccel, airAccel, friction, stopSpeed, jumpImpulse } = movement
+  let vx = state.velocity[0], vz = state.velocity[2]
+  let wishX = 0, wishZ = 0, wishSpeed = 0, jumped = false
+
+  if (input) {
+    let fx = 0, fz = 0
+    if (input.forward) fz += 1
+    if (input.backward) fz -= 1
+    if (input.left) fx -= 1
+    if (input.right) fx += 1
+    const flen = Math.sqrt(fx * fx + fz * fz)
+    if (flen > 0) { fx /= flen; fz /= flen }
+    const yaw = input.yaw || 0
+    const cy = Math.cos(yaw), sy = Math.sin(yaw)
+    wishX = fz * sy - fx * cy
+    wishZ = fx * sy + fz * cy
+    wishSpeed = flen > 0 ? maxSpeed : 0
+    if (input.jump && state.onGround) {
+      state.velocity[1] = jumpImpulse
+      state.onGround = false
+      jumped = true
+    }
+  }
+
+  if (state.onGround && !jumped) {
+    const speed = Math.sqrt(vx * vx + vz * vz)
+    if (speed > 0.1) {
+      const control = speed < stopSpeed ? stopSpeed : speed
+      const drop = control * friction * dt
+      let newSpeed = speed - drop
+      if (newSpeed < 0) newSpeed = 0
+      const scale = newSpeed / speed
+      vx *= scale; vz *= scale
+    } else { vx = 0; vz = 0 }
+    if (wishSpeed > 0) {
+      const cur = vx * wishX + vz * wishZ
+      let add = wishSpeed - cur
+      if (add > 0) {
+        let as = groundAccel * wishSpeed * dt
+        if (as > add) as = add
+        vx += as * wishX; vz += as * wishZ
+      }
+    }
+  } else {
+    if (wishSpeed > 0) {
+      const cur = vx * wishX + vz * wishZ
+      let add = wishSpeed - cur
+      if (add > 0) {
+        let as = airAccel * wishSpeed * dt
+        if (as > add) as = add
+        vx += as * wishX; vz += as * wishZ
+      }
+    }
+  }
+
+  state.velocity[0] = vx
+  state.velocity[2] = vz
+  return { wishX, wishZ, wishSpeed, jumped }
+}
+
+export const DEFAULT_MOVEMENT = {
+  maxSpeed: 8.0,
+  groundAccel: 10.0,
+  airAccel: 1.0,
+  friction: 6.0,
+  stopSpeed: 2.0,
+  jumpImpulse: 4.5
+}

package/src/spatial/Octree.js

@@ -0,0 +1,91 @@
+import { octree } from 'd3-octree'
+
+export class SpatialIndex {
+  constructor(config = {}) {
+    this._tree = octree()
+    this._entities = new Map()
+    this._relevanceRadius = config.relevanceRadius || 200
+  }
+
+  insert(id, position) {
+    this.remove(id)
+    const point = [position[0], position[1], position[2]]
+    point._entityId = id
+    this._entities.set(id, point)
+    this._tree.add(point)
+  }
+
+  remove(id) {
+    const existing = this._entities.get(id)
+    if (!existing) return
+    this._tree.remove(existing)
+    this._entities.delete(id)
+  }
+
+  update(id, position) {
+    this.insert(id, position)
+  }
+
+  has(id) {
+    return this._entities.has(id)
+  }
+
+  getPosition(id) {
+    const p = this._entities.get(id)
+    return p ? [p[0], p[1], p[2]] : null
+  }
+
+  nearby(position, radius) {
+    const cx = position[0], cy = position[1], cz = position[2]
+    const r2 = radius * radius
+    const results = []
+    this._tree.visit((node, x0, y0, z0, x1, y1, z1) => {
+      if (!node.length) {
+        let d = node
+        do {
+          const p = d.data
+          const dx = p[0] - cx, dy = p[1] - cy, dz = p[2] - cz
+          if (dx * dx + dy * dy + dz * dz <= r2) {
+            results.push(p._entityId)
+          }
+        } while (d = d.next)
+      }
+      const nx = Math.max(x0, Math.min(cx, x1))
+      const ny = Math.max(y0, Math.min(cy, y1))
+      const nz = Math.max(z0, Math.min(cz, z1))
+      const ddx = nx - cx, ddy = ny - cy, ddz = nz - cz
+      return ddx * ddx + ddy * ddy + ddz * ddz > r2
+    })
+    return results
+  }
+
+  nearest(position, radius) {
+    const p = this._tree.find(position[0], position[1], position[2], radius)
+    return p ? p._entityId : null
+  }
+
+  get size() {
+    return this._entities.size
+  }
+
+  clear() {
+    this._tree = octree()
+    this._entities.clear()
+  }
+
+  rebuild() {
+    const entries = Array.from(this._entities.entries())
+    this._tree = octree()
+    for (const [, point] of entries) {
+      this._tree.add(point)
+    }
+  }
+
+  get relevanceRadius() {
+    return this._relevanceRadius
+  }
+
+  set relevanceRadius(v) {
+    this._relevanceRadius = v
+  }
+}

package/src/stage/Stage.js

@@ -0,0 +1,90 @@
+import { SpatialIndex } from '../spatial/Octree.js'
+
+export class Stage {
+  constructor(name, config = {}) {
+    this.name = name
+    this.entityIds = new Set()
+    this.spatial = new SpatialIndex({ relevanceRadius: config.relevanceRadius || 200 })
+    this.gravity = config.gravity || null
+    this.spawnPoint = config.spawnPoint || null
+    this.playerModel = config.playerModel || null
+    this._runtime = null
+    this._staticIds = new Set()
+  }
+
+  bind(runtime) {
+    this._runtime = runtime
+  }
+
+  addEntity(id, config = {}) {
+    if (!this._runtime) return null
+    const entity = this._runtime.spawnEntity(id, config)
+    this.entityIds.add(entity.id)
+    const pos = entity.position || [0, 0, 0]
+    this.spatial.insert(entity.id, pos)
+    if (entity.bodyType === 'static' || config.autoTrimesh) {
+      this._staticIds.add(entity.id)
+    }
+    return entity
+  }
+
+  removeEntity(id) {
+    if (!this._runtime) return
+    this.spatial.remove(id)
+    this._staticIds.delete(id)
+    this.entityIds.delete(id)
+    this._runtime.destroyEntity(id)
+  }
+
+  updateEntityPosition(id, position) {
+    if (!this.entityIds.has(id)) return
+    this.spatial.update(id, position)
+  }
+
+  getNearbyEntities(position, radius) {
+    return this.spatial.nearby(position, radius || this.spatial.relevanceRadius)
+  }
+
+  getRelevantEntities(position, radius) {
+    const nearby = this.spatial.nearby(position, radius || this.spatial.relevanceRadius)
+    const set = new Set(nearby)
+    for (const sid of this._staticIds) set.add(sid)
+    return Array.from(set)
+  }
+
+  getStaticIds() {
+    return Array.from(this._staticIds)
+  }
+
+  hasEntity(id) {
+    return this.entityIds.has(id)
+  }
+
+  get entityCount() {
+    return this.entityIds.size
+  }
+
+  clear() {
+    if (!this._runtime) return
+    for (const id of [...this.entityIds]) {
+      this._runtime.destroyEntity(id)
+    }
+    this.entityIds.clear()
+    this._staticIds.clear()
+    this.spatial.clear()
+  }
+
+  syncPositions() {
+    if (!this._runtime) return
+    for (const id of this.entityIds) {
+      const e = this._runtime.getEntity(id)
+      if (e && e.bodyType !== 'static') {
+        this.spatial.update(id, e.position)
+      }
+    }
+  }
+
+  getAllEntityIds() {
+    return Array.from(this.entityIds)
+  }
+}

package/src/stage/StageLoader.js

@@ -0,0 +1,95 @@
+import { Stage } from './Stage.js'
+
+export class StageLoader {
+  constructor(runtime) {
+    this._runtime = runtime
+    this._stages = new Map()
+    this._activeStage = null
+  }
+
+  loadFromDefinition(name, worldDef) {
+    const stage = new Stage(name, {
+      relevanceRadius: worldDef.relevanceRadius || 200,
+      gravity: worldDef.gravity,
+      spawnPoint: worldDef.spawnPoint,
+      playerModel: worldDef.playerModel
+    })
+    stage.bind(this._runtime)
+
+    if (worldDef.gravity) {
+      this._runtime.gravity = [...worldDef.gravity]
+    }
+
+    for (const entDef of worldDef.entities || []) {
+      const cfg = {
+        model: entDef.model,
+        position: entDef.position || [0, 0, 0],
+        rotation: entDef.rotation,
+        scale: entDef.scale,
+        app: entDef.app,
+        config: entDef.config || null
+      }
+      if (entDef.model && !entDef.app) {
+        cfg.autoTrimesh = true
+      }
+      stage.addEntity(entDef.id || null, cfg)
+    }
+
+    this._stages.set(name, stage)
+    if (!this._activeStage) this._activeStage = stage
+    return stage
+  }
+
+  getStage(name) {
+    return this._stages.get(name) || null
+  }
+
+  getActiveStage() {
+    return this._activeStage
+  }
+
+  setActiveStage(name) {
+    const stage = this._stages.get(name)
+    if (stage) this._activeStage = stage
+    return stage
+  }
+
+  removeStage(name) {
+    const stage = this._stages.get(name)
+    if (!stage) return
+    stage.clear()
+    this._stages.delete(name)
+    if (this._activeStage === stage) {
+      this._activeStage = this._stages.values().next().value || null
+    }
+  }
+
+  swapStage(oldName, newName, newDef) {
+    this.removeStage(oldName)
+    return this.loadFromDefinition(newName, newDef)
+  }
+
+  getAllStageNames() {
+    return Array.from(this._stages.keys())
+  }
+
+  get stageCount() {
+    return this._stages.size
+  }
+
+  syncAllPositions() {
+    for (const stage of this._stages.values()) {
+      stage.syncPositions()
+    }
+  }
+
+  getNearbyEntities(position, radius) {
+    if (!this._activeStage) return []
+    return this._activeStage.getNearbyEntities(position, radius)
+  }
+
+  getRelevantEntities(position, radius) {
+    if (!this._activeStage) return []
+    return this._activeStage.getRelevantEntities(position, radius)
+  }
+}

package/src/storage/FSAdapter.js

@@ -0,0 +1,56 @@
+import { readFile, writeFile, unlink, readdir, mkdir, rename, access } from 'node:fs/promises'
+import { join, dirname } from 'node:path'
+import { StorageAdapter } from './StorageAdapter.js'
+
+export class FSAdapter extends StorageAdapter {
+  constructor(baseDir = './data') {
+    super()
+    this._dir = baseDir
+    this._ready = false
+  }
+
+  async _ensureDir() {
+    if (this._ready) return
+    await mkdir(this._dir, { recursive: true }).catch(() => {})
+    this._ready = true
+  }
+
+  _path(key) {
+    const safe = key.replace(/[^a-zA-Z0-9._-]/g, '_')
+    return join(this._dir, `${safe}.json`)
+  }
+
+  async get(key) {
+    try {
+      const data = await readFile(this._path(key), 'utf-8')
+      return JSON.parse(data)
+    } catch { return undefined }
+  }
+
+  async set(key, value) {
+    await this._ensureDir()
+    const fp = this._path(key)
+    const tmp = fp + '.tmp'
+    await writeFile(tmp, JSON.stringify(value), 'utf-8')
+    await rename(tmp, fp)
+  }
+
+  async delete(key) {
+    try { await unlink(this._path(key)) } catch {}
+  }
+
+  async list(prefix = '') {
+    await this._ensureDir()
+    try {
+      const files = await readdir(this._dir)
+      const safe = prefix.replace(/[^a-zA-Z0-9._-]/g, '_')
+      return files
+        .filter(f => f.endsWith('.json') && f.startsWith(safe))
+        .map(f => f.slice(0, -5))
+    } catch { return [] }
+  }
+
+  async has(key) {
+    try { await access(this._path(key)); return true } catch { return false }
+  }
+}