action-engine-js 1.0.0

package/actionengine/math/physics/actionphysics.js

@@ -0,0 +1,108 @@
+// actionengine/math/physics/actionphysics.js
+class ActionPhysics {
+    static initialize(ammo, world) {
+        this.ammo = ammo;
+        this.world = world;
+        
+        // Cache common physics objects
+        this._rayStart = new ammo.btVector3(0, 0, 0);
+        this._rayEnd = new ammo.btVector3(0, 0, 0);
+        this._rayCallback = new ammo.ClosestRayResultCallback(this._rayStart, this._rayEnd);
+        this._sweepStart = new ammo.btTransform();
+        this._sweepEnd = new ammo.btTransform();
+        this._tmpVec = new ammo.btVector3(0, 0, 0);
+        this._halfExtents = new ammo.btVector3(0, 0, 0);
+        this._sweepCallback = new ammo.ClosestConvexResultCallback(this._rayStart, this._rayEnd);
+    }
+
+    static rayTest(body, direction, distance) {
+        const origin = body.getWorldTransform().getOrigin();
+
+        // Use cached vectors
+        this._rayStart.setValue(origin.x(), origin.y(), origin.z());
+        this._rayEnd.setValue(
+            origin.x() + direction.x * distance,
+            origin.y() + direction.y * distance,
+            origin.z() + direction.z * distance
+        );
+
+        // Reset and reuse callback
+        this._rayCallback.set_m_closestHitFraction(1);
+        this._rayCallback.set_m_collisionObject(null);
+
+        this.world.rayTest(this._rayStart, this._rayEnd, this._rayCallback);
+        return this._rayCallback.hasHit();
+    }
+    
+    static boxSweepTest(position, size, direction, distance) {
+        // Set up start transform at current position
+        this._sweepStart.setIdentity();
+        this._sweepStart.setOrigin(new this.ammo.btVector3(
+            position.x,
+            position.y,
+            position.z
+        ));
+
+        // Set up end transform
+        this._sweepEnd.setIdentity();
+        this._tmpVec.setValue(
+            position.x + direction.x * distance,
+            position.y + direction.y * distance, 
+            position.z + direction.z * distance
+        );
+        this._sweepEnd.setOrigin(this._tmpVec);
+
+        // Use cached halfExtents vector
+        this._halfExtents.setValue(
+            size.x * 0.5,
+            size.y * 0.5,
+            size.z * 0.5
+        );
+        const boxShape = new this.ammo.btBoxShape(this._halfExtents);
+
+        // Reset and reuse callback
+        this._sweepCallback.set_m_closestHitFraction(1);
+
+        this.world.convexSweepTest(
+            boxShape,
+            this._sweepStart,
+            this._sweepEnd,
+            this._sweepCallback,
+            0.0
+        );
+
+        const hasHit = this._sweepCallback.hasHit();
+        
+        // Only the shape needs cleanup now
+        Ammo.destroy(boxShape);
+
+        return {
+            hasHit,
+            hitFraction: this._sweepCallback.m_closestHitFraction
+        };
+    }
+    static cleanup() {
+        if (this._rayStart) {
+            Ammo.destroy(this._rayStart);
+            this._rayStart = null;
+        }
+        if (this._rayEnd) {
+            Ammo.destroy(this._rayEnd);
+            this._rayEnd = null;
+        }
+        if (this._rayCallback) {
+            Ammo.destroy(this._rayCallback);
+            this._rayCallback = null;
+        }
+        if (this._sweepStart) Ammo.destroy(this._sweepStart);
+        if (this._sweepEnd) Ammo.destroy(this._sweepEnd);
+        if (this._tmpVec) Ammo.destroy(this._tmpVec);
+        if (this._halfExtents) Ammo.destroy(this._halfExtents);
+        if (this._sweepCallback) Ammo.destroy(this._sweepCallback);
+        this._sweepStart = null;
+        this._sweepEnd = null;
+        this._tmpVec = null;
+        this._halfExtents = null;
+        this._sweepCallback = null;
+    }
+}

package/actionengine/math/physics/actionphysicsobject3D.js

@@ -0,0 +1,164 @@
+class ActionPhysicsObject3D extends RenderableObject {
+     constructor(physicsWorld, triangles, options = {}) {
+        super();
+        if (!physicsWorld) {
+            console.error("[ActionPhysicsObject3D] Physics world is required. Stack trace:", new Error().stack);
+            throw new Error("[ActionPhysicsObject3D] Physics world is required - check console for stack trace");
+        }
+        this.physicsWorld = physicsWorld;
+        
+        // Store the original triangles for later toggling
+        this._originalTriangles = triangles.slice();
+        
+        // Set visibility property
+        this.isVisible = options && options.isVisible !== undefined ? options.isVisible : true;
+        
+        // Initialize triangles based on visibility
+        this.triangles = this.isVisible ? this._originalTriangles : [];
+        
+        this.originalNormals = [];
+        this.originalVerts = [];
+        this.position = new Vector3(0, 0, 0);
+        
+        // Calculate bounding sphere for frustum culling
+        this.calculateBoundingSphere();
+        
+        // We need to store normals and verts even for invisible objects
+        // so when they become visible again we can update them correctly
+        // Use _originalTriangles to ensure we always have the data
+        this._originalTriangles.forEach((triangle) => {
+            this.originalNormals.push(new Vector3(
+                triangle.normal.x,
+                triangle.normal.y,
+                triangle.normal.z
+            ));
+            
+            triangle.vertices.forEach((vertex) => {
+                this.originalVerts.push(new Vector3(
+                    vertex.x,
+                    vertex.y,
+                    vertex.z
+                ));
+            });
+        });
+    }
+
+    // Add a method to toggle visibility
+    setVisibility(visible) {
+        if (this.isVisible === visible) return; // No change needed
+        
+        this.isVisible = visible;
+        
+        // Update triangles based on visibility - this is the key part
+        // When invisible, we set triangles to an empty array
+        // When visible, we restore the original triangles
+        this.triangles = visible ? this._originalTriangles : [];
+    }
+
+    updateVisual() {
+        if (!this.body) return;
+
+        // Cache frequently accessed properties
+        const pos = this.body.position;
+        const rot = this.body.rotation;
+        const { x: posX, y: posY, z: posZ } = pos;
+        
+        // Check if object has moved since last update
+        if (!this._visualDirty && this._lastPosition && this._lastRotation) {
+            // Check position
+            if (Math.abs(this._lastPosition.x - posX) < 0.001 &&
+                Math.abs(this._lastPosition.y - posY) < 0.001 &&
+                Math.abs(this._lastPosition.z - posZ) < 0.001) {
+                
+                // Check rotation - using dot product as a quick comparison
+                // If dot product is very close to 1, rotation hasn't changed significantly
+                const lastQuat = this._lastRotation;
+                const curQuat = rot;
+                const dot = lastQuat.x * curQuat.x + lastQuat.y * curQuat.y + 
+                           lastQuat.z * curQuat.z + lastQuat.w * curQuat.w;
+                
+                if (Math.abs(dot) > 0.9999) {
+                    // Position and rotation haven't changed, skip update
+                    return;
+                }
+            }
+        }
+        
+        // Update position once
+        this.position.set(posX, posY, posZ);
+        
+        // Cache current position and rotation for next comparison
+        if (!this._lastPosition) this._lastPosition = new Vector3();
+        this._lastPosition.set(posX, posY, posZ);
+        
+        if (!this._lastRotation) this._lastRotation = new Goblin.Quaternion();
+        this._lastRotation.x = rot.x;
+        this._lastRotation.y = rot.y;
+        this._lastRotation.z = rot.z;
+        this._lastRotation.w = rot.w;
+        
+        // Mark as clean since we're updating now
+        this._visualDirty = false;
+
+        // Preallocate reusable vector to avoid garbage collection
+        const relativeVert = new Goblin.Vector3();
+
+        // Use a for loop instead of forEach for better performance
+        for (let i = 0; i < this.triangles.length; i++) {
+            const triangle = this.triangles[i];
+
+            // Update normal - can be done with direct rotation
+            triangle.normal = this.rotateVector(this.originalNormals[i], rot);
+
+            // Update vertices
+            const baseIndex = i * 3;
+            for (let j = 0; j < 3; j++) {
+                const vertex = triangle.vertices[j];
+                const origVert = this.originalVerts[baseIndex + j];
+
+                // Reuse vector instead of creating new one
+                relativeVert.set(origVert.x, origVert.y, origVert.z);
+
+                // Rotate and translate in place
+                rot.transformVector3(relativeVert);
+                vertex.x = relativeVert.x + posX;
+                vertex.y = relativeVert.y + posY;
+                vertex.z = relativeVert.z + posZ;
+            }
+        }
+    }
+
+    rotateVector(vector, rotation) {
+        // Create Goblin vector
+        const v = new Goblin.Vector3(vector.x, vector.y, vector.z);
+        // Apply rotation
+        rotation.transformVector3(v);
+        // Return as our Vector3
+        return new Vector3(v.x, v.y, v.z);
+    }
+    
+    // Calculate the bounding sphere radius for frustum culling
+    calculateBoundingSphere() {
+        if (!this.triangles || this.triangles.length === 0) {
+            // Default radius if no triangles
+            this.boundingSphereRadius = 20;
+            return;
+        }
+        
+        // Find the maximum distance from center to any vertex
+        let maxDistanceSquared = 0;
+        
+        for (const triangle of this.triangles) {
+            for (const vertex of triangle.vertices) {
+                // Simple distance from origin - assuming most objects are centered
+                const distSquared = vertex.x * vertex.x + vertex.y * vertex.y + vertex.z * vertex.z;
+                if (distSquared > maxDistanceSquared) {
+                    maxDistanceSquared = distSquared;
+                }
+            }
+        }
+        
+        // Set radius with a small buffer for safety
+        this.boundingSphereRadius = Math.sqrt(maxDistanceSquared) * 1.1;
+    }
+}

package/actionengine/math/physics/actionphysicsworld3D.js

@@ -0,0 +1,238 @@
+// actionengine/math/physics/actionphysicsworld3D.js
+class ActionPhysicsWorld3D {
+    constructor(fixedTimestep = 1 / 60) {
+        this.broadphase = new Goblin.SAPBroadphase();
+        this.narrowphase = new Goblin.NarrowPhase();
+        this.solver = new Goblin.IterativeSolver();
+        this.world = new Goblin.World(this.broadphase, this.narrowphase, this.solver);
+
+        this.world.gravity = new Goblin.Vector3(0, -98.1, 0);
+
+        this.objects = new Set();
+
+        // Physics timing variables
+        this.fixedTimeStep = fixedTimestep;
+        this.physicsAccumulator = 0;
+        this.lastPhysicsTime = performance.now();
+        this.isPaused = false;
+    }
+
+    fixed_update(fixedDeltaTime) {
+        if (!this.world || this.isPaused) return;
+        
+        // Store pre-physics state for objects that need to know if they've moved
+        const movedObjects = new Set();
+        
+        // Capture pre-step positions and rotations for moving objects
+        this.objects.forEach(object => {
+            if (object.body && !object.body.is_static) {
+                movedObjects.add(object);
+            }
+        });
+
+        try {
+            // Step physics with the fixed timestep
+            this.world.step(fixedDeltaTime);
+            
+            // Mark objects that moved during physics as visually dirty
+            movedObjects.forEach(object => {
+                if (typeof object.markVisualDirty === 'function') {
+                    object.markVisualDirty();
+                }
+            });
+        } catch (error) {
+            if (error.toString().includes("silhouette")) {
+                console.error("===== SILHOUETTE ERROR DETECTED =====");
+                console.error("Error message:", error.message);
+                console.error("Error stack:", error.stack);
+                
+                // Log object counts and world state
+                console.error("Physics objects count:", this.objects.size);
+                console.error("Rigid bodies count:", this.world.rigid_bodies.length);
+                
+                // Log character information if available
+                if (window.gameCharacter) {
+                    console.error("Character information:");
+                    console.error("  - Type:", window.gameCharacter.constructor.name);
+                    console.error("  - Position:", 
+                        window.gameCharacter.body.position.x,
+                        window.gameCharacter.body.position.y,
+                        window.gameCharacter.body.position.z
+                    );
+                    console.error("  - Has body?", !!window.gameCharacter.body);
+                    console.error("  - Body in world?", this.world.rigid_bodies.includes(window.gameCharacter.body));
+                }
+                
+                // Log object pool sizes - these are key to understanding the issue
+                if (window.Goblin && window.Goblin.ObjectPool) {
+                    console.error("Goblin object pools:");
+                    Object.keys(window.Goblin.ObjectPool.pools).forEach(key => {
+                        console.error(`  - ${key}: ${window.Goblin.ObjectPool.pools[key].length} objects`);
+                    });
+                }
+                
+                // Continue execution - skip this physics step
+                console.error("Skipping current physics step due to error");
+                
+                // Log a counter of how many times this has happened
+                this._silhouetteErrorCount = (this._silhouetteErrorCount || 0) + 1;
+                console.error(`Total silhouette errors: ${this._silhouetteErrorCount}`);
+                
+                // Keep track of what the character was doing when this happened
+                if (window.gameCharacter && window.gameCharacter.debugInfo) {
+                    const state = window.gameCharacter.debugInfo.state;
+                    console.error("Character state when error occurred:", state ? state.current : "unknown");
+                }
+                
+                // Store detailed information for later analysis
+                if (!window._silhouetteErrorLog) window._silhouetteErrorLog = [];
+                window._silhouetteErrorLog.push({
+                    timestamp: new Date().toISOString(),
+                    errorMessage: error.message,
+                    characterPosition: window.gameCharacter ? 
+                        [window.gameCharacter.body.position.x, 
+                         window.gameCharacter.body.position.y, 
+                         window.gameCharacter.body.position.z] : null,
+                    characterState: window.gameCharacter && window.gameCharacter.debugInfo ? 
+                        window.gameCharacter.debugInfo.state.current : null
+                });
+            } else {
+                // Re-throw any other errors
+                throw error;
+            }
+        }
+    }
+
+    update(deltaTime) {
+        // This is now a lightweight wrapper for backward compatibility
+        // Physics is now handled in fixed_update()        
+        if (!this.world || this.isPaused) return;
+        
+        // Update any non-physics related components here that need variable timestep
+        // (none currently, all physics moved to fixed_update)
+    }
+
+    addConstraint(constraint) {
+        if (!constraint) {
+            console.warn("[PhysicsWorld] Attempted to add null constraint");
+            return;
+        }
+        //console.log("[PhysicsWorld] Adding constraint:", constraint);
+        this.world.addConstraint(constraint);
+    }
+
+    addObject(object) {
+        this.objects.add(object);
+        if (object.body) {
+            //console.log("[PhysicsWorld] Adding object body:", object.body);
+            this.world.addRigidBody(object.body);
+        }
+        if (object.rigidBodies) {
+            object.rigidBodies.forEach((body) => {
+                console.log("[PhysicsWorld] Adding object body:", body);
+                this.world.addRigidBody(body);
+            });
+        }
+        if (object.constraints) {
+            object.constraints.forEach((constraint) => {
+                console.log("[PhysicsWorld] Adding object constraint:", constraint);
+                this.world.addConstraint(constraint);
+            });
+        }
+    }
+
+    addRigidBody(body, group = 0, mask = 0) {
+        /* //disable masking for now
+        if (group !== undefined || mask !== undefined) {
+            body.collision_groups = group || 1;
+            body.collision_mask = mask || -1;
+        }
+        */
+        this.world.addRigidBody(body);
+    }
+
+    addTerrainBody(body, group = 0, mask = 0) {
+        //console.log("[PhysicsWorld] Adding terrain body:", body);
+        if (this.terrainBody) {
+            //console.log("[PhysicsWorld] Removing old terrain body");
+            this.world.removeRigidBody(this.terrainBody);
+        }
+        this.terrainBody = body;
+        
+        //disable masking for now
+        //body.collision_groups = group;
+        //body.collision_mask = mask;
+        
+        //console.log("[PhysicsWorld] Adding to world with groups:", group, "mask:", mask);
+        this.world.addRigidBody(body);
+    }
+
+    removeRigidBody(body) {
+        this.world.removeRigidBody(body);
+    }
+
+    removeConstraint(constraint) {
+        if (!constraint) {
+            console.warn("[PhysicsWorld] Attempted to remove null constraint");
+            return;
+        }
+        this.world.removeConstraint(constraint);
+    }
+
+    removeObject(object) {
+        if (object.body) {
+            this.world.removeRigidBody(object.body);
+        }
+        // Check for additional bodies
+        if (object.rigidBodies) {
+            object.rigidBodies.forEach((body) => {
+                //console.log("[PhysicsWorld] Removing object body:", body);
+                this.world.removeRigidBody(body);
+            });
+        }
+        if (object.constraints) {
+            object.constraints.forEach((constraint) => {
+                //console.log("[PhysicsWorld] Removing object constraint:", constraint);
+                this.world.removeConstraint(constraint);
+            });
+        }
+        this.objects.delete(object);
+    }
+
+    pause() {
+        this.isPaused = true;
+    }
+
+    resume() {
+        this.isPaused = false;
+        this.lastPhysicsTime = performance.now();
+        this.physicsAccumulator = 0;
+    }
+
+    reset() {
+        // nuke it
+        this.broadphase = new Goblin.SAPBroadphase();
+        this.narrowphase = new Goblin.NarrowPhase();
+        this.solver = new Goblin.IterativeSolver();
+        
+        // Clear all object pools
+        Object.keys(Goblin.ObjectPool.pools).forEach(key => {
+            Goblin.ObjectPool.pools[key].length = 0;
+        });
+        
+        if (this.terrainBody) {
+            this.world.removeRigidBody(this.terrainBody);
+            this.terrainBody = null;
+        }
+
+        this.objects.forEach((obj) => {
+            this.removeObject(obj);
+        });
+        
+        this.objects.clear();
+    }
+
+    getWorld() {
+        return this.world;
+    }
+}

package/actionengine/math/physics/actionraycast.js

@@ -0,0 +1,129 @@
+// actionengine/physics/actionraycast.js
+
+/**
+ * Utility class for performing raycasts in the ActionEngine world.
+ * Provides a simplified wrapper around the Goblin Physics raycasting system.
+ */
+class ActionRaycast {
+    /**
+     * Cast a ray from start to end in the physics world
+     * @param {Vector3|{x,y,z}} start - Starting point of the ray
+     * @param {Vector3|{x,y,z}} end - End point of the ray
+     * @param {ActionPhysicsWorld3D} physicsWorld - The physics world to cast in
+     * @param {Object} options - Optional settings
+     * @param {string[]} options.ignoreObjects - Array of object debugNames to ignore
+     * @param {number} options.minDistance - Minimum distance threshold (ignore hits closer than this)
+     * @returns {Object|null} Hit result or null if no hit
+     */
+    static cast(start, end, physicsWorld, options = {}) {
+        const ignoreList = options.ignoreObjects || [];
+        const minDistance = options.minDistance || 0;
+        
+        // Ensure start and end are correctly formatted
+        const rayStart = {
+            x: start.x,
+            y: start.y,
+            z: start.z
+        };
+        
+        const rayEnd = {
+            x: end.x,
+            y: end.y,
+            z: end.z
+        };
+        
+        // Perform the raycast using Goblin physics
+        const intersections = physicsWorld.getWorld().rayIntersect(rayStart, rayEnd);
+        
+        if (!intersections || intersections.length === 0) {
+            return null;
+        }
+        
+        // Filter and find the first valid intersection
+        for (let i = 0; i < intersections.length; i++) {
+            const hit = intersections[i];
+            
+            // Skip if hit is too close
+            if (hit.t < minDistance) {
+                continue;
+            }
+            
+            // Skip if object is in ignore list
+            if (hit.object && hit.object.debugName && 
+                ignoreList.some(name => 
+                    hit.object.debugName === name || 
+                    hit.object.debugName.includes(name)
+                )
+            ) {
+                continue;
+            }
+            
+            // Return formatted hit result
+            return {
+                object: hit.object,
+                point: { x: hit.point.x, y: hit.point.y, z: hit.point.z },
+                normal: { x: hit.normal.x, y: hit.normal.y, z: hit.normal.z },
+                distance: hit.t,
+                rayDirection: this._calculateDirection(rayStart, rayEnd)
+            };
+        }
+        
+        return null;
+    }
+    
+    /**
+     * Cast multiple rays from a single origin in different directions
+     * @param {Vector3|{x,y,z}} origin - Origin point for all rays
+     * @param {Array<Vector3|{x,y,z}>} directions - Array of direction vectors
+     * @param {number} length - Length of each ray
+     * @param {ActionPhysicsWorld3D} physicsWorld - The physics world to cast in
+     * @param {Object} options - Optional settings (same as cast method)
+     * @returns {Array} Array of hit results (null for each ray with no hit)
+     */
+    static multicast(origin, directions, length, physicsWorld, options = {}) {
+        return directions.map(dir => {
+            const end = {
+                x: origin.x + dir.x * length,
+                y: origin.y + dir.y * length,
+                z: origin.z + dir.z * length
+            };
+            return this.cast(origin, end, physicsWorld, options);
+        });
+    }
+    
+    /**
+     * Calculate normalized direction vector from start to end
+     * @private
+     */
+    static _calculateDirection(start, end) {
+        const dx = end.x - start.x;
+        const dy = end.y - start.y;
+        const dz = end.z - start.z;
+        const length = Math.sqrt(dx*dx + dy*dy + dz*dz);
+        
+        if (length < 0.0001) {
+            return { x: 0, y: 0, z: 0 };
+        }
+        
+        return {
+            x: dx / length,
+            y: dy / length,
+            z: dz / length
+        };
+    }
+    
+    /**
+     * Calculate a point along the ray at a specific distance
+     * @param {Vector3|{x,y,z}} start - Starting point of the ray
+     * @param {Vector3|{x,y,z}} direction - Normalized direction vector
+     * @param {number} distance - Distance along the ray
+     * @returns {Vector3} Point at the specified distance
+     */
+    static getPointOnRay(start, direction, distance) {
+        return new Vector3(
+            start.x + direction.x * distance,
+            start.y + direction.y * distance,
+            start.z + direction.z * distance
+        );
+    }
+}