spoint 0.1.0 → 0.1.10

package/apps/environment/index.js

@@ -1,17 +1,216 @@
+import { SMART_OBJECT_TEMPLATES, getTemplate, isValidTemplate, getPlaceholderColor, getPlaceholderDimensions } from './smartObjects.js'
+import { readdirSync, statSync } from 'fs'
+import { join } from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = fileURLToPath(new URL('.', import.meta.url))
+const modelsDir = join(__dirname, 'models')
+
+function discoverModels() {
+  const registry = {}
+  try {
+    const categories = readdirSync(modelsDir).filter(f => statSync(join(modelsDir, f)).isDirectory())
+    for (const cat of categories) {
+      const catPath = join(modelsDir, cat)
+      const files = readdirSync(catPath).filter(f => f.endsWith('.glb') || f.endsWith('.gltf'))
+      registry[cat] = files
+    }
+  } catch (e) {
+    console.log('[Environment] Model discovery skipped (models dir not found)')
+  }
+  return registry
+}
+
 export default {
   server: {
     setup(ctx) {
       ctx.physics.setStatic(true)
       ctx.physics.addTrimeshCollider()
+
+      ctx.state.smartObjects = new Map()
+      ctx.state.editorMode = false
+      ctx.state.nextSmartObjectId = 0
+      ctx.state.modelRegistry = discoverModels()
+
+      ctx.debug.log(`[Environment] Initialized with ${Object.keys(SMART_OBJECT_TEMPLATES).length} smart object templates, ${Object.values(ctx.state.modelRegistry).flat().length} models discovered`)
+    },
+
+    update(ctx, dt) {
+      for (const [id, obj] of ctx.state.smartObjects) {
+        if (obj.template === 'platform') updatePlatform(ctx, id, obj, dt)
+        if (obj.template === 'hazard') updateHazard(ctx, id, obj, dt)
+      }
+    },
+
+    onEvent(payload, ctx) {
+      if (payload.type === 'dropModel' && payload.position && payload.modelPath) {
+        const id = `dropped_model_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
+        const entity = ctx.world.spawn(id, {
+          position: payload.position,
+          rotation: payload.rotation || [0, 0, 0, 1],
+          model: payload.modelPath
+        })
+        if (entity) {
+          entity.custom = {
+            droppedModel: true,
+            modelPath: payload.modelPath,
+            scale: payload.scale || [1, 1, 1]
+          }
+          ctx.debug.log(`[Environment] Dropped model spawned: ${id}`)
+        }
+      }
+    },
+
+    teardown(ctx) {
+      for (const id of ctx.state.smartObjects.keys()) {
+        ctx.world.destroy(id)
+      }
+      ctx.state.smartObjects.clear()
     }
   },
+
   client: {
     render(ctx) {
       return {
         model: ctx.entity.model,
         position: ctx.entity.position,
-        rotation: ctx.entity.rotation
+        rotation: ctx.entity.rotation,
+        custom: ctx.entity.custom
       }
     }
   }
 }
+
+function addCollider(ctx, collider) {
+  if (!collider) return
+
+  switch (collider.type) {
+    case 'box':
+      ctx.physics.addBoxCollider(collider.size)
+      break
+    case 'sphere':
+      ctx.physics.addSphereCollider(collider.radius)
+      break
+    case 'capsule':
+      ctx.physics.addCapsuleCollider(collider.radius, collider.halfHeight * 2)
+      break
+    case 'trimesh':
+      ctx.physics.addTrimeshCollider()
+      break
+  }
+}
+
+function updatePlatform(ctx, id, obj, dt) {
+  if (!obj.config || !obj.config.waypoints || obj.config.waypoints.length < 2) return
+
+  const waypoints = obj.config.waypoints
+  const speed = obj.config.speed || 5
+  const waitTime = obj.config.waitTime || 1
+
+  if (obj.waitTimer === undefined) obj.waitTimer = 0
+  if (obj.currentWaypoint === undefined) obj.currentWaypoint = 0
+
+  obj.waitTimer -= dt
+  if (obj.waitTimer > 0) return
+
+  const entity = ctx.world.getEntity(id)
+  if (!entity) return
+
+  const current = waypoints[obj.currentWaypoint]
+  const next = waypoints[(obj.currentWaypoint + 1) % waypoints.length]
+
+  const dx = next[0] - entity.position[0]
+  const dy = next[1] - entity.position[1]
+  const dz = next[2] - entity.position[2]
+  const dist = Math.sqrt(dx * dx + dy * dy + dz * dz)
+
+  if (dist < 0.1) {
+    obj.currentWaypoint = (obj.currentWaypoint + 1) % waypoints.length
+    obj.waitTimer = waitTime
+    return
+  }
+
+  const moveDistance = Math.min(speed * dt, dist)
+  entity.position[0] += (dx / dist) * moveDistance
+  entity.position[1] += (dy / dist) * moveDistance
+  entity.position[2] += (dz / dist) * moveDistance
+}
+
+function updateHazard(ctx, id, obj, dt) {
+  if (!obj.config) return
+  if (obj.damageTimer === undefined) obj.damageTimer = 0
+
+  obj.damageTimer -= dt
+  if (obj.damageTimer > 0) return
+
+  obj.damageTimer = obj.config.damageInterval || 0.5
+
+  const entity = ctx.world.getEntity(id)
+  if (!entity) return
+
+  const damage = obj.config.damage || 10
+  const players = ctx.players.getAll()
+
+  for (const player of players) {
+    if (!player.state) continue
+    const pp = player.state.position
+    const dx = pp[0] - entity.position[0]
+    const dy = pp[1] - entity.position[1]
+    const dz = pp[2] - entity.position[2]
+    const dist = Math.sqrt(dx * dx + dy * dy + dz * dz)
+    const radius = obj.collider?.radius || 2
+
+    if (dist < radius) {
+      player.state.health = Math.max(0, (player.state.health || 100) - damage * dt)
+      ctx.network.broadcast({ type: 'hazard_damage', playerId: player.id, damage: Math.round(damage * dt) })
+    }
+  }
+}
+
+function spawnSmartObject(ctx, templateName, position, rotation = [0, 0, 0, 1], parent = null) {
+  if (!isValidTemplate(templateName)) {
+    ctx.debug.log(`[Environment] Invalid template: ${templateName}`)
+    return null
+  }
+
+  const template = getTemplate(templateName)
+  const id = `smart_${templateName}_${ctx.state.nextSmartObjectId++}`
+
+  const entity = ctx.world.spawn(id, {
+    position,
+    rotation,
+    parent,
+    model: template.model
+  })
+
+  if (!entity) return null
+
+  const isEditor = ctx.state.editorMode
+
+  entity.custom = {
+    smartObject: true,
+    template: templateName,
+    editorPlaceholder: isEditor,
+    color: getPlaceholderColor(templateName)
+  }
+
+  ctx.state.smartObjects.set(id, {
+    template: templateName,
+    config: { ...template.config },
+    collider: template.collider
+  })
+
+  if (!isEditor && template.collider) {
+    addCollider(ctx, template.collider)
+  }
+
+  return entity
+}
+
+export const spawn = (ctx, template, position, config) => {
+  const obj = spawnSmartObject(ctx, template, position)
+  if (obj && config) Object.assign(ctx.state.smartObjects.get(obj.id).config, config)
+  return obj
+}
+
+export const setEditorMode = (ctx, enabled) => { ctx.state.editorMode = enabled }

package/apps/environment/smartObjects.js

@@ -0,0 +1,114 @@
+// Smart Object Templates
+// Define behavior, physics, and visual properties for environment entities
+
+export const SMART_OBJECT_TEMPLATES = {
+  door: {
+    displayName: 'Door',
+    model: null,
+    collider: { type: 'box', size: [1.5, 2.5, 0.1] },
+    physics: 'kinematic',
+    editorPlaceholder: { color: 0x0066ff, dims: [1.5, 2.5, 0.1] },
+    config: {
+      open: false,
+      openTime: 0.5,
+      closeTime: 0.5,
+      openAngle: Math.PI / 2
+    }
+  },
+
+  platform: {
+    displayName: 'Moving Platform',
+    model: null,
+    collider: { type: 'box', size: [4, 0.5, 4] },
+    physics: 'kinematic',
+    editorPlaceholder: { color: 0x00cc00, dims: [4, 0.5, 4] },
+    config: {
+      waypoints: [[0, 0, 0]],
+      speed: 5,
+      waitTime: 1
+    }
+  },
+
+  trigger: {
+    displayName: 'Trigger Volume',
+    model: null,
+    collider: { type: 'box', size: [2, 3, 2] },
+    physics: 'trigger',
+    editorPlaceholder: { color: 0xffff00, dims: [2, 3, 2] },
+    config: {
+      eventName: 'trigger',
+      oneshot: false
+    }
+  },
+
+  hazard: {
+    displayName: 'Hazard Zone',
+    model: null,
+    collider: { type: 'sphere', radius: 2 },
+    physics: 'trigger',
+    editorPlaceholder: { color: 0xff0000, dims: [2, 2, 2] },
+    config: {
+      damage: 10,
+      damageInterval: 0.5
+    }
+  },
+
+  lootBox: {
+    displayName: 'Loot Box',
+    model: null,
+    collider: { type: 'box', size: [1, 1.5, 1] },
+    physics: 'dynamic',
+    editorPlaceholder: { color: 0x885533, dims: [1, 1.5, 1] },
+    config: {
+      lootType: 'ammo',
+      quantity: 30,
+      openSound: 'open'
+    }
+  },
+
+  pillar: {
+    displayName: 'Pillar/Column',
+    model: null,
+    collider: { type: 'capsule', radius: 0.5, halfHeight: 2 },
+    physics: 'static',
+    editorPlaceholder: { color: 0x888888, dims: [1, 4, 1] },
+    config: {
+      decorative: true
+    }
+  }
+}
+
+// Editor placeholder color mapping
+export const PLACEHOLDER_COLORS = {
+  door: 0x0066ff,      // Blue
+  platform: 0x00cc00,  // Green
+  trigger: 0xffff00,   // Yellow
+  hazard: 0xff0000,    // Red
+  lootBox: 0x885533,   // Brown
+  pillar: 0x888888,    // Gray
+  unknown: 0xcccccc    // Light gray
+}
+
+// Get placeholder color for a template
+export function getPlaceholderColor(templateName) {
+  return PLACEHOLDER_COLORS[templateName] || PLACEHOLDER_COLORS.unknown
+}
+
+// Get placeholder dimensions for a template
+export function getPlaceholderDimensions(templateName) {
+  const template = SMART_OBJECT_TEMPLATES[templateName]
+  if (!template || !template.editorPlaceholder) {
+    return [1, 1, 1]
+  }
+  return template.editorPlaceholder.dims
+}
+
+// Validate template exists and is accessible
+export function isValidTemplate(templateName) {
+  return templateName in SMART_OBJECT_TEMPLATES
+}
+
+// Get template definition
+export function getTemplate(templateName) {
+  return SMART_OBJECT_TEMPLATES[templateName] || null
+}

package/apps/interactable/index.js

@@ -0,0 +1,155 @@
+export default {
+  server: {
+    setup(ctx) {
+      ctx.entity.custom = { mesh: 'box', color: 0x00ff88, sx: 1.5, sy: 0.5, sz: 1.5, label: 'INTERACT' }
+      ctx.state.interactionRadius = 3.5
+      ctx.state.interactionCooldown = new Map()
+      ctx.state.interactionCount = 0
+
+      ctx.physics.setStatic(true)
+      ctx.physics.addBoxCollider([0.75, 0.25, 0.75])
+
+      ctx.time.every(0.1, () => {
+        const nearby = ctx.players.getNearest(ctx.entity.position, ctx.state.interactionRadius)
+        if (!nearby) return
+
+        const now = Date.now()
+        const playerId = nearby.id
+        const lastInteract = ctx.state.interactionCooldown.get(playerId) || 0
+
+        if (nearby.state?.interact && now - lastInteract > 500) {
+          ctx.state.interactionCooldown.set(playerId, now)
+          ctx.state.interactionCount++
+
+          const messages = [
+            'Hello there!',
+            'You found the interact button!',
+            'Nice to meet you!',
+            'This button works!',
+            `Interacted ${ctx.state.interactionCount} times total`
+          ]
+          const msg = messages[ctx.state.interactionCount % messages.length]
+
+          ctx.players.send(playerId, {
+            type: 'interact_response',
+            message: msg,
+            count: ctx.state.interactionCount
+          })
+
+          ctx.network.broadcast({
+            type: 'interact_effect',
+            position: ctx.entity.position,
+            playerId: playerId
+          })
+        }
+      })
+    },
+
+    teardown(ctx) {
+      ctx.state.interactionCooldown?.clear()
+    },
+
+    onMessage(ctx, msg) {
+      if (msg.type === 'player_leave') {
+        ctx.state.interactionCooldown?.delete(msg.playerId)
+      }
+    }
+  },
+
+  client: {
+    setup(engine) {
+      this._lastMessage = null
+      this._messageExpire = 0
+      this._showingInteract = false
+      this._isMobile = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)
+      this._wasRegistered = false
+    },
+
+    onFrame(dt, engine) {
+      const ent = engine.client?.state?.entities?.find(e => e.app === 'interactable')
+      const pos = ent?.position
+      const local = engine.client?.state?.players?.find(p => p.id === engine.playerId)
+      if (!pos || !local?.position) {
+        if (this._wasRegistered) {
+          engine.mobileControls?.unregisterInteractable(ent?.id || 'interactable')
+          this._wasRegistered = false
+        }
+        return
+      }
+
+      const dx = pos[0] - local.position[0]
+      const dy = pos[1] - local.position[1]
+      const dz = pos[2] - local.position[2]
+      const dist = Math.sqrt(dx * dx + dy * dy + dz * dz)
+      const canInteract = dist < 3.5
+
+      if (canInteract && !this._wasRegistered) {
+        engine.mobileControls?.registerInteractable(ent.id, 'INTERACT')
+        this._wasRegistered = ent.id
+      } else if (!canInteract && this._wasRegistered) {
+        engine.mobileControls?.unregisterInteractable(this._wasRegistered)
+        this._wasRegistered = false
+      }
+
+      this._canInteract = canInteract
+    },
+
+    teardown(engine) {
+      if (this._wasRegistered) {
+        engine.mobileControls?.unregisterInteractable('interactable')
+        this._wasRegistered = false
+      }
+    },
+
+    onInput(input, engine) {
+      if (input.interact && !this._wasInteracting) {
+        this._showingInteract = true
+        this._messageExpire = Date.now() + 2000
+      }
+      this._wasInteracting = input.interact
+    },
+
+    onEvent(payload, engine) {
+      if (payload.type === 'interact_response') {
+        this._lastMessage = payload.message
+        this._messageExpire = Date.now() + 3000
+      }
+      if (payload.type === 'interact_effect') {
+        this._lastMessage = 'Someone interacted!'
+        this._messageExpire = Date.now() + 1500
+      }
+    },
+
+    render(ctx) {
+      const h = ctx.h
+      const pos = ctx.entity.position
+      if (!h || !pos) return { position: pos }
+
+      const ui = []
+
+      if (this._lastMessage && Date.now() < this._messageExpire) {
+        const timeLeft = (this._messageExpire - Date.now()) / 3000
+        const opacity = Math.min(1, timeLeft * 2)
+        ui.push(
+          h('div', {
+            style: `position:fixed;top:30%;left:50%;transform:translate(-50%,-50%);padding:16px 32px;background:rgba(0,0,0,0.8);border-radius:12px;color:#0f0;font-weight:bold;font-size:20px;text-align:center;border:2px solid #0f0;opacity:${opacity}`
+          }, this._lastMessage)
+        )
+      }
+
+      const custom = { ...ctx.entity.custom }
+      if (this._canInteract) {
+        custom.glow = true
+        custom.glowColor = 0x00ff88
+        custom.glowIntensity = 0.5
+      }
+
+      return {
+        position: pos,
+        rotation: ctx.entity.rotation,
+        custom,
+        ui: ui.length > 0 ? h('div', null, ...ui) : null
+      }
+    }
+  }
+}

package/apps/physics-crate/index.js

@@ -1,23 +1,29 @@
 export default {
   server: {
     setup(ctx) {
+      ctx.entity.custom = { mesh: 'box', color: 0xff8800, sx: 1, sy: 1, sz: 1 }
       ctx.physics.setDynamic(true)
       ctx.physics.setMass(10)
-      ctx.physics.addBoxCollider([1, 1, 1])
+      ctx.physics.addBoxCollider([0.5, 0.5, 0.5])
     },
-    onCollision(ctx, other) {
-      if (other.velocity > 5) {
-        ctx.entity.destroy()
+    teardown(ctx) {
+      const ent = ctx._entity
+      if (ent?._physicsBodyId && ctx._runtime?._physics) {
+        ctx._runtime._physics.removeBody(ent._physicsBodyId)
+        ent._physicsBodyId = null
       }
+    },
+    update(ctx, dt) {
+      const ent = ctx._entity
+      if (!ent?._physicsBodyId || !ctx._runtime?._physics) return
+      const pw = ctx._runtime._physics
+      ent.position = pw.getBodyPosition(ent._physicsBodyId)
+      ent.rotation = pw.getBodyRotation(ent._physicsBodyId)
     }
   },
   client: {
     render(ctx) {
-      return {
-        model: ctx.entity.model,
-        position: ctx.entity.position,
-        rotation: ctx.entity.rotation
-      }
+      return { position: ctx.entity.position, rotation: ctx.entity.rotation, custom: ctx.entity.custom }
     }
   }
 }

package/apps/power-crate/index.js

@@ -1,7 +1,8 @@
 const CONFIG = {
-  spawnInterval: 120,
+  spawnInterval: 30,
   pickupRadius: 2.5,
   pickupLifetime: 30,
+  maxCrates: 20,
   crateHitRadius: 1.5,
   buffDuration: 45,
   speedMultiplier: 1.2,
@@ -19,7 +20,7 @@ const CONFIG = {
 export default {
   server: {
     setup(ctx) {
-      ctx.state.crates = ctx.state.crates || new Map()
+      ctx.state.crates = ctx.state.crates || new Set()
       ctx.state.pickups = ctx.state.pickups || new Map()
       ctx.state.spawnPoints = findSpawnPoints(ctx)
       ctx.state.nextCrateId = ctx.state.nextCrateId || 0
@@ -30,6 +31,8 @@ export default {
       })
 
       console.log(`[power-crate] ${ctx.state.spawnPoints.length} spawn points, interval ${CONFIG.spawnInterval}s`)
+      const initialCount = Math.min(5, ctx.state.spawnPoints.length)
+      for (let i = 0; i < initialCount; i++) spawnCrate(ctx)
     },
 
     update(ctx, dt) {
@@ -44,7 +47,7 @@ export default {
     },
 
     teardown(ctx) {
-      for (const id of ctx.state.crates.keys()) ctx.world.destroy(id)
+      for (const id of ctx.state.crates) ctx.world.destroy(id)
       for (const id of ctx.state.pickups.keys()) ctx.world.destroy(id)
       ctx.state.crates.clear()
       ctx.state.pickups.clear()
@@ -78,14 +81,12 @@ function findSpawnPoints(ctx) {
 function spawnCrate(ctx) {
   const sp = ctx.state.spawnPoints
   if (sp.length === 0) return
+  if (ctx.state.crates.size >= CONFIG.maxCrates) return
   const pos = sp[Math.floor(Math.random() * sp.length)]
   const id = `power_crate_${ctx.state.nextCrateId++}`
-  ctx.world.spawn(id, {
-    model: './world/crate.glb',
-    position: [...pos],
-    app: 'physics-crate'
-  })
-  ctx.state.crates.set(id, [...pos])
+  const e = ctx.world.spawn(id, { position: [...pos] })
+  if (e) e.custom = { mesh: 'box', color: 0xff8800, sx: 1, sy: 1, sz: 1, hover: 0.15, spin: 1 }
+  ctx.state.crates.add(id)
 }
 
 function handleFireEvent(ctx, data) {
@@ -93,7 +94,10 @@ function handleFireEvent(ctx, data) {
   const origin = data.origin
   const direction = data.direction
 
-  for (const [crateId, cratePos] of ctx.state.crates) {
+  for (const crateId of ctx.state.crates) {
+    const ent = ctx.world.getEntity(crateId)
+    if (!ent) continue
+    const cratePos = ent.position
     const toTarget = [
       cratePos[0] - origin[0],
       cratePos[1] - origin[1],
@@ -113,16 +117,18 @@ function handleFireEvent(ctx, data) {
     )
     if (dist > CONFIG.crateHitRadius) continue
 
+    const hitPos = [cratePos[0], cratePos[1], cratePos[2]]
     ctx.world.destroy(crateId)
     ctx.state.crates.delete(crateId)
-    spawnPickup(ctx, cratePos)
+    spawnPickup(ctx, hitPos)
     break
   }
 }
 
 function spawnPickup(ctx, pos) {
   const id = `powerup_${ctx.state.nextCrateId++}`
-  ctx.world.spawn(id, { position: [...pos] })
+  const e = ctx.world.spawn(id, { position: [...pos] })
+  if (e) e.custom = { mesh: 'cylinder', r: 0.4, h: 0.1, seg: 16, color: 0xffd700, roughness: 0.3, metalness: 0.8, emissive: 0xffa000, emissiveIntensity: 0.3, rotZ: Math.PI / 2, light: 0xffd700, lightIntensity: 1, lightRange: 4, spin: 3, hover: 0.3 }
   ctx.state.pickups.set(id, { position: [...pos], lifetime: CONFIG.pickupLifetime })
 }