@lanmower/entrypoint 0.16.0

package/src/debug/Inspector.js

@@ -0,0 +1,52 @@
+export class Inspector {
+  constructor() {
+    this.clients = new Map()
+  }
+
+  handleMessage(clientId, msg) {
+    if (!msg || msg.type < 100) return false
+    const msgType = msg.type
+    if (msgType >= 100 && msgType <= 199) {
+      this._handleDebugMessage(clientId, msg)
+      return true
+    }
+    return false
+  }
+
+  _handleDebugMessage(clientId, msg) {
+    const client = this.clients.get(clientId) || {
+      id: clientId,
+      debugMessages: []
+    }
+    client.lastDebugMessage = Date.now()
+    client.debugMessages = client.debugMessages || []
+    client.debugMessages.push({
+      type: msg.type,
+      timestamp: Date.now(),
+      payload: msg.payload
+    })
+    if (client.debugMessages.length > 1000) {
+      client.debugMessages.shift()
+    }
+    this.clients.set(clientId, client)
+  }
+
+  removeClient(clientId) {
+    this.clients.delete(clientId)
+  }
+
+  getAllClients(connections) {
+    const result = []
+    for (const [clientId, client] of this.clients.entries()) {
+      const conn = connections.getClient(clientId)
+      if (conn) {
+        result.push({
+          id: clientId,
+          debugMessages: client.debugMessages.length,
+          lastMessage: client.lastDebugMessage
+        })
+      }
+    }
+    return result
+  }
+}

package/src/debug/StateInspector.js

@@ -0,0 +1,42 @@
+export class StateInspector {
+  constructor() {
+    this.snapshots = []
+    this.delays = []
+    this.corrections = []
+    this.maxSnapshots = 100
+  }
+
+  recordSnapshot(snap) {
+    this.snapshots.push({ ...snap, timestamp: Date.now() })
+    if (this.snapshots.length > this.maxSnapshots) {
+      this.snapshots.shift()
+    }
+  }
+
+  recordSnapshotDelay(delay) {
+    this.delays.push(delay)
+    if (this.delays.length > this.maxSnapshots) {
+      this.delays.shift()
+    }
+  }
+
+  recordCorrection(playerId, oldState, newState, deviationMs) {
+    this.corrections.push({ playerId, newState, deviationMs, timestamp: Date.now() })
+    if (this.corrections.length > this.maxSnapshots) {
+      this.corrections.shift()
+    }
+  }
+
+  getStats() {
+    const avgDelay = this.delays.length > 0
+      ? this.delays.reduce((a, b) => a + b, 0) / this.delays.length
+      : 0
+    return {
+      snapshots: this.snapshots.length,
+      delays: this.delays.length,
+      avgDelay,
+      corrections: this.corrections.length,
+      lastSnapshot: this.snapshots[this.snapshots.length - 1] || null
+    }
+  }
+}

package/src/index.client.js

@@ -0,0 +1,8 @@
+export { InputHandler } from './client/InputHandler.js'
+export { PhysicsNetworkClient } from './client/PhysicsNetworkClient.js'
+export { PredictionEngine } from './client/PredictionEngine.js'
+export { ReconciliationEngine } from './client/ReconciliationEngine.js'
+
+export { MSG, msgName, DISCONNECT_REASONS, CONNECTION_QUALITY, UNRELIABLE_MSGS, isUnreliable } from './protocol/MessageTypes.js'
+export { Codec } from './protocol/Codec.js'
+export { SequenceTracker } from './protocol/SequenceTracker.js'

package/src/index.js

@@ -0,0 +1 @@
+export * from './index.server.js'

package/src/index.server.js

@@ -0,0 +1,27 @@
+export { PhysicsWorld } from './physics/World.js'
+
+export { AppRuntime } from './apps/AppRuntime.js'
+export { EventBus } from './apps/EventBus.js'
+export { StageLoader } from './stage/StageLoader.js'
+export { Stage } from './stage/Stage.js'
+export { SpatialIndex } from './spatial/Octree.js'
+
+export { TickSystem } from './netcode/TickSystem.js'
+export { NetworkState } from './netcode/NetworkState.js'
+export { SnapshotEncoder } from './netcode/SnapshotEncoder.js'
+export { PlayerManager } from './netcode/PlayerManager.js'
+export { LagCompensator } from './netcode/LagCompensator.js'
+export { PhysicsIntegration } from './netcode/PhysicsIntegration.js'
+export { EventLog } from './netcode/EventLog.js'
+
+export { StorageAdapter } from './storage/StorageAdapter.js'
+export { FSAdapter } from './storage/FSAdapter.js'
+
+export { MSG, msgName, DISCONNECT_REASONS, CONNECTION_QUALITY, UNRELIABLE_MSGS, isUnreliable } from './protocol/MessageTypes.js'
+export { Codec } from './protocol/Codec.js'
+export { SequenceTracker } from './protocol/SequenceTracker.js'
+
+export { TransportWrapper } from './transport/TransportWrapper.js'
+export { WebSocketTransport } from './transport/WebSocketTransport.js'
+export { WebTransportTransport } from './transport/WebTransportTransport.js'
+export { WebTransportServer, WEBTRANSPORT_AVAILABLE } from './transport/WebTransportServer.js'

package/src/math.js

@@ -0,0 +1,21 @@
+export function mulQuat(a, b) {
+  return [
+    a[3]*b[0] + a[0]*b[3] + a[1]*b[2] - a[2]*b[1],
+    a[3]*b[1] - a[0]*b[2] + a[1]*b[3] + a[2]*b[0],
+    a[3]*b[2] + a[0]*b[1] - a[1]*b[0] + a[2]*b[3],
+    a[3]*b[3] - a[0]*b[0] - a[1]*b[1] - a[2]*b[2]
+  ]
+}
+
+export function rotVec(v, q) {
+  const [qx, qy, qz, qw] = q
+  const ix = qw*v[0] + qy*v[2] - qz*v[1]
+  const iy = qw*v[1] + qz*v[0] - qx*v[2]
+  const iz = qw*v[2] + qx*v[1] - qy*v[0]
+  const iw = -qx*v[0] - qy*v[1] - qz*v[2]
+  return [
+    ix*qw + iw*-qx + iy*-qz - iz*-qy,
+    iy*qw + iw*-qy + iz*-qx - ix*-qz,
+    iz*qw + iw*-qz + ix*-qy - iy*-qx
+  ]
+}

package/src/netcode/EventLog.js

@@ -0,0 +1,74 @@
+export class EventLog {
+  constructor(config = {}) {
+    this._log = []
+    this._maxSize = config.maxSize || 100000
+    this._nextId = 1
+    this._recording = true
+  }
+
+  record(type, data, meta = {}) {
+    if (!this._recording) return null
+    const event = {
+      id: this._nextId++,
+      tick: meta.tick || 0,
+      timestamp: Date.now(),
+      type,
+      data,
+      meta: { actor: meta.actor || null, reason: meta.reason || null, context: meta.context || null, sourceApp: meta.sourceApp || null, sourceEntity: meta.sourceEntity || null, causalEventId: meta.causalEventId || null, ...meta }
+    }
+    this._log.push(event)
+    if (this._log.length > this._maxSize) this._log.shift()
+    return event
+  }
+
+  query(filter = {}) {
+    return this._log.filter(e => {
+      if (filter.type && e.type !== filter.type) return false
+      if (filter.tick !== undefined && e.tick !== filter.tick) return false
+      if (filter.tickRange && (e.tick < filter.tickRange[0] || e.tick > filter.tickRange[1])) return false
+      if (filter.actor && e.meta.actor !== filter.actor) return false
+      if (filter.entity && e.meta.sourceEntity !== filter.entity) return false
+      if (filter.app && e.meta.sourceApp !== filter.app) return false
+      return true
+    })
+  }
+
+  getRange(startTick, endTick) {
+    return this._log.filter(e => e.tick >= startTick && e.tick <= endTick)
+  }
+
+  get size() { return this._log.length }
+  get lastTick() { return this._log.length > 0 ? this._log[this._log.length - 1].tick : 0 }
+
+  pause() { this._recording = false }
+  resume() { this._recording = true }
+  clear() { this._log = []; this._nextId = 1 }
+
+  serialize() { return JSON.stringify(this._log) }
+
+  static deserialize(json) {
+    const log = new EventLog()
+    log._log = JSON.parse(json)
+    log._nextId = log._log.length > 0 ? log._log[log._log.length - 1].id + 1 : 1
+    return log
+  }
+
+  replay(runtime, options = {}) {
+    const speed = options.speed || 1
+    const startTick = options.startTick || 0
+    const endTick = options.endTick || Infinity
+    const events = this._log.filter(e => e.tick >= startTick && e.tick <= endTick)
+    const result = { eventsReplayed: 0, errors: [] }
+    for (const event of events) {
+      try {
+        switch (event.type) {
+          case 'entity_spawn': runtime.spawnEntity(event.data.id, event.data.config); break
+          case 'entity_destroy': runtime.destroyEntity(event.data.id); break
+          case 'bus_event': runtime._eventBus?.emit(event.data.channel, event.data.data, event.meta); break
+        }
+        result.eventsReplayed++
+      } catch (e) { result.errors.push({ eventId: event.id, error: e.message }) }
+    }
+    return result
+  }
+}

package/src/netcode/LagCompensator.js

@@ -0,0 +1,78 @@
+export class LagCompensator {
+  constructor(historyWindow = 500) {
+    this.historyWindow = historyWindow
+    this.playerHistory = new Map()
+  }
+
+  recordPlayerPosition(playerId, position, rotation, velocity, tick) {
+    if (!this.playerHistory.has(playerId)) {
+      this.playerHistory.set(playerId, [])
+    }
+
+    const history = this.playerHistory.get(playerId)
+    history.push({
+      tick,
+      timestamp: Date.now(),
+      position: [...position],
+      rotation: [...rotation],
+      velocity: [...velocity]
+    })
+
+    const cutoff = Date.now() - this.historyWindow
+    while (history.length > 0 && history[0].timestamp < cutoff) {
+      history.shift()
+    }
+  }
+
+  getPlayerStateAtTime(playerId, millisAgo) {
+    const history = this.playerHistory.get(playerId)
+    if (!history || history.length === 0) return null
+
+    const targetTime = Date.now() - millisAgo
+    let best = null
+
+    for (const state of history) {
+      if (state.timestamp <= targetTime) {
+        best = state
+      } else {
+        break
+      }
+    }
+
+    return best
+  }
+
+  validateShot(shooterId, targetId, latencyMs) {
+    const targetState = this.getPlayerStateAtTime(targetId, latencyMs)
+    if (!targetState) return { valid: false, reason: 'no_history' }
+
+    const speed = Math.sqrt(targetState.velocity[0]**2 + targetState.velocity[1]**2 + targetState.velocity[2]**2)
+
+    if (speed > 30) {
+      return { valid: true, reason: 'fast_moving_target', state: targetState }
+    }
+
+    return { valid: true, reason: 'valid_shot', state: targetState }
+  }
+
+  detectTeleport(playerId, newPosition, threshold = 50) {
+    const history = this.playerHistory.get(playerId)
+    if (!history || history.length < 2) return false
+
+    const lastPos = history[history.length - 1].position
+    const dist = Math.sqrt((newPosition[0] - lastPos[0])**2 + (newPosition[1] - lastPos[1])**2 + (newPosition[2] - lastPos[2])**2)
+
+    return dist > threshold
+  }
+
+  clearPlayerHistory(playerId) {
+    this.playerHistory.delete(playerId)
+  }
+
+  getStats() {
+    return {
+      trackedPlayers: this.playerHistory.size,
+      totalSamples: Array.from(this.playerHistory.values()).reduce((sum, h) => sum + h.length, 0)
+    }
+  }
+}

package/src/netcode/NetworkState.js

@@ -0,0 +1,66 @@
+export class NetworkState {
+  constructor() {
+    this.players = new Map()
+    this.tick = 0
+    this.timestamp = 0
+  }
+
+  addPlayer(playerId, initialState = {}) {
+    this.players.set(playerId, {
+      id: playerId,
+      position: initialState.position || [0, 0, 0],
+      rotation: initialState.rotation || [0, 0, 0, 1],
+      velocity: initialState.velocity || [0, 0, 0],
+      angularVelocity: initialState.angularVelocity || [0, 0, 0],
+      onGround: initialState.onGround !== undefined ? initialState.onGround : true,
+      health: initialState.health || 100,
+      inputSequence: 0,
+      lastUpdate: Date.now()
+    })
+  }
+
+  removePlayer(playerId) {
+    this.players.delete(playerId)
+  }
+
+  getPlayer(playerId) {
+    return this.players.get(playerId)
+  }
+
+  updatePlayer(playerId, state) {
+    const player = this.players.get(playerId)
+    if (player) {
+      Object.assign(player, state)
+      player.lastUpdate = Date.now()
+    }
+  }
+
+  getAllPlayers() {
+    return Array.from(this.players.values())
+  }
+
+  getSnapshot() {
+    return {
+      tick: this.tick,
+      timestamp: this.timestamp,
+      players: this.getAllPlayers().map(p => ({
+        id: p.id,
+        position: p.position,
+        rotation: p.rotation,
+        velocity: p.velocity,
+        onGround: p.onGround,
+        health: p.health,
+        inputSequence: p.inputSequence
+      }))
+    }
+  }
+
+  setTick(tick, timestamp = Date.now()) {
+    this.tick = tick
+    this.timestamp = timestamp
+  }
+
+  clear() {
+    this.players.clear()
+  }
+}

package/src/netcode/PhysicsIntegration.js

@@ -0,0 +1,132 @@
+export class PhysicsIntegration {
+  constructor(config = {}) {
+    this.physicsWorld = config.physicsWorld || null
+    this.config = {
+      gravity: config.gravity || [0, -9.81, 0],
+      capsuleRadius: config.capsuleRadius || 0.4,
+      capsuleHalfHeight: config.capsuleHalfHeight || 0.9,
+      playerMass: config.playerMass || 160,
+      ...config
+    }
+    this.playerBodies = new Map()
+  }
+
+  setPhysicsWorld(world) {
+    this.physicsWorld = world
+  }
+
+  addPlayerCollider(playerId, radius = 0.4) {
+    if (!this.physicsWorld) {
+      this.playerBodies.set(playerId, { id: playerId, charId: null, onGround: true })
+      return
+    }
+    const charId = this.physicsWorld.addPlayerCharacter(
+      radius,
+      this.config.capsuleHalfHeight,
+      [0, 5, 0],
+      this.config.playerMass
+    )
+    this.playerBodies.set(playerId, { id: playerId, charId, onGround: true })
+  }
+
+  removePlayerCollider(playerId) {
+    const data = this.playerBodies.get(playerId)
+    if (data?.charId && this.physicsWorld) {
+      this.physicsWorld.removeCharacter(data.charId)
+    }
+    this.playerBodies.delete(playerId)
+  }
+
+  updatePlayerPhysics(playerId, state, deltaTime) {
+    const data = this.playerBodies.get(playerId)
+    if (!data || !data.charId || !this.physicsWorld) {
+      return this._fallbackPhysics(playerId, state, deltaTime)
+    }
+    const charId = data.charId
+    const currentVel = this.physicsWorld.getCharacterVelocity(charId)
+    const onGround = this.physicsWorld.getCharacterGroundState(charId)
+    let vy
+    if (onGround) {
+      vy = state.velocity[1] > 0 ? state.velocity[1] : 0
+    } else {
+      vy = currentVel[1] + this.config.gravity[1] * deltaTime
+    }
+    this.physicsWorld.setCharacterVelocity(charId, [state.velocity[0], vy, state.velocity[2]])
+    this.physicsWorld.updateCharacter(charId, deltaTime)
+    const pos = this.physicsWorld.getCharacterPosition(charId)
+    const vel = this.physicsWorld.getCharacterVelocity(charId)
+    data.onGround = this.physicsWorld.getCharacterGroundState(charId)
+    state.position = pos
+    state.velocity = vel
+    state.onGround = data.onGround
+    return state
+  }
+
+  _fallbackPhysics(playerId, state, deltaTime) {
+    state.velocity[1] += this.config.gravity[1] * deltaTime
+    state.position[0] += state.velocity[0] * deltaTime
+    state.position[1] += state.velocity[1] * deltaTime
+    state.position[2] += state.velocity[2] * deltaTime
+    if (state.position[1] <= 0) {
+      state.position[1] = 0
+      state.velocity[1] = 0
+      state.onGround = true
+    } else {
+      state.onGround = false
+    }
+    return state
+  }
+
+  setPlayerPosition(playerId, position) {
+    const data = this.playerBodies.get(playerId)
+    if (data?.charId && this.physicsWorld) {
+      this.physicsWorld.setCharacterPosition(data.charId, position)
+    }
+  }
+
+  getPlayerPosition(playerId) {
+    const data = this.playerBodies.get(playerId)
+    if (data?.charId && this.physicsWorld) {
+      return this.physicsWorld.getCharacterPosition(data.charId)
+    }
+    return [0, 0, 0]
+  }
+
+  checkCollisionWithOthers(playerId, allPlayers) {
+    const data = this.playerBodies.get(playerId)
+    if (!data) return []
+    const pos = data.charId && this.physicsWorld
+      ? this.physicsWorld.getCharacterPosition(data.charId)
+      : [0, 0, 0]
+    const collisions = []
+    for (const other of allPlayers) {
+      if (other.id === playerId) continue
+      const otherPos = other.state?.position || other.position
+      if (!otherPos) continue
+      const dx = otherPos[0] - pos[0]
+      const dy = otherPos[1] - pos[1]
+      const dz = otherPos[2] - pos[2]
+      const distance = Math.sqrt(dx * dx + dy * dy + dz * dz)
+      const minDist = this.config.capsuleRadius * 2
+      if (distance < minDist && distance > 0) {
+        collisions.push({ playerId: other.id, distance, normal: [dx / distance, dy / distance, dz / distance] })
+      }
+    }
+    return collisions
+  }
+
+  raycast(origin, direction, maxDistance) {
+    if (!this.physicsWorld) return { hit: false, distance: maxDistance }
+    return this.physicsWorld.raycast(origin, direction, maxDistance)
+  }
+
+  validateMovement(playerId, newPosition, oldPosition) {
+    const distance = Math.hypot(
+      newPosition[0] - oldPosition[0],
+      newPosition[1] - oldPosition[1],
+      newPosition[2] - oldPosition[2]
+    )
+    if (distance > 2.0) return { valid: false, reason: 'move_too_far', distance }
+    return { valid: true }
+  }
+}

package/src/netcode/PlayerManager.js

@@ -0,0 +1,109 @@
+export class PlayerManager {
+  constructor() {
+    this.players = new Map()
+    this.nextPlayerId = 1
+    this.inputBuffers = new Map()
+  }
+
+  addPlayer(socket, initialState = {}) {
+    const playerId = this.nextPlayerId++
+    const pos = initialState.position || [0, 0, 0]
+    const player = {
+      id: playerId,
+      socket,
+      state: {
+        position: [...pos],
+        rotation: initialState.rotation || [0, 0, 0, 1],
+        velocity: initialState.velocity || [0, 0, 0],
+        angularVelocity: initialState.angularVelocity || [0, 0, 0],
+        onGround: true,
+        health: 100
+      },
+      inputSequence: 0,
+      lastInputTime: 0,
+      connected: true,
+      joinTime: Date.now()
+    }
+    this.players.set(playerId, player)
+    this.inputBuffers.set(playerId, [])
+    return playerId
+  }
+
+  removePlayer(playerId) {
+    this.players.delete(playerId)
+    this.inputBuffers.delete(playerId)
+  }
+
+  getPlayer(playerId) {
+    return this.players.get(playerId)
+  }
+
+  getAllPlayers() {
+    return Array.from(this.players.values())
+  }
+
+  getConnectedPlayers() {
+    return this.getAllPlayers().filter(p => p.connected)
+  }
+
+  getPlayerCount() {
+    return this.players.size
+  }
+
+  updatePlayerState(playerId, state) {
+    const player = this.players.get(playerId)
+    if (player) Object.assign(player.state, state)
+  }
+
+  addInput(playerId, input) {
+    const player = this.players.get(playerId)
+    if (!player) return
+    player.inputSequence++
+    player.lastInputTime = Date.now()
+    const inputs = this.inputBuffers.get(playerId)
+    if (inputs) {
+      inputs.push({ sequence: player.inputSequence, data: input, timestamp: Date.now() })
+      if (inputs.length > 128) inputs.shift()
+    }
+  }
+
+  getInputs(playerId) {
+    return this.inputBuffers.get(playerId) || []
+  }
+
+  clearInputs(playerId) {
+    const inputs = this.inputBuffers.get(playerId)
+    if (inputs) inputs.length = 0
+  }
+
+  broadcast(message) {
+    const json = JSON.stringify(message)
+    for (const player of this.getConnectedPlayers()) {
+      if (player.socket && player.socket.send) {
+        try { player.socket.send(json) } catch (e) {}
+      }
+    }
+  }
+
+  broadcastBinary(buffer) {
+    for (const player of this.getConnectedPlayers()) {
+      if (player.socket && player.socket.send) {
+        try { player.socket.send(buffer) } catch (e) {}
+      }
+    }
+  }
+
+  sendToPlayer(playerId, message) {
+    const player = this.players.get(playerId)
+    if (player && player.socket && player.socket.send) {
+      try { player.socket.send(JSON.stringify(message)) } catch (e) {}
+    }
+  }
+
+  sendBinaryToPlayer(playerId, buffer) {
+    const player = this.players.get(playerId)
+    if (player && player.socket && player.socket.send) {
+      try { player.socket.send(buffer) } catch (e) {}
+    }
+  }
+}

package/src/netcode/SnapshotEncoder.js

@@ -0,0 +1,49 @@
+function quantize(v, precision) {
+  return Math.round(v * precision) / precision
+}
+
+export class SnapshotEncoder {
+  static encode(snapshot) {
+    const players = (snapshot.players || []).map(p => [
+      p.id,
+      quantize(p.position[0], 100), quantize(p.position[1], 100), quantize(p.position[2], 100),
+      quantize(p.rotation[0], 10000), quantize(p.rotation[1], 10000), quantize(p.rotation[2], 10000), quantize(p.rotation[3], 10000),
+      quantize(p.velocity[0], 100), quantize(p.velocity[1], 100), quantize(p.velocity[2], 100),
+      p.onGround ? 1 : 0,
+      Math.round(p.health || 0),
+      p.inputSequence || 0
+    ])
+    const entities = (snapshot.entities || []).map(e => [
+      e.id,
+      e.model || '',
+      quantize(e.position[0], 100), quantize(e.position[1], 100), quantize(e.position[2], 100),
+      quantize(e.rotation[0], 10000), quantize(e.rotation[1], 10000), quantize(e.rotation[2], 10000), quantize(e.rotation[3], 10000),
+      e.bodyType || 'static',
+      e.custom || null
+    ])
+    return { tick: snapshot.tick || 0, timestamp: snapshot.timestamp || 0, players, entities }
+  }
+
+  static decode(data) {
+    if (data.players && Array.isArray(data.players)) {
+      const players = data.players.map(p => {
+        if (Array.isArray(p)) return {
+          id: p[0], position: [p[1], p[2], p[3]],
+          rotation: [p[4], p[5], p[6], p[7]],
+          velocity: [p[8], p[9], p[10]],
+          onGround: p[11] === 1, health: p[12], inputSequence: p[13]
+        }
+        return p
+      })
+      const entities = (data.entities || []).map(e => {
+        if (Array.isArray(e)) return {
+          id: e[0], model: e[1], position: [e[2], e[3], e[4]],
+          rotation: [e[5], e[6], e[7], e[8]], bodyType: e[9], custom: e[10]
+        }
+        return e
+      })
+      return { tick: data.tick, timestamp: data.timestamp, players, entities }
+    }
+    return data
+  }
+}