@makefully/platypus 4.1.5 → 4.1.8

package/src/shapes/Polyline.js

@@ -0,0 +1,97 @@
+import Point from "./Point";
+import Segment from "./Segment";
+
+export default class Polyline extends Segment {
+    constructor (...args) {
+        super(...args);
+        this.type = 'polyline';
+        this._segments = null;
+    }
+
+    get loop () {
+        return this._loop;
+    }
+
+    set loop (loop) {
+        const
+            newValue = !!loop;
+
+        if (newValue !== this._loop) {
+            this._loop = newValue;
+            this._segments = null;
+        }
+    }
+
+    get segments () {
+        if (!this._segments) {
+            const
+                {points} = this,
+                segments = [];
+
+            for (let i = 0; i < points.length - 1; i++) {
+                segments.push(new Segment({
+                    a: points[i],
+                    b: points[i + 1]
+                }));
+            }
+
+            if (this.loop) {
+                segments.push(new Segment({
+                    a: points[points.length - 1],
+                    b: points[0]
+                }));
+            }
+
+            this._segments = segments;
+        }
+
+        return this._segments;
+    }
+    
+    initialize (options) {
+        super.initialize(options);
+        this._loop = options.loop ?? false;
+    }
+
+    forEach (func) {
+        this.segments.forEach(func);
+    }
+
+    getLength () {
+        return this.segments.reduce((sum, segment) => sum + segment.getLength(), 0);
+    }
+
+    duplicate () {
+        return new Polyline(this);
+    }
+    
+    toObject (options) {
+        const
+            {points, type} = this;
+
+        return {
+            points: points.map((point) => adjustedXY(point, options)),
+            type
+        };
+    }
+
+    static validateDefinition ({points} = {}) {
+        const
+            {length = 0} = points ?? [];
+
+        if (length < 2) {
+            return false;
+        } else {
+            for (let i = 0; i < length; i++) {
+                const
+                    point = points[i];
+
+                if (!Point.validateDefinition(Array.isArray(point) ? {x: point[0], y: point[1]} : point)) {
+                    return false;                    
+                }
+            }
+
+            return true;
+        }
+    }
+}

package/src/shapes/Rectangle.js

@@ -0,0 +1,78 @@
+import Polygon from "./Polygon";
+
+const
+    errDelta = 0.0001,
+    isRectangle = ({x: ax, y: ay}, {x: bx, y: by}, {x: cx, y: cy}, {x: dx, y: dy}) => {
+        const
+            sqr = (a) => a * a,
+            x = (ax + bx + cx + dx) / 4,
+            y = (ay + by + cy + dy) / 4,
+            asqr = sqr(x - ax) + sqr(y - ay),
+            bsqr = sqr(x - bx) + sqr(y - by),
+            csqr = sqr(x - cx) + sqr(y - cy),
+            dsqr = sqr(x - dx) + sqr(y - dy);
+
+      return Math.abs(asqr - bsqr) < errDelta &&
+            Math.abs(asqr - csqr) < errDelta &&
+            Math.abs(asqr - dsqr) < errDelta;
+    };
+
+export default class Rectangle extends Polygon {
+    constructor (...args) {
+        super(...args);
+        this.type = 'rectangle';
+    }
+
+    get halfHeight () {
+        return this.height / 2;
+    }
+
+    set halfHeight (hh) {
+        this.height = hh * 2;
+    }
+
+    get halfWidth () {
+        return this.width / 2;
+    }
+    
+    set halfWidth (hw) {
+        this.width = hw * 2;
+    }
+
+    initialize (options) {
+        const
+            {anchor: {x: ax, y: ay} = {x: 0, y: 0}, height, width, x = 0, y = 0} = options,
+            left = x - ax * width,
+            top = y - ay * height,
+            right = x + (1 - ax) * width,
+            bottom = y + (1 - ay) * height;
+
+        this.width = width;
+        this.height = height;
+
+        super.initialize({
+            ...options,
+            points: [{
+                x: left,
+                y: top
+            }, {
+                x: right,
+                y: top
+            }, {
+                x: right,
+                y: bottom
+            }, {
+                x: left,
+                y: bottom
+            }]
+        });
+    }
+
+    duplicate () {
+        return new Rectangle(this);
+    }
+
+    static validateDefinition ({height, width, points} = {}) {
+        return typeof height === 'number' && height > 0 && typeof width === 'number' && width > 0 && (!points || ((points.length === 4) && isRectangle(...points)));
+    }
+}

package/src/shapes/RoundedRectangle.js

@@ -0,0 +1,33 @@
+import Circle from "./Circle";
+import Rectangle from "./Rectangle";
+
+export default class RoundedRectangle extends Rectangle {
+    constructor (...args) {
+        super(...args);
+        this.type = 'roundedRectangle';
+    }
+
+    initialize (options) {
+        super.initialize(options);
+        this.radius = options.radius;
+    }
+
+    duplicate () {
+        return new RoundedRectangle(this);
+    }
+
+    toObject (options) {
+        const
+            {radius} = this,
+            {scale} = options;
+
+        return {
+            ...super.toObject(options),
+            radius: radius * scale
+        }
+    }
+
+    static validateDefinition (definition) {
+        return Circle.validateDefinition(definition) && Rectangle.validateDefinition(definition);
+    }
+}

package/src/shapes/Segment.js

@@ -0,0 +1,346 @@
+import Point from './Point';
+import Vector from '../Vector';
+
+const
+    EPSILON = 1e-10;
+
+export default class Segment extends Point {
+    constructor (...args) {
+        super(...args);
+        this.type = 'segment';
+        this._points = null;
+        this._revolutions = 0;
+    }
+
+    get a () {
+        return this.points[0];
+    }
+
+    get b () {
+        return this.points[this.points.length - 1];
+    }
+
+    get points () {
+        if (!this._points) {
+            const
+                {revolutions, x: X, y: Y} = this;
+                
+            if (revolutions % 1) {
+                const
+                    {cos, sin} = this.getSinCos();
+
+                this._points = this._vectors.map(({x, y}) => new Point({
+                    x: X + x * cos - y * sin,
+                    y: Y + x * sin + y * cos
+                }));
+            } else {
+                this._points = this._vectors.map(({x, y}) => new Point({
+                    x: X + x,
+                    y: Y + y
+                }));
+            }
+        }
+        return this._points;
+    }
+
+    get revolutions () {
+        return this._revolutions;
+    }
+
+    set revolutions (revolutions) {
+        if (this._revolutions !== revolutions) {
+            this._points = null; // need to recalculate if they exist.
+            this._revolutions = revolutions;
+        }
+    }
+
+    get vectors () {
+        return this._vectors;
+    }
+
+    initialize (options) {
+        const
+            {a, b, points, revolutions = 0, x = 0, y = 0} = options;
+
+        super.initialize(options);
+
+        if (revolutions % 1) {
+            const
+                {cos, sin} = this.getSinCos();
+
+            this._vectors = (points ?? [a, b]).map((point) => {
+                if (Array.isArray(point)) {
+                    return new Vector(point[0] * cos + point[1] * sin - x, -point[0] * sin + point[1] * cos - y);
+                } else {
+                    return new Vector(point.x * cos + point.y * sin - x, -point.x * sin + point.y * cos - y);
+                }
+            });
+        } else {
+            this._vectors = (points ?? [a, b]).map((point) => {
+                if (Array.isArray(point)) {
+                    return new Vector(point[0] - x, point[1] - y);
+                } else {
+                    return new Vector(point.x - x, point.y - y);
+                }
+            });
+        }
+    }
+
+    getLength () {
+        const
+            {a, b} = this;
+
+        return Math.hypot(b.x - a.x, b.y - a.y);
+    }
+
+    intersects ({a: c, b: d}) {
+        const
+            ccw = (a, b, c) => (c.y - a.y) * (b.x - a.x) > (b.y - a.y) * (c.x - a.x),
+            {a, b} = this;
+
+        return ccw(a, c, d) !== ccw(b, c, d) && ccw(a, b, c) !== ccw(a, b, d);
+    }
+
+    getIntersection (segment, {intersectsLine = false, segmentIsLine = false}) {
+        // Solve line intersection using determinants
+        const
+            {a, b} = this,
+            {a: c, b: d} = segment,
+            dabx = a.x - b.x,
+            daby = a.y - b.y,
+            dcdx = c.x - d.x,
+            dcdy = c.y - d.y,
+            det = dabx * dcdy - daby * dcdx;
+
+        if (Math.abs(det) < EPSILON) {
+            return null; // parallel or coincident
+        } else {
+            const
+                projection = (a, b, v) => (a.x - b.x) * v.x + (a.y - b.y) * v.y,
+                daxbyaybx = a.x * b.y - a.y * b.x,
+                dcxdycydx = c.x * d.y - c.y * d.x,
+                xy = new Point({
+                    x: (daxbyaybx * dcdx - dabx * dcxdycydx) / det,
+                    y: (daxbyaybx * dcdy - daby * dcxdycydx) / det
+                });
+
+            if (!intersectsLine) {
+                const
+                    v = this.getVector(),
+                    proj = projection(xy, a, v),
+                    min = Math.min(0, projection(b, a, v)),
+                    max = Math.max(0, projection(b, a, v));
+
+                v.recycle();
+
+                if (proj < min - EPSILON || proj > max + EPSILON) {
+                    return null;
+                }
+            }
+
+            // Clamp against "segment" unless infinite
+            if (!segmentIsLine) {
+                const
+                    v = segment.getVector(),
+                    proj = projection(xy, c, v),
+                    min = Math.min(0, projection(d, c, v)),
+                    max = Math.max(0, projection(d, c, v));
+
+                v.recycle();
+
+                if (proj < min - EPSILON || proj > max + EPSILON) {
+                    return null;
+                }
+            }
+
+            return xy;
+        }
+    }
+
+    getVector () {
+        const
+            {a, b} = this;
+
+        return Vector.setUp(b.x - a.x, b.y - a.y);
+    }
+
+    duplicate () {
+        return new Segment(this);
+    }
+
+    moveX (x) {
+        super.moveX(x);
+        this._points = null;
+    }
+
+    moveY (y) {
+        super.moveY(y);
+        this._points = null;
+    }
+
+    reflect (point) {
+        const
+            {a, b} = this,
+            segment = Vector.setUp(b.x - a.x, b.y - a.y),
+            aToPoint = Vector.setUp(point.x - a.x, point.y - a.y),
+            dot = segment.x * aToPoint.x + segment.y * aToPoint.y,
+            segmentSqr = segment.x * segment.x + segment.y * segment.y,
+            projectionFactor = dot / segmentSqr,
+            projectionOfPoint = Vector.setUp(a.x + projectionFactor * segment.x, a.y + projectionFactor * segment.y),
+            reflection = new Point({
+                x: 2 * projectionOfPoint.x - point.x,
+                y: 2 * projectionOfPoint.y - point.y
+            });
+
+        segment.recycle();
+        aToPoint.recycle();
+        projectionOfPoint.recycle();
+
+        return reflection;
+    }
+
+    isCollinear (segment, {epsilon = EPSILON} = {}) {
+        const
+            {a, b} = this,
+            {a: c, b: d} = segment,
+            orient = (p, q, r) => (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y),
+            aOrient = orient(c, d, a),
+            bOrient = orient(c, d, b);
+
+        return Math.abs(aOrient) < epsilon && Math.abs(bOrient) < epsilon;
+    }
+
+    bisect (segment, options) {
+        const
+            {a, b} = this,
+            {a: c, b: d} = segment,
+            v = segment.getVector(),
+            orient = (p, q, r) => (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y),
+            aOrient = orient(c, d, a),
+            bOrient = orient(c, d, b);
+
+        if (Math.abs(aOrient) < EPSILON && Math.abs(bOrient) < EPSILON) {
+            // collinear bisect
+            const
+                projection = (a) => (a.x - c.x) * v.x + (a.y - c.y) * v.y,
+                magA = projection(a),
+                magB = projection(b),
+                magC = projection(c),
+                magD = projection(d),
+                segmentMin = Math.min(magC, magD),
+                segmentMax = Math.max(magC, magD),
+                myMin = Math.min(magA, magB),
+                myMax = Math.max(magA, magB);
+
+            if (myMax < segmentMin) {
+                return [this, null];
+            } else if (myMin > segmentMax) {
+                return [null, this];
+            } else if (myMin >= segmentMin && myMax <= segmentMax) {
+                return [null, null]
+            } else {
+                // using unnormalized projection, so divide by |v|²
+                const
+                    len2 = v.x * v.x + v.y * v.y;
+
+                return [
+                    magA < segmentMin ? new Segment({
+                        a,
+                        b: {
+                            x: c.x + (segmentMin / len2) * v.x,
+                            y: c.y + (segmentMin / len2) * v.y
+                        }
+                    }) : null,
+                    magB > segmentMax ? new Segment({
+                        a: {
+                            x: c.x + (segmentMax / len2) * v.x,
+                            y: c.y + (segmentMax / len2) * v.y
+                        },
+                        b
+                    }) : null
+                ]
+            }
+        } else if (aOrient > -EPSILON && bOrient > -EPSILON) {
+            return [this, null];
+        } else if (aOrient < EPSILON && bOrient < EPSILON) {
+            return [null, this];
+        } else {
+            const
+                intersection = this.getIntersection(segment, options);
+
+            if (!intersection) {
+                 // no split, return identity
+                if (aOrient > 0) {
+                    return [this, null];
+                } else {
+                    return [null, this];
+                }
+            } else {
+                const
+                    left = new Segment({a, b: intersection}),
+                    right = new Segment({a: intersection, b});
+
+                return aOrient > 0 ? [left, right] : [right, left];
+            }
+        }
+    }
+
+    toArray (local = false) {
+        if (local) {
+            return this.vectors.map(({x, y}) => new Vector(x, y));
+        } else {
+            return this.points.map(({x, y}) => new Point({
+                x,
+                y
+            }));
+        }
+    }
+
+    toArray1D (local = false) {
+        if (local) {
+            return this.vectors.reduce((arr, {x, y}) => {
+                arr.push(x, y);
+                return arr
+            }, []);
+        } else {
+            return this.points.reduce((arr, {x, y}) => {
+                arr.push(x, y);
+                return arr
+            }, []);
+        }
+    }
+
+    toArray2D (local = false) {
+        if (local) {
+            return this.vectors.map(({x, y}) => ([x, y]));
+        } else {
+            return this.points.map(({x, y}) => ([x, y]));
+        }
+    }
+
+    toObject (options) {
+        const
+            {a, b, type} = this;
+
+        return {
+            a: adjustedXY(a, options),
+            b: adjustedXY(b, options),
+            type
+        };
+    }
+
+    static validateDefinition ({a, b, points} = {}) {
+        const
+            ab = points ?? [a, b];
+
+        if (ab.length !== 2) {
+            return false;
+        } else {
+            const
+                A = Array.isArray(ab[0]) ? {x: ab[0][0], y: ab[0][1]} : ab[0],
+                B = Array.isArray(ab[1]) ? {x: ab[1][0], y: ab[1][1]} : ab[1];
+
+            return Point.validateDefinition(A) && Point.validateDefinition(B) && (A.x !== B.x || A.y !== B.y);
+        }
+    }
+}

package/src/shapes/adjustedXY.js

@@ -0,0 +1,19 @@
+export default function adjustedXY (shape, {local = true, scale = 1}) {
+    if (local) {
+        const
+            {registration: {x, y}} = shape;
+
+        return {
+            x: x * scale,
+            y: y * scale
+        };
+    } else {
+        const
+            {x, y} = shape;
+
+        return {
+            x: x * scale,
+            y: y * scale
+        };
+    }
+}

package/src/shapes/castFromBox2D.js

@@ -0,0 +1,92 @@
+import castFromObject from "./castFromObject";
+
+/* global platypus */
+const
+    BOX2D_SHAPES = [
+        'circle',
+        'capsule',
+        'segment',
+        'polygon',
+        'segment' // <-- unsure how to convert chain shape segment into its owning chain shape as a `polyline`, so it'll be converted to a segment. */
+    ],
+    castTo = {
+        circle: (shapeId, {scale = 1} = {}) => {
+            const
+                {radius, center: {x, y}} = platypus.game.box2d.b2Shape_GetCircle(shapeId);
+
+            return {
+                radius: radius * scale,
+                type: 'circle',
+                x: x * scale,
+                y: y * scale
+            };
+        },
+        capsule: (shapeId, {scale = 1} = {}) => {
+            const
+                {radius, center1: {x: ax, y: ay}, center2: {x: bx, y: by}} = platypus.game.box2d.b2Shape_GetCapsule(shapeId);
+
+            return {
+                a: {
+                    x: ax * scale,
+                    y: ay * scale
+                },
+                b: {
+                    x: bx * scale,
+                    y: by * scale
+                },
+                radius: radius * scale,
+                type: 'capsule'
+            };
+        },
+        segment: (shapeId, {scale = 1} = {}) => {
+            const
+                {point1: {x: ax, y: ay}, point2: {x: bx, y: by}} = platypus.game.box2d.b2Shape_GetSegment(shapeId);
+
+            return {
+                a: {
+                    x: ax * scale,
+                    y: ay * scale
+                },
+                b: {
+                    x: bx * scale,
+                    y: by * scale
+                },
+                type: 'segment'
+            };
+        },
+        polygon: (shapeId, {scale = 1} = {}) => {
+            const
+                poly = platypus.game.box2d.b2Shape_GetPolygon(shapeId),
+                {count, radius} = poly,
+                points = [];
+
+            for (let i = 0; i < count; i++) {
+                const
+                    {x, y} = poly.GetVertex(i);
+
+                points.push({
+                    x: x * scale,
+                    y: y * scale
+                });
+            }
+
+            return {
+                points,
+                radius: radius * scale,
+                type: 'polygon'
+            };
+        }
+    };
+
+export default function castFromBox2D (shapeId, options) {
+    const
+        {b2Shape_GetType} = platypus.game.box2d,
+        shape = BOX2D_SHAPES[b2Shape_GetType(shapeId).value];
+
+    if (shape) {
+        return castFromObject(castTo[shape](shapeId, options));
+    } else {
+        platypus.debug.warn(`Unable to cast shape of type "${shape}" from Box2D.`, shape);
+        return null;
+    }
+}