@vib3code/sdk 2.0.3-canary.d0c4221 → 2.0.3-canary.d677f12

package/src/experimental/demos/CrystalLabyrinth.js

@@ -0,0 +1,202 @@
+/**
+ * CrystalLabyrinth.js - Vertical Slice Demo
+ *
+ * Implements the full "Ultra" stack:
+ * - VIB3Universe (Multi-instance)
+ * - VIB3Orchestrator (Game Loop)
+ * - VIB3Compositor (Visuals)
+ * - LatticePhysics (4D Collision)
+ * - PlayerController4D (Input)
+ * - LiveDirector (AI Pacing)
+ *
+ * @experimental
+ */
+import { VIB3Universe } from '../VIB3Universe.js';
+import { GameLoop } from '../GameLoop.js';
+import { LatticePhysics } from '../LatticePhysics.js';
+import { PlayerController4D } from '../PlayerController4D.js';
+import { LiveDirector } from '../LiveDirector.js';
+
+class CrystalLabyrinthGame {
+    constructor() {
+        this.universe = new VIB3Universe('vib3-universe');
+        this.physics = new LatticePhysics();
+        this.director = new LiveDirector(this.universe);
+
+        // Game State
+        this.score = 0;
+        this.health = 100;
+        this.isPlaying = false;
+
+        // Entities
+        this.player = null; // The "Camera"
+        this.crystals = [];
+        this.shadows = [];
+
+        // UI
+        this.ui = {
+            score: document.getElementById('score'),
+            health: document.getElementById('health'),
+            overlay: document.getElementById('overlay'),
+            startBtn: document.getElementById('start-btn')
+        };
+
+        // Bind input
+        this.controller = new PlayerController4D(document.body, {
+            setParameter: (k, v) => this.updatePlayerView(k, v)
+        });
+
+        // Setup Loop
+        this.loop = new GameLoop(
+            (dt) => this.update(dt),
+            (alpha) => this.render(alpha)
+        );
+
+        this.init();
+    }
+
+    async init() {
+        // Create the "World" (Background Layer)
+        // A deep, slow-moving Holographic system representing the void
+        const world = await this.universe.spawnActor({
+            personality: 'neutral',
+            system: 'holographic',
+            geometry: 11, // Hypersphere
+            layer: { zIndex: 0, opacity: 0.4 }
+        });
+
+        // Setup UI listeners
+        this.ui.startBtn.addEventListener('click', () => this.start());
+    }
+
+    start() {
+        this.isPlaying = true;
+        this.ui.overlay.classList.add('hidden');
+
+        // Start Systems
+        this.universe.start();
+        this.loop.start();
+        this.director.start();
+
+        // Spawn Level
+        this.spawnLevel();
+    }
+
+    async spawnLevel() {
+        // Spawn 5 Crystals (Pickups)
+        for (let i = 0; i < 5; i++) {
+            const crystal = await this.universe.spawnActor({
+                personality: 'heroic', // Bright, positive
+                system: 'faceted',
+                geometry: 7, // Crystal
+                layer: { zIndex: 10, blendMode: 'screen', opacity: 0.9 }
+            });
+
+            // Random position in 4D space (mock)
+            crystal.physics = {
+                pos: {
+                    x: (Math.random() - 0.5) * 20,
+                    y: (Math.random() - 0.5) * 5,
+                    z: (Math.random() - 0.5) * 20
+                },
+                vel: { x: 0, y: 0, z: 0 },
+                acc: { x: 0, y: 0, z: 0 }
+            };
+
+            this.crystals.push(crystal);
+        }
+
+        // Spawn 3 Shadows (Enemies)
+        for (let i = 0; i < 3; i++) {
+            const shadow = await this.universe.spawnActor({
+                personality: 'glitch', // Chaotic, negative
+                system: 'quantum',
+                geometry: 16, // Spiky
+                layer: { zIndex: 5, blendMode: 'multiply', opacity: 0.7 }
+            });
+
+            shadow.physics = {
+                pos: { x: 0, y: 0, z: -30 }, // Start far away
+                vel: { x: 0, y: 0, z: 0 },
+                acc: { x: 0, y: 0, z: 0 }
+            };
+
+            this.shadows.push(shadow);
+        }
+    }
+
+    /**
+     * Physics Update (Fixed Timestep)
+     */
+    update(dt) {
+        if (!this.isPlaying) return;
+
+        // 1. Update Player Controls
+        this.controller.update(dt);
+
+        // 2. Update Physics World
+        // Sync player controller state to physics engine?
+        // For now, controller handles movement directly.
+
+        // 3. AI Logic (Shadows hunt player)
+        this.shadows.forEach(shadow => {
+            // Move towards player (0,0,0 relative to camera)
+            // In a real engine, we'd have absolute coordinates.
+            // Here, we simulate relative motion by updating parameters
+
+            // Mock: Oscillate shadow intensity based on "proximity"
+            shadow.emote('panic', 0.5);
+        });
+
+        // 4. Check Collisions (Mock)
+        // If player is close to a crystal -> Collect
+        if (Math.random() < 0.005 && this.crystals.length > 0) {
+            this.collectCrystal(this.crystals.pop());
+        }
+    }
+
+    /**
+     * Render Update (Variable Timestep)
+     */
+    render(alpha) {
+        // Visual interpolation could happen here
+    }
+
+    updatePlayerView(key, value) {
+        // Broadcast player view changes to the World actor
+        // This makes the world rotate around the player
+        const world = this.universe.actors.get(this.universe.orchestrator.entities.keys().next().value);
+        if (world && world.engine) {
+            world.engine.setParameter(key, value);
+        }
+    }
+
+    collectCrystal(actor) {
+        this.score++;
+        this.ui.score.innerText = this.score;
+
+        // FX
+        actor.emote('joy', 1.0, 500);
+        setTimeout(() => {
+            this.universe.despawnActor(actor.id);
+        }, 500);
+
+        if (this.score >= 5) {
+            this.win();
+        }
+    }
+
+    win() {
+        this.isPlaying = false;
+        this.ui.overlay.innerHTML = `
+            <h1 style="color: #0f0; text-shadow: 0 0 20px #0f0;">SECTOR STABILIZED</h1>
+            <p>The lattice is secure.</p>
+            <button onclick="location.reload()">Re-enter</button>
+        `;
+        this.ui.overlay.classList.remove('hidden');
+        this.loop.stop();
+    }
+}
+
+// Start Game
+new CrystalLabyrinthGame();

package/src/export/SVGExporter.js

@@ -355,17 +355,21 @@ function projectPoints(points, rotor, dimension, width, height) {
     const centerY = height / 2;
     const scale = Math.min(width, height) * 0.4;
 
+    // Reuse vectors to minimize allocation
+    const rotatedBuffer = new Vec4();
+    const projectedBuffer = new Vec4();
+
     for (const point of points) {
         // Apply 4D rotation
-        const rotated = rotor.rotate(point);
+        rotor.rotate(point, rotatedBuffer);
 
         // Project to 3D (perspective from W)
-        const proj3d = rotated.projectPerspective(dimension);
+        rotatedBuffer.projectPerspective(dimension, projectedBuffer);
 
         // Project to 2D (simple orthographic for clean SVG)
-        const x = centerX + proj3d.x * scale;
-        const y = centerY - proj3d.y * scale; // Flip Y for SVG coordinates
-        const depth = proj3d.z; // Keep depth for styling
+        const x = centerX + projectedBuffer.x * scale;
+        const y = centerY - projectedBuffer.y * scale; // Flip Y for SVG coordinates
+        const depth = projectedBuffer.z; // Keep depth for styling
 
         projected.push({ x, y, depth, original: point });
     }

package/src/geometry/generators/Crystal.js

@@ -61,8 +61,8 @@ export function generate24CellVertices(size = 1) {
             ];
             for (const [s1, s2] of signs) {
                 const v = new Vec4(0, 0, 0, 0);
-                v.data[i] = s1 * s;
-                v.data[j] = s2 * s;
+                v.setComponent(i, s1 * s);
+                v.setComponent(j, s2 * s);
                 vertices.push(v);
             }
         }

package/src/geometry/warp/HypersphereCore.js

@@ -16,13 +16,14 @@ import { Vec4 } from '../../math/Vec4.js';
  * @param {number} radius - Hypersphere radius
  * @returns {Vec4} Point on hypersphere
  */
-export function projectToHypersphere(point, radius = 1) {
+export function projectToHypersphere(point, radius = 1, target = null) {
     const len = point.length();
     if (len < 0.0001) {
         // Handle origin - project to north pole
+        if (target) return target.set(0, 0, 0, radius);
         return new Vec4(0, 0, 0, radius);
     }
-    return point.scale(radius / len);
+    return point.scale(radius / len, target);
 }
 
 /**
@@ -30,9 +31,10 @@ export function projectToHypersphere(point, radius = 1) {
  * Maps all of 3D space onto the 4D hypersphere
  * @param {Vec4} point - Input point (uses x, y, z)
  * @param {number} radius - Hypersphere radius
+ * @param {Vec4} [target=null] - Optional target vector
  * @returns {Vec4} Point on hypersphere
  */
-export function stereographicToHypersphere(point, radius = 1) {
+export function stereographicToHypersphere(point, radius = 1, target = null) {
     const x = point.x;
     const y = point.y;
     const z = point.z;
@@ -40,6 +42,15 @@ export function stereographicToHypersphere(point, radius = 1) {
     const sumSq = x * x + y * y + z * z;
     const denom = sumSq + 1;
 
+    if (target) {
+        return target.set(
+            (2 * x) / denom * radius,
+            (2 * y) / denom * radius,
+            (2 * z) / denom * radius,
+            (sumSq - 1) / denom * radius
+        );
+    }
+
     return new Vec4(
         (2 * x) / denom * radius,
         (2 * y) / denom * radius,
@@ -56,12 +67,22 @@ export function stereographicToHypersphere(point, radius = 1) {
  * @param {number} phi - Azimuth on base S² (0 to 2π)
  * @param {number} psi - Fiber angle (0 to 2π)
  * @param {number} radius - Hypersphere radius
+ * @param {Vec4} [target=null] - Optional target vector
  * @returns {Vec4} Point on hypersphere
  */
-export function hopfFibration(theta, phi, psi, radius = 1) {
+export function hopfFibration(theta, phi, psi, radius = 1, target = null) {
     const cosTheta2 = Math.cos(theta / 2);
     const sinTheta2 = Math.sin(theta / 2);
 
+    if (target) {
+        return target.set(
+            cosTheta2 * Math.cos((phi + psi) / 2) * radius,
+            cosTheta2 * Math.sin((phi + psi) / 2) * radius,
+            sinTheta2 * Math.cos((phi - psi) / 2) * radius,
+            sinTheta2 * Math.sin((phi - psi) / 2) * radius
+        );
+    }
+
     return new Vec4(
         cosTheta2 * Math.cos((phi + psi) / 2) * radius,
         cosTheta2 * Math.sin((phi + psi) / 2) * radius,
@@ -78,8 +99,9 @@ export function hopfFibration(theta, phi, psi, radius = 1) {
  * @returns {Vec4[]} Warped vertices
  */
 export function warpRadial(vertices, radius = 1, blendFactor = 1) {
+    const onSphere = new Vec4();
     return vertices.map(v => {
-        const onSphere = projectToHypersphere(v, radius);
+        projectToHypersphere(v, radius, onSphere);
         return v.lerp(onSphere, blendFactor);
     });
 }
@@ -93,8 +115,9 @@ export function warpRadial(vertices, radius = 1, blendFactor = 1) {
  * @returns {Vec4[]} Warped vertices
  */
 export function warpStereographic(vertices, radius = 1, scale = 1) {
+    const scaled = new Vec4();
     return vertices.map(v => {
-        const scaled = v.scale(scale);
+        v.scale(scale, scaled);
         return stereographicToHypersphere(scaled, radius);
     });
 }
@@ -146,25 +169,31 @@ export function warpHypersphereCore(geometry, options = {}) {
         twist = 1
     } = options;
 
-    let warpedVertices;
-
-    // Pre-scale vertices
-    const scaledVertices = geometry.vertices.map(v => v.scale(scale));
-
-    switch (method) {
-        case 'stereographic':
-            warpedVertices = warpStereographic(scaledVertices, radius, 1);
-            break;
-
-        case 'hopf':
-            warpedVertices = warpHopf(scaledVertices, radius, twist);
-            break;
+    const temp = new Vec4();
+    const warpedVertices = geometry.vertices.map(v => {
+        // Combined scaling and warping to minimize allocations
+        const result = v.scale(scale);
+
+        if (method === 'stereographic') {
+            stereographicToHypersphere(result, radius, result);
+        } else if (method === 'hopf') {
+            const r = result.length();
+            if (r < 0.0001) {
+                result.set(0, 0, 0, radius);
+            } else {
+                const theta = Math.acos(result.z / r);
+                const phi = Math.atan2(result.y, result.x);
+                const psi = result.w * twist + phi * 0.5;
+                hopfFibration(theta, phi, psi, radius, result);
+            }
+        } else {
+            // Radial (default)
+            projectToHypersphere(result, radius, temp);
+            result.lerp(temp, blend, result);
+        }
 
-        case 'radial':
-        default:
-            warpedVertices = warpRadial(scaledVertices, radius, blend);
-            break;
-    }
+        return result;
+    });
 
     return {
         ...geometry,