spoint 0.1.492 → 0.1.493

package/README.md

@@ -165,6 +165,16 @@ npm run bots
 
 Env vars: `BOT_COUNT`, `BOT_DURATION`, `BOT_HZ`, `BOT_URL`
 
+## Documentation
+
+- **Getting Started**: `docs/getting-started.md` — Full tutorial, world/app creation, API reference
+- **Quick Reference**: `docs/quick-reference.md` — Cheatsheet for config, physics, client, network messages
+- **Architecture**: `docs/architecture-decisions.md`
+- **Rendering**: `docs/rendering.md`
+- **Editor**: `docs/editor-composing.md`
+- **Publishing**: `docs/publish.md`
+- **Anticheat**: `docs/anticheat.md`
+
 ## License
 
 MIT

package/apps/matrix-construct-room/index.js

@@ -0,0 +1,267 @@
+export default {
+  server: {
+    setup(ctx) {
+      const roomSize = 30
+      const wallHeight = 8
+      const wallThickness = 0.5
+
+      // Floor
+      ctx.physics.addColliderFromConfig({
+        type: 'box',
+        size: [roomSize / 2, wallThickness / 2, roomSize / 2],
+        position: [0, -wallThickness / 2, 0],
+        mass: 0,
+        dynamic: false
+      })
+
+      // Ceiling
+      ctx.physics.addColliderFromConfig({
+        type: 'box',
+        size: [roomSize / 2, wallThickness / 2, roomSize / 2],
+        position: [0, wallHeight + wallThickness / 2, 0],
+        mass: 0,
+        dynamic: false
+      })
+
+      // Walls - back (negative Z)
+      ctx.physics.addColliderFromConfig({
+        type: 'box',
+        size: [roomSize / 2, wallHeight / 2, wallThickness / 2],
+        position: [0, wallHeight / 2, -roomSize / 2],
+        mass: 0,
+        dynamic: false
+      })
+
+      // Walls - front (positive Z)
+      ctx.physics.addColliderFromConfig({
+        type: 'box',
+        size: [roomSize / 2, wallHeight / 2, wallThickness / 2],
+        position: [0, wallHeight / 2, roomSize / 2],
+        mass: 0,
+        dynamic: false
+      })
+
+      // Walls - left (negative X)
+      ctx.physics.addColliderFromConfig({
+        type: 'box',
+        size: [wallThickness / 2, wallHeight / 2, roomSize / 2],
+        position: [-roomSize / 2, wallHeight / 2, 0],
+        mass: 0,
+        dynamic: false
+      })
+
+      // Walls - right (positive X)
+      ctx.physics.addColliderFromConfig({
+        type: 'box',
+        size: [wallThickness / 2, wallHeight / 2, roomSize / 2],
+        position: [roomSize / 2, wallHeight / 2, 0],
+        mass: 0,
+        dynamic: false
+      })
+
+      // Store room dimensions for client rendering
+      ctx.state.roomSize = roomSize
+      ctx.state.wallHeight = wallHeight
+      ctx.state.wallThickness = wallThickness
+      ctx.state.gridSize = 2
+    }
+  },
+  client: {
+    setup(engine) {
+      // Create the white room with grid lines
+      this.createConstructRoom(engine)
+    },
+    render(ctx) {
+      return {
+        position: [0, 0, 0],
+        rotation: [0, 0, 0, 1],
+        custom: {
+          // Empty - we create the room in setup
+        }
+      }
+    },
+    createConstructRoom(engine) {
+      const { THREE, scene } = engine
+      const roomSize = 30
+      const wallHeight = 8
+      const wallThickness = 0.5
+      const gridSize = 2
+
+      // White material with slight emissive glow
+      const whiteMaterial = new THREE.MeshStandardMaterial({
+        color: 0xffffff,
+        roughness: 0.1,
+        metalness: 0,
+        emissive: 0x222222,
+        emissiveIntensity: 0.3,
+        side: THREE.DoubleSide
+      })
+
+      // Grid line material - subtle gray
+      const gridMaterial = new THREE.MeshStandardMaterial({
+        color: 0x888888,
+        roughness: 0.3,
+        metalness: 0,
+        emissive: 0x111111,
+        emissiveIntensity: 0.1,
+        side: THREE.DoubleSide,
+        transparent: true,
+        opacity: 0.4
+      })
+
+      // Bright grid line material for main axes
+      const axisMaterial = new THREE.MeshStandardMaterial({
+        color: 0xcccccc,
+        roughness: 0.2,
+        metalness: 0,
+        emissive: 0x333333,
+        emissiveIntensity: 0.2,
+        side: THREE.DoubleSide
+      })
+
+      // Floor
+      const floorGeo = new THREE.BoxGeometry(roomSize, wallThickness, roomSize)
+      const floor = new THREE.Mesh(floorGeo, whiteMaterial)
+      floor.position.set(0, -wallThickness / 2, 0)
+      floor.receiveShadow = true
+      scene.add(floor)
+
+      // Ceiling
+      const ceilGeo = new THREE.BoxGeometry(roomSize, wallThickness, roomSize)
+      const ceil = new THREE.Mesh(ceilGeo, whiteMaterial)
+      ceil.position.set(0, wallHeight + wallThickness / 2, 0)
+      scene.add(ceil)
+
+      // Walls
+      const wallGeo = new THREE.BoxGeometry(roomSize, wallHeight, wallThickness)
+      const sideWallGeo = new THREE.BoxGeometry(wallThickness, wallHeight, roomSize)
+
+      // Back wall (negative Z)
+      const backWall = new THREE.Mesh(wallGeo, whiteMaterial)
+      backWall.position.set(0, wallHeight / 2, -roomSize / 2)
+      backWall.receiveShadow = true
+      scene.add(backWall)
+
+      // Front wall (positive Z)
+      const frontWall = new THREE.Mesh(wallGeo, whiteMaterial)
+      frontWall.position.set(0, wallHeight / 2, roomSize / 2)
+      frontWall.receiveShadow = true
+      scene.add(frontWall)
+
+      // Left wall (negative X)
+      const leftWall = new THREE.Mesh(sideWallGeo, whiteMaterial)
+      leftWall.position.set(-roomSize / 2, wallHeight / 2, 0)
+      leftWall.receiveShadow = true
+      scene.add(leftWall)
+
+      // Right wall (positive X)
+      const rightWall = new THREE.Mesh(sideWallGeo, whiteMaterial)
+      rightWall.position.set(roomSize / 2, wallHeight / 2, 0)
+      rightWall.receiveShadow = true
+      scene.add(rightWall)
+
+      // Grid lines on floor
+      const lineThickness = 0.05
+      const lineGeo = new THREE.BoxGeometry(roomSize, lineThickness, lineThickness)
+      const crossLineGeo = new THREE.BoxGeometry(lineThickness, lineThickness, roomSize)
+
+      // Floor grid
+      for (let i = -roomSize / 2; i <= roomSize / 2; i += gridSize) {
+        // X-axis lines
+        const lineX = new THREE.Mesh(lineGeo, i === 0 ? axisMaterial : gridMaterial)
+        lineX.position.set(0, lineThickness / 2, i)
+        scene.add(lineX)
+
+        // Z-axis lines
+        const lineZ = new THREE.Mesh(crossLineGeo, i === 0 ? axisMaterial : gridMaterial)
+        lineZ.position.set(i, lineThickness / 2, 0)
+        scene.add(lineZ)
+      }
+
+      // Wall grids - back wall
+      const wallLineGeoH = new THREE.BoxGeometry(roomSize, lineThickness, lineThickness)
+      const wallLineGeoV = new THREE.BoxGeometry(lineThickness, wallHeight, lineThickness)
+
+      for (let i = -roomSize / 2; i <= roomSize / 2; i += gridSize) {
+        // Horizontal lines
+        const hLine = new THREE.Mesh(wallLineGeoH, i === 0 ? axisMaterial : gridMaterial)
+        hLine.position.set(0, -wallHeight / 2 + i + wallHeight / 2, -roomSize / 2 + wallThickness / 2 + lineThickness)
+        scene.add(hLine)
+
+        // Vertical lines
+        const vLine = new THREE.Mesh(wallLineGeoV, i === 0 ? axisMaterial : gridMaterial)
+        vLine.position.set(-roomSize / 2 + i, 0, -roomSize / 2 + wallThickness / 2 + lineThickness)
+        scene.add(vLine)
+      }
+
+      // Front wall grid
+      for (let i = -roomSize / 2; i <= roomSize / 2; i += gridSize) {
+        const hLine = new THREE.Mesh(wallLineGeoH, i === 0 ? axisMaterial : gridMaterial)
+        hLine.position.set(0, -wallHeight / 2 + i + wallHeight / 2, roomSize / 2 - wallThickness / 2 - lineThickness)
+        scene.add(hLine)
+
+        const vLine = new THREE.Mesh(wallLineGeoV, i === 0 ? axisMaterial : gridMaterial)
+        vLine.position.set(-roomSize / 2 + i, 0, roomSize / 2 - wallThickness / 2 - lineThickness)
+        scene.add(vLine)
+      }
+
+      // Left wall grid
+      const sideWallLineGeoH = new THREE.BoxGeometry(lineThickness, lineThickness, roomSize)
+      const sideWallLineGeoV = new THREE.BoxGeometry(lineThickness, wallHeight, lineThickness)
+
+      for (let i = -roomSize / 2; i <= roomSize / 2; i += gridSize) {
+        const hLine = new THREE.Mesh(sideWallLineGeoH, i === 0 ? axisMaterial : gridMaterial)
+        hLine.position.set(-roomSize / 2 + wallThickness / 2 + lineThickness, -wallHeight / 2 + i + wallHeight / 2, 0)
+        scene.add(hLine)
+
+        const vLine = new THREE.Mesh(sideWallLineGeoV, i === 0 ? axisMaterial : gridMaterial)
+        vLine.position.set(-roomSize / 2 + wallThickness / 2 + lineThickness, 0, -roomSize / 2 + i)
+        scene.add(vLine)
+      }
+
+      // Right wall grid
+      for (let i = -roomSize / 2; i <= roomSize / 2; i += gridSize) {
+        const hLine = new THREE.Mesh(sideWallLineGeoH, i === 0 ? axisMaterial : gridMaterial)
+        hLine.position.set(roomSize / 2 - wallThickness / 2 - lineThickness, -wallHeight / 2 + i + wallHeight / 2, 0)
+        scene.add(hLine)
+
+        const vLine = new THREE.Mesh(sideWallLineGeoV, i === 0 ? axisMaterial : gridMaterial)
+        vLine.position.set(roomSize / 2 - wallThickness / 2 - lineThickness, 0, -roomSize / 2 + i)
+        scene.add(vLine)
+      }
+
+      // Ceiling grid
+      for (let i = -roomSize / 2; i <= roomSize / 2; i += gridSize) {
+        const lineX = new THREE.Mesh(lineGeo, i === 0 ? axisMaterial : gridMaterial)
+        lineX.position.set(0, wallHeight + wallThickness - lineThickness / 2, i)
+        scene.add(lineX)
+
+        const lineZ = new THREE.Mesh(crossLineGeo, i === 0 ? axisMaterial : gridMaterial)
+        lineZ.position.set(i, wallHeight + wallThickness - lineThickness / 2, 0)
+        scene.add(lineZ)
+      }
+
+      // Add subtle point lights for that construct glow
+      const centerLight = new THREE.PointLight(0xffffff, 2, 50)
+      centerLight.position.set(0, wallHeight / 2, 0)
+      scene.add(centerLight)
+
+      // Corner accent lights
+      const cornerPositions = [
+        [-roomSize / 2 + 2, wallHeight - 2, -roomSize / 2 + 2],
+        [roomSize / 2 - 2, wallHeight - 2, -roomSize / 2 + 2],
+        [-roomSize / 2 + 2, wallHeight - 2, roomSize / 2 - 2],
+        [roomSize / 2 - 2, wallHeight - 2, roomSize / 2 - 2]
+      ]
+
+      cornerPositions.forEach(pos => {
+        const light = new THREE.PointLight(0xffffff, 0.5, 15)
+        light.position.set(...pos)
+        scene.add(light)
+      })
+
+      // Store reference for cleanup if needed
+      this.constructRoom = { floor, ceil, backWall, frontWall, leftWall, rightWall }
+    }
+  }
+}

package/apps/world/matrix-construct.js

@@ -0,0 +1,96 @@
+const MATRIX_CONSTRUCT = {
+  enabled: false,
+  anchorDir: [0, 1, 0],
+  radius: 1000,
+  reliefScale: 0,
+  maxLevel: 0,
+  offsetY: 0,
+  center: [0, 0],
+  physics: { extent: 1, resolution: 1 },
+  seed: 0,
+  timeOfDay: { serverAuthoritative: true, dayLengthSec: 600, startFraction: 0.5 },
+  weather: { serverAuthoritative: true, type: 'clear', intensity: 0, particleCount: 0 },
+  vegetation: { enabled: false }
+}
+
+export default {
+  port: 3001,
+  tickRate: 64,
+  entityTickRate: 15,
+  gravity: [0, -9.81, 0],
+  relevanceRadius: 100,
+  physicsRadius: 50,
+  physicsBodyBudget: 128,
+  movement: {
+    maxSpeed: 7.0,
+    sprintSpeed: 12.0,
+    groundAccel: 300.0,
+    airAccel: 30.0,
+    airMaxSpeed: 0.15,
+    airSpeedCap: 16.0,
+    friction: 5.0,
+    stopSpeed: 1.0,
+    jumpImpulse: 5.5,
+    collisionRestitution: 0.2,
+    collisionDamping: 0.25
+  },
+  player: {
+    health: 100,
+    capsuleRadius: 0.28,
+    capsuleHalfHeight: 0.63,
+    crouchHalfHeight: 0.315,
+    mass: 120,
+    modelScale: 1.323,
+    feetOffset: 0.212
+  },
+  scene: {
+    skyColor: 0xffffff,
+    fogColor: 0xffffff,
+    fogNear: 500,
+    fogFar: 1000,
+    ambientColor: 0xffffff,
+    ambientIntensity: 0.8,
+    sunColor: 0xffffff,
+    sunIntensity: 0.5,
+    sunPosition: [0, 100, 0],
+    fillColor: 0xffffff,
+    fillIntensity: 0.5,
+    fillPosition: [0, 50, 0],
+    shadowMapSize: 1024,
+    shadowBias: 0.001,
+    shadowNormalBias: 0.1
+  },
+  camera: {
+    fov: 70,
+    shoulderOffset: 0.35,
+    shoulderOffsets: [0, 0.55, 0.35, 0.1, 0.0],
+    headHeight: 1.85,
+    zoomStages: [0, 2, 4, 8, 18],
+    defaultZoomIndex: 2,
+    followSpeed: 12.0,
+    snapSpeed: 30.0,
+    mouseSensitivity: 0.002,
+    pitchRange: [-1.4, 1.4]
+  },
+  animation: {
+    mixerTimeScale: 1.3,
+    walkTimeScale: 2.4,
+    jogTimeScale: 1.9,
+    sprintTimeScale: 1.0,
+    fadeTime: 0.15
+  },
+  trustedApps: ['matrix-construct-room', 'tps-game'],
+  placeableApps: [],
+  terrain: MATRIX_CONSTRUCT,
+  entities: [
+    { id: 'terrain', app: 'terrain', config: MATRIX_CONSTRUCT },
+    { id: 'matrix-room', app: 'matrix-construct-room', position: [0, 0, 0] },
+    { id: 'tps-game', position: [0, 0, 0], app: 'tps-game' }
+  ],
+  spawnPoint: [0, 2, 0],
+  playerModel: './apps/tps-game/cleetus.vrm',
+  iceServers: [
+    { urls: 'stun:stun.l.google.com:19302' },
+    { urls: 'turn:openrelay.metered.ca:443?transport=tcp', username: 'openrelayproject', credential: 'openrelayproject' }
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spoint",
-  "version": "0.1.492",
+  "version": "0.1.493",
   "description": "Physics and netcode SDK for multiplayer game servers",
   "type": "module",
   "workspaces": [