Particle factory

import { constructors, force, spring, springnames } from '../core/library.js';

import { doCreate, mergeOver, pushUnique, λnull, Ωempty } from '../helper/utilities.js';

import { releaseParticleHistory, requestParticleHistory } from '../untracked-factory/particle-history.js';

import { makeVector, releaseVector, requestVector } from '../untracked-factory/vector.js';

import baseMix from '../mixin/base.js';

import { _isArray, BLACK, EULER, PARTICLE, T_PARTICLE } from '../helper/shared-vars.js';

const Particle = function (items = Ωempty) {

    this.makeName(items.name);
    this.register();

    this.set(this.defs);
    this.initializePositions();

    this.hasLifetime = false;
    this.distanceLimit = 0;
    this.killBeyondCanvas = false;
    this.isBeingDragged = false;
    this.dragOffset = null;

    this.set(items);

    return this;
};

const P = Particle.prototype = doCreate();

P.type = T_PARTICLE;
P.lib = PARTICLE;
P.isArtefact = false;
P.isAsset = false;

baseMix(P);

const defaultAttributes = {

    position: null,

    velocity: null,

    load: null,

    history: null,

    historyLength: 1,

    engine: EULER,

    forces: null,

    mass: 1,

    fill: BLACK,
    stroke: BLACK,
};
P.defs = mergeOver(P.defs, defaultAttributes);

P.packetExclusionsByRegex = pushUnique(P.packetExclusionsByRegex, ['^(local|dirty|current)']);
P.packetObjects = pushUnique(P.packetObjects, ['position', 'velocity', 'load']);

P.factoryKill = function () {

    this.history.forEach(h => releaseParticleHistory(h));

    const deadSprings = [];
    let s;

    springnames.forEach(name => {

        s = spring[name];

        if (s.particleFrom && s.particleFrom.name === this.name) deadSprings.push(s);
        else if (s.particleTo && s.particleTo.name === this.name) deadSprings.push(s);
    });

    deadSprings.forEach(s => s.kill());
};

const G = P.getters,
    S = P.setters,
    D = P.deltaSetters;

G.positionX = function () { return this.position.x; };
G.positionY = function () { return this.position.y; };
G.positionZ = function () { return this.position.z; };

G.position = function () {

    const s = this.position;
    return [s.x, s.y, s.z];
};

S.positionX = function (coord) { this.position.x = coord; };
S.positionY = function (coord) { this.position.y = coord; };
S.positionZ = function (coord) { this.position.z = coord; };

S.position = function (item) { this.position.set(item); };

D.positionX = function (coord) { this.position.x += coord; };
D.positionY = function (coord) { this.position.y += coord; };
D.positionZ = function (coord) { this.position.z += coord; };

D.position = λnull;

G.velocityX = function () { return this.velocity.x; };
G.velocityY = function () { return this.velocity.y; };
G.velocityZ = function () { return this.velocity.z; };

G.velocity = function () {

    const s = this.velocity;
    return [s.x, s.y, s.z];
};

S.velocityX = function (coord) { this.velocity.x = coord; };
S.velocityY = function (coord) { this.velocity.y = coord; };
S.velocityZ = function (coord) { this.velocity.z = coord; };

S.velocity = function (x, y, z) {

    this.velocity.set(x, y, z);
};

D.velocityX = function (coord) { this.velocity.x += coord; };
D.velocityY = function (coord) { this.velocity.y += coord; };
D.velocityZ = function (coord) { this.velocity.z += coord; };

D.velocity = λnull;

S.forces = function (item) {

    if (item) {

        if (_isArray(item)) {

            this.forces.length = 0;
            this.forces = this.forces.concat(item);
        }
        else this.forces.push(item);
    }
};

S.load = λnull;
S.history = λnull;

D.load = λnull;

P.initializePositions = function () {

    this.initialPosition = makeVector();
    this.position = makeVector();
    this.velocity = makeVector();
    this.load = makeVector();

    this.forces = [];
    this.history = [];

    this.isRunning = false;
};

P.applyForces = function (world, host) {

    this.load.zero();

    let f;

    if (!this.isBeingDragged) {

        this.forces.forEach(key => {

            f = (key && key.type === 'Force') ? key : force[key];

            if (f && f.action) f.action(this, world, host);
        });
    }
};

P.update = function (tick, world) {

    if (this.isBeingDragged) this.position.setFromVector(this.isBeingDragged).vectorAdd(this.dragOffset);
    else particleEngines[this.engine].call(this, tick * world.tickMultiplier);
};

P.manageHistory = function (tick, host) {

    const {history, remainingTime, position, historyLength, hasLifetime, distanceLimit, initialPosition, killBeyondCanvas} = this;

    let addHistoryFlag = true,
        remaining = 0;

    if (hasLifetime) {

        remaining = remainingTime - tick;

        if (remaining <= 0) {

            const last = history.pop();

            releaseParticleHistory(last);

            addHistoryFlag = false;

            if (!history.length) this.isRunning = false;
        }
        else this.remainingTime = remaining;
    }

    const oldest = history[history.length - 1];

    if (oldest) {

        const [, oz, ox, oy] = oldest;

        if (killBeyondCanvas) {

            const w = host.element.width,
                h = host.element.height;

            if (ox < 0 || oy < 0 || ox > w || oy > h) {

                addHistoryFlag = false;
                this.isRunning = false;
            }
        }

        if (distanceLimit) {

            const test = requestVector(initialPosition);

            test.vectorSubtractArray([ox, oy, oz]);

            if (test.getMagnitude() > distanceLimit) {

                addHistoryFlag = false;
                this.isRunning = false;
            }
            releaseVector(test);
        }
    }

    if (addHistoryFlag) {

        const {x, y, z} = position;

        const h = requestParticleHistory();

        h[0] = remaining;
        h[1] = z;
        h[2] = x;
        h[3] = y;

        history.unshift(h);

        if (history.length > historyLength) {

            const old = history.splice(historyLength);

            old.forEach(item => releaseParticleHistory(item));
        }
    }
};

P.run = function (timeKill, radiusKill, killBeyondCanvas) {

    this.hasLifetime = false;
    if (timeKill) {

        this.remainingTime = timeKill;
        this.hasLifetime = true;
    }

    this.distanceLimit = 0;
    if (radiusKill) {

        this.initialPosition.set(this.position);
        this.distanceLimit = radiusKill;
    }

    this.killBeyondCanvas = killBeyondCanvas;

    this.isRunning = true;
};

export const makeParticle = function (items) {

    if (!items) return false;
    return new Particle(items);
};

constructors.Particle = Particle;

const particlePool = [];

export const requestParticle = function (items) {

    if (!particlePool.length) particlePool.push(new Particle());

    const v = particlePool.pop();

    v.isRunning = false;
    v.hasLifetime = false;
    v.distanceLimit = 0;
    v.killBeyondCanvas = false;
    v.isBeingDragged = false;
    v.dragOffset = null;

    v.position.zero();
    v.velocity.zero();
    v.load.zero();
    v.initialPosition.zero();
    v.history.length = 0;
    v.forces.length = 0;

    v.set(items);

    return v
};

export const releaseParticle = function (item) {

    if (item && item.type === T_PARTICLE) {

        item.history.forEach(h => releaseParticleHistory(h));
        item.history.length = 0;

        item.set(item.defs);
        particlePool.push(item);

        if (particlePool.length > 50) {

            const temp = [...particlePool];
            particlePool.length = 0;
            temp.forEach(p => p.kill());
        }
    }
};

const particleEngines = {

    'euler': function (tick) {

        const {position, velocity, load, mass} = this;

        const acc = requestVector(),
            vel = requestVector(velocity);

        acc.setFromVector(load).scalarDivide(mass);

        vel.vectorAdd(acc.scalarMultiply(tick));

        velocity.setFromVector(vel);

        position.vectorAdd(vel.scalarMultiply(tick));

        releaseVector(acc, vel);
    },

    'improved-euler': function (tick) {

        const {position, velocity, load, mass} = this;

        const acc1 = requestVector(),
            acc2 = requestVector(),
            acc3 = requestVector(),
            vel = requestVector(velocity);

        acc1.setFromVector(load).scalarDivide(mass).scalarMultiply(tick);
        acc2.setFromVector(load).vectorAdd(acc1).scalarDivide(mass).scalarMultiply(tick);
        acc3.setFromVector(acc1).vectorAdd(acc2).scalarDivide(2);

        vel.vectorAdd(acc3);

        velocity.setFromVector(vel);

        position.vectorAdd(vel.scalarMultiply(tick));

        releaseVector(acc1, acc2, acc3, vel);
    },

    'runge-kutta': function (tick) {

        const {position, velocity, load, mass} = this;

        const acc1 = requestVector(),
            acc2 = requestVector(),
            acc3 = requestVector(),
            acc4 = requestVector(),
            acc5 = requestVector(),
            vel = requestVector(velocity);

        acc1.setFromVector(load).scalarDivide(mass).scalarMultiply(tick).scalarDivide(2);
        acc2.setFromVector(load).vectorAdd(acc1).scalarDivide(mass).scalarMultiply(tick).scalarDivide(2);
        acc3.setFromVector(load).vectorAdd(acc2).scalarDivide(mass).scalarMultiply(tick).scalarDivide(2);
        acc4.setFromVector(load).vectorAdd(acc3).scalarDivide(mass).scalarMultiply(tick).scalarDivide(2);

        acc2.scalarMultiply(2);
        acc3.scalarMultiply(2);

        acc5.setFromVector(acc1).vectorAdd(acc2).vectorAdd(acc3).vectorAdd(acc4).scalarDivide(6);

        vel.vectorAdd(acc5);

        velocity.setFromVector(vel);

        position.vectorAdd(vel.scalarMultiply(tick));

        releaseVector(acc1, acc2, acc3, acc4, acc5, vel);
    },
};