@woosh/meep-engine 2.51.0 → 2.53.0

package/src/engine/ecs/systems/AttackerSystem.js

@@ -1,67 +0,0 @@
-/**
- * Created by Alex on 30/06/2014.
- */
-import { System } from '../System.js';
-import Attacker from '../components/Attacker.js';
-import { Transform } from '../transform/Transform.js';
-
-
-class AttackerSystem extends System {
-    constructor() {
-        super();
-
-        this.dependencies = [Attacker];
-    }
-
-    add(component, entity) {
-    }
-
-    remove(component, entity) {
-    }
-
-    update(timeDelta) {
-        /**
-         *
-         * @type {EntityManager}
-         */
-        const em = this.entityManager;
-
-        /**
-         *
-         * @param {Attacker} attacker
-         * @param {Transform} transform
-         * @param entity
-         */
-        function visitEntity(attacker, transform, entity) {
-            const target = attacker.target;
-            if (target === null) {
-                return; //no target
-            }
-            //check distance between attacker and the target
-            const targetTransform = em.getComponent(target, Transform);
-            if (targetTransform === null) {
-                //target doesn't have transform
-                attacker.target = null; //drop target
-                return;
-            }
-            if (transform.position.distanceTo(targetTransform.position) > attacker.range) {
-                return; //target is too far
-            }
-            const delay = attacker.delay;
-            let time = attacker.timerValue + timeDelta;
-            if (time > delay) {
-                let attacks = Math.floor(time / delay);
-                time %= delay;
-                while (attacks-- > 0) {
-                    em.sendEvent(entity, "attack", target);
-                }
-            }
-            attacker.timerValue = time;
-        }
-
-        em.traverseEntities([Attacker, Transform], visitEntity);
-    }
-}
-
-
-export default AttackerSystem;

package/src/engine/ecs/systems/MeshColliderSystem.js

@@ -1,47 +0,0 @@
-/**
- * Created by hdnha on 7/24/2014.
- */
-import { System } from '../System.js';
-import Tag from '../components/Tag.js';
-import { Transform } from '../transform/Transform.js';
-import Renderable from '../renderable/Renderable.js';
-import MeshCollider from '../components/MeshCollider.js';
-import { Raycaster } from "three";
-
-
-class MeshColliderSystem extends System {
-    constructor() {
-        super();
-
-        this.dependencies = [MeshCollider];
-    }
-
-    add(component, entity) {
-    }
-
-    remove(component) {
-    }
-
-    update(timeDelta) {
-        const entityManager = this.entityManager;
-        entityManager.traverseEntities([Transform, MeshCollider], function (transform, meshCollider, entity) {
-            const delta = transform.position.clone().sub(transform.previousPosition);
-            const length = delta.length();
-            let raycaster = new Raycaster(transform.previousPosition, delta.normalize(), 0, length);
-            if (!raycaster) {
-                return;
-            }
-            entityManager.traverseEntities([Tag, Renderable], function (tag, renderable, otherEntity) {
-                if (meshCollider.tags.indexOf(tag.name) != -1) {
-                    const objects = raycaster.intersectObject(renderable.mesh);
-                    if (objects.length > 0) {
-                        entityManager.sendEvent(entity, "collision", otherEntity);
-                        return false; //stop traversal
-                    }
-                }
-            });
-        });
-    }
-}
-
-export default MeshColliderSystem;

package/src/engine/ecs/systems/MonsterAISystem.js

@@ -1,163 +0,0 @@
-/**
- * Created by Alex on 12/08/2014.
- */
-import { System } from '../System.js';
-import { Transform } from '../transform/Transform.js';
-import MonsterAI from '../components/MonsterAI.js';
-import Tag from '../components/Tag.js';
-import PathFollower from '../../navigation/ecs/path_following/PathFollower.js';
-import Steering from '../components/Steering.js';
-import Attacker from '../components/Attacker.js';
-
-
-class MonsterAISystem extends System {
-    constructor(pathFinder) {
-        super();
-        this.pathFinder = pathFinder;
-
-        this.dependencies = [MonsterAI];
-    }
-
-    add(component, entity) {
-        const pathFinder = this.pathFinder;
-        const em = this.entityManager;
-        em.addEntityEventListener(entity, "spawned", function () {
-            //reset current path
-            const pf = em.getComponent(entity, PathFollower);
-            pf.path = null;
-            gotoDefensePoint(em, pathFinder, entity);
-        });
-    }
-
-    remove(component) {
-    }
-
-    update(timeDelta) {
-        const em = this.entityManager;
-        const pathFinder = this.pathFinder;
-        em.traverseEntities([MonsterAI, Attacker, Transform], function (ai, attacker, transform, entity) {
-            const target = attacker.target;
-            if (target !== null) {
-                //there is a target
-                const targetTransform = em.getComponent(target, Transform);
-                if (targetTransform === null) {
-                    gotoDefensePoint(em, pathFinder, entity);
-                    return;
-                }
-                //check the distance
-                const distance = transform.position.distanceTo(targetTransform.position);
-                if (distance <= ai.chaseDistance) {
-                    //check if path exists
-                    pathFinder.findPath(transform.position, targetTransform.position, 2, function (path) {
-                        //find length of the path
-                        if (path !== null && pathLength(path) < ai.chaseDistance) {
-                            const pathFollower = em.getComponent(entity, PathFollower);
-                            if (pathFollower !== null) {
-                                pathFollower.path = path;
-                                pathFollower.lastIndex = 0;
-                                //stop steering
-                                const steering = em.getComponent(entity, Steering);
-                                steering.destination = null;
-                            }
-                        } else {
-                            gotoDefensePoint(em, pathFinder, entity);
-                        }
-                    });
-                } else {
-                    gotoDefensePoint(em, pathFinder, entity);
-                }
-            }
-        });
-    }
-}
-
-
-function pointsEqual(p1, p2) {
-    return p1.x === p2.x && p1.y === p2.y && p1.z === p2.z;
-}
-
-function navigateTo(em, entity, target, pathFinder) {
-    const pathFollower = em.getComponent(entity, PathFollower);
-    const steering = em.getComponent(entity, Steering);
-    const source = em.getComponent(entity, Transform);
-
-    //check if already going to the right place
-    const path = pathFollower.path;
-    let pathLength;
-    if (path !== null && path !== void 0 && (pathLength = path.length, pathLength > 0)) {
-        const lastPointOfPath = path[pathLength - 1];
-        if (pointsEqual(lastPointOfPath, target.position)) {
-            return;// already following thr right path
-        }
-    }
-
-    //find new path
-    if (target !== null && !pathFollower.lock) {
-        pathFollower.lock = true;
-        pathFinder.findPath(source.position, target.position, 2, function (path) {
-            //reset path
-            pathFollower.path = path;
-            pathFollower.lastIndex = 0;
-            //stop steering
-            steering.destination = null;
-            //release lock
-            pathFollower.lock = false;
-        });
-    }
-}
-
-/**
- * finds nearest (straight line distance) entity with matching tag and navigates to it
- * @param em
- * @param pathFinder
- * @param entity
- * @param tagName
- */
-function gotoTag(em, pathFinder, entity, tagName) {
-    let target = null;
-    let d = Math.POSITIVE_INFINITY;
-    const sourceTransform = em.getComponent(entity, Transform);
-    const sourcePosition = sourceTransform.position;
-
-    /**
-     *
-     * @param {Tag} tag
-     * @param {Transform} transform
-     */
-    function visitTag(tag, transform) {
-        if (tag.contains(tagName)) {
-            const distanceToSquared = transform.position.distanceToSquared(sourcePosition);
-            if (target === null || distanceToSquared < d) {
-                target = transform;
-                d = distanceToSquared;
-            }
-        }
-    }
-
-    em.traverseEntities([Tag, Transform], visitTag);
-    navigateTo(em, entity, target, pathFinder);
-}
-
-function pathLength(path) {
-    let result = 0;
-    if (path === void 0) {
-        return 0;
-    }
-    const l = path.length - 1;
-    if (l >= 1) {
-        let c = path[0], p;
-        for (let i = 1; i < l; i++) {
-            p = c;
-            c = path[i];
-            result += p.distanceTo(c);
-        }
-    }
-    return result;
-}
-
-function gotoDefensePoint(entityManager, pathFinder, entity) {
-
-    gotoTag(entityManager, pathFinder, entity, "DefensePoint");
-}
-
-export default MonsterAISystem;

package/src/engine/ecs/systems/MortalitySystem.js

@@ -1,46 +0,0 @@
-/**
- * User: Alex Goldring
- * Date: 17/6/2014
- * Time: 21:27
- */
-import { System } from '../System.js';
-import Mortality from '../components/Mortality.js';
-
-
-class MortalitySystem extends System {
-    constructor() {
-        super();
-
-        this.dependencies = [Mortality];
-        //
-        this.__handlers = [];
-    }
-
-    reset() {
-        this.__handlers = [];
-    }
-
-    link(component, entity) {
-        const entityManager = this.entityManager;
-        const h = function () {
-            component.actions.forEach(function (action) {
-                action(entity, entityManager);
-            });
-        };
-        this.__handlers[entity] = h;
-        entityManager.addEntityEventListener(entity, "death", h);
-    }
-
-    unlink(component, entity) {
-        const handlers = this.__handlers;
-        const handler = handlers[entity];
-        this.entityManager.removeEntityEventListener(entity, "death", handler);
-        delete handlers[entity];
-    }
-
-    update(timeDelta) {
-    }
-}
-
-
-export default MortalitySystem;

package/src/engine/ecs/systems/RangedAttackSystem.js

@@ -1,132 +0,0 @@
-/**
- * Created by Alex on 13/08/2014.
- */
-import { System } from '../System.js';
-import { Transform } from '../transform/Transform.js';
-import RangedAttack from '../components/RangedAttack.js';
-import PhysicalBody from '../components/PhysicalBody.js';
-import Motion from '../components/Motion.js';
-import Renderable from '../renderable/Renderable.js';
-import { Matrix4 as ThreeMatrix4, Vector3 as ThreeVector3 } from 'three';
-import { solveQuadratic } from "../../../core/math/solveQuadratic.js";
-
-/**
- * Return the firing solution for a projectile starting at 'src' with
- * velocity 'v', to hit a target, 'dst'.
- *
- * @param Vector3 source position of shooter
- * @param Vector3 target position of target
- * @param Vector3 targetVelocity   velocity of target object
- * @param Vector3 sourceSpeed   speed of projectile
- * @return Vector3 Coordinate at which to fire (and where intercept occurs)
- */
-const intercept = (function () {
-
-
-    const toTarget = new ThreeVector3();
-    const v0 = new ThreeVector3();
-
-    function intercept(source, target, targetVelocity, sourceSpeed) {
-        toTarget.copy(target).sub(source);
-        // Get quadratic equation components
-        const a = targetVelocity.dot(targetVelocity) - sourceSpeed * sourceSpeed;
-        const b = 2 * targetVelocity.dot(toTarget);
-        const c = toTarget.dot(toTarget);
-
-        // Solve quadratic
-        const ts = [];
-        const root_count = solveQuadratic(ts, 0, a, b, c); // See quad(), below
-
-        // Find smallest positive solution
-        let sol = null;
-        if (root_count > 0) {
-            const t0 = ts[0], t1 = ts[1];
-            let t = Math.min(t0, t1);
-            if (t < 0) t = Math.max(t0, t1);
-            if (t > 0) {
-                v0.copy(targetVelocity).multiplyScalar(t).add(target);
-                sol = v0;
-            }
-        }
-
-        return sol;
-    }
-
-    return intercept;
-})();
-
-
-class RangedAttackSystem extends System {
-    constructor() {
-        super();
-
-        this.dependencies = [RangedAttack];
-    }
-
-    add(component, entity) {
-        const em = this.entityManager;
-        em.addEntityEventListener(entity, "attack", function (target) {
-            //get transform
-            const targetTransform = em.getComponent(target, Transform);
-            if (targetTransform === null) {
-                //target no longer exists
-                return;
-            }
-            const sourceTransform = em.getComponent(entity, Transform);
-            //get projectile
-            const projectileBuilder = component.factory();
-            const projectileTransform = projectileBuilder.getComponent(Transform);
-            //get delta between source and target
-            const sourcePosition = sourceTransform.position.clone().add(component.projectileOffset);
-            let targetPosition = targetTransform.position.clone();
-
-            //check if target has a mesh
-            const renderable = em.getComponent(target, Renderable);
-            if (renderable !== null) {
-                targetPosition.add(renderable.center);
-            }
-            //check if target is moving
-            const motion = em.getComponent(target, Motion);
-            if (motion !== null) {
-                //correct targeting, with respect to motion
-                const interceptPosition = intercept(sourcePosition, targetPosition, motion.velocity, component.speed);
-                if (interceptPosition !== null) {
-                    //if there is a valid solution, use it
-                    targetPosition = interceptPosition;
-                }
-            }
-            const velocity = targetPosition.clone().sub(sourcePosition).normalize().multiplyScalar(component.speed);
-            //move projectile to source transform
-            projectileTransform.position.copy(sourcePosition);
-            //align rotation
-            const matrix4 = new ThreeMatrix4();
-            const up = new ThreeVector3(0, 1, 0);
-            matrix4.lookAt(sourcePosition, targetPosition, up);
-            projectileTransform.rotation.setFromRotationMatrix(matrix4);
-
-            //set physical body
-            const physicalBody = projectileBuilder.getComponent(PhysicalBody);
-            if (physicalBody !== null && physicalBody !== void 0) {
-                const body = physicalBody.body;
-                body.position.copy(sourcePosition);
-                body.linearVelocity.copy(velocity);
-            }
-            //motion of component
-            const pMotion = projectileBuilder.getComponent(Motion);
-            if (pMotion !== null) {
-                pMotion.velocity.copy(velocity);
-            }
-            //build
-            let projectileEntity = projectileBuilder.build(em);
-        });
-    }
-
-    remove(component) {
-    }
-
-    update(timeDelta) {
-    }
-}
-
-
-export default RangedAttackSystem;

package/src/engine/ecs/systems/SerializationMetadataSystem.js

@@ -1,10 +0,0 @@
-import { System } from "../System.js";
-import { SerializationMetadata } from "../components/SerializationMetadata.js";
-
-export class SerializationMetadataSystem extends System {
-    constructor() {
-        super();
-
-        this.dependencies = [SerializationMetadata];
-    }
-}

package/src/engine/ecs/systems/TargetAISystem.js

@@ -1,107 +0,0 @@
-/**
- * Created by Alex on 30/06/2014.
- */
-import { System } from '../System.js';
-import TargetAI from '../components/TargetAI.js';
-import Attacker from '../components/Attacker.js';
-import { Transform } from '../transform/Transform.js';
-import Tag from '../components/Tag.js';
-
-
-class TargetAISystem extends System {
-    constructor() {
-        super();
-
-        this.dependencies = [TargetAI];
-
-        this.entityManager = null;
-        this.managedTargets = [];
-    }
-
-    reset() {
-        this.managedTargets = [];
-    }
-
-    startup(entityManager, readyCallback, errorCallback) {
-        this.entityManager = entityManager;
-        const self = this;
-        entityManager.on.entityRemoved.add(function (entity) {
-            //check if it's a managed entity
-            const managedTarget = self.managedTargets[entity];
-            if (managedTarget !== void 0) {
-                managedTarget.target = null;
-            }
-        });
-        readyCallback();
-    }
-
-    remove(component, entity) {
-        if (component.target !== null) {
-            delete this.managedTargets[component.target];
-        }
-    }
-
-    update(timeDelta) {
-        const self = this;
-        //go through target pickers
-        const em = this.entityManager;
-        em.traverseEntities([TargetAI, Attacker, Transform], function (picker, attacker, source, entity) {
-            const sourcePosition = source.global.position;
-            let targetEntity = attacker.target;
-            let targetPosition;
-            if (targetEntity !== null) {
-                const targetTransform = em.getComponent(targetEntity, Transform);
-                if (targetTransform === null) {
-                    //target entity no longer exists
-                    loseTarget(em, entity, attacker, self);
-                } else {
-                    targetPosition = targetTransform.global.position;
-                    const d = targetPosition.distanceTo(sourcePosition);
-                    if (d > picker.range) {
-                        //reset target if too far
-                        loseTarget(em, entity, attacker, self);
-                    } else {
-                        //we already have a decent target
-                        return;
-                    }
-                }
-            }
-            if (attacker.target === null) {
-                let range = picker.range;
-                const tags = picker.tags;
-                //find a new nearest target
-                em.traverseEntities([Tag, Transform], function (tag, transform, entity) {
-                    if (!tag.containsOneOf(tags)) {
-                        //not a tag we care about
-                        return;
-                    }
-                    //check distance
-                    let d = transform.global.position.distanceTo(sourcePosition);
-                    if (d < range) {
-                        range = d; //reduce search radius
-                        targetEntity = entity;
-                    }
-                });
-                if (targetEntity !== null) {
-                    gainTarget(em, entity, attacker, targetEntity, self);
-                }
-            }
-        });
-    }
-}
-
-
-function loseTarget(em, entity, attacker, ts) {
-    const oldTarget = attacker.target;
-    attacker.target = null;
-    em.sendEvent(entity, "target-lost", oldTarget);
-    delete ts.managedTargets[oldTarget];
-}
-
-function gainTarget(em, entity, attacker, target, ts) {
-    attacker.target = target;
-    em.sendEvent(entity, "target-gained", target);
-    ts.managedTargets[target] = attacker;
-}
-
-export default TargetAISystem;

package/src/engine/ecs/systems/ViewportMeshProjectionSystem.js

@@ -1,68 +0,0 @@
-/**
- * Created by Alex on 18/12/2014.
- */
-import { System } from '../System.js';
-import { Transform } from '../transform/Transform.js';
-import Renderable from '../renderable/Renderable.js';
-import GeometryBVH from '../components/GeometryBVH.js';
-import ViewportMeshProjection from '../components/ViewportMeshProjection.js';
-import { Vector3 as ThreeVector3 } from 'three';
-
-class VMPS extends System {
-    /**
-     *
-     * @param {GraphicsEngine} graphicsEngine
-     * @constructor
-     */
-    constructor(graphicsEngine) {
-        super();
-        this.graphicEngine = graphicsEngine;
-
-        this.dependencies = [ViewportMeshProjection];
-
-        //small number
-        this.update = (function () {
-            const source = new ThreeVector3();
-            const target = new ThreeVector3();
-
-            function update(timeDelta) {
-                const ge = this.graphicEngine;
-                const em = this.entityManager;
-                em.traverseEntities([ViewportMeshProjection, Transform], function (p, t, e) {
-                    const v2 = p.position;
-                    const geometryBVH = em.getComponent(p.entity, GeometryBVH);
-                    if (geometryBVH !== null) {
-                        //bvh exists
-                        ge.viewportProjectionRay(v2.x, v2.y, source, target);
-                        geometryBVH.raycast(source, target, function (point) {
-                            if (t.position.distanceToSquared(point) > EPSILON) {
-                                t.position.copy(point);
-                            }
-                        });
-                    } else {
-                        //no bvh, use mesh directly
-                        const renderable = em.getComponent(p.entity, Renderable);
-                        const hits = ge.intersectObjectUnderViewportPoint(v2.x, v2.y, renderable.mesh, true);
-                        if (hits !== void 0 && hits.length > 0) {
-                            //take first hit
-                            const hit = hits[0];
-                            const point = hit.point;
-                            if (t.position.distanceToSquared(point) > EPSILON) {
-                                t.position.copy(point);
-                            }
-                        }
-                    }
-
-
-                });
-            }
-
-            return update;
-        })();
-    }
-}
-
-
-const EPSILON = 0.00001;
-
-export default VMPS;