@tsparticles/plugin-infection 3.0.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Matteo Bruni
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,70 @@
+[![banner](https://particles.js.org/images/banner3.png)](https://particles.js.org)
+
+# tsParticles Infection Plugin
+
+[![jsDelivr](https://data.jsdelivr.com/v1/package/npm/tsparticles-plugin-infection/badge)](https://www.jsdelivr.com/package/npm/tsparticles-plugin-infection)
+[![npmjs](https://badge.fury.io/js/tsparticles-plugin-infection.svg)](https://www.npmjs.com/package/tsparticles-plugin-infection)
+[![npmjs](https://img.shields.io/npm/dt/tsparticles-plugin-infection)](https://www.npmjs.com/package/tsparticles-plugin-infection) [![GitHub Sponsors](https://img.shields.io/github/sponsors/matteobruni)](https://github.com/sponsors/matteobruni)
+
+[tsParticles](https://github.com/matteobruni/tsparticles) plugin for particles infection simulation effect.
+
+## How to use it
+
+### CDN / Vanilla JS / jQuery
+
+The CDN/Vanilla version JS has one required file in vanilla configuration:
+
+Including the `tsparticles.plugin.infection.min.js` file will export the function to load the plugin:
+
+```text
+loadInfectionPlugin
+```
+
+### Usage
+
+Once the scripts are loaded you can set up `tsParticles` and the plugin like this:
+
+```javascript
+(async () => {
+  await loadInfectionPlugin();
+
+  await tsParticles.load({
+    id: "tsparticles",
+    options: {
+      /* options */
+    },
+  });
+})();
+```
+
+### ESM / CommonJS
+
+This package is compatible also with ES or CommonJS modules, firstly this needs to be installed, like this:
+
+```shell
+$ npm install tsparticles-plugin-infection
+```
+
+or
+
+```shell
+$ yarn add tsparticles-plugin-infection
+```
+
+Then you need to import it in the app, like this:
+
+```javascript
+const { tsParticles } = require("tsparticles-engine");
+const { loadInfectionPlugin } = require("tsparticles-plugin-infection");
+
+loadInfectionPlugin(tsParticles);
+```
+
+or
+
+```javascript
+import { tsParticles } from "tsparticles-engine";
+import { loadInfectionPlugin } from "tsparticles-plugin-infection";
+
+loadInfectionPlugin(tsParticles);
+```

package/browser/Infecter.js

@@ -0,0 +1,97 @@
+export class Infecter {
+    constructor(container) {
+        this.container = container;
+    }
+    startInfection(particle, stage) {
+        const options = this.container.actualOptions;
+        if (!options.infection || !particle.infection) {
+            return;
+        }
+        const stages = options.infection.stages, stagesCount = stages.length;
+        if (stage > stagesCount || stage < 0) {
+            return;
+        }
+        particle.infection.delay = 0;
+        particle.infection.delayStage = stage;
+    }
+    updateInfection(particle, delta) {
+        const infection = this.container.actualOptions.infection;
+        if (!infection || !particle.infection) {
+            return;
+        }
+        const stages = infection.stages, stagesCount = stages.length;
+        if (particle.infection.delay !== undefined && particle.infection.delayStage !== undefined) {
+            const stage = particle.infection.delayStage;
+            if (stage > stagesCount || stage < 0) {
+                return;
+            }
+            if (particle.infection.delay >= infection.delay * 1000) {
+                particle.infection.stage = stage;
+                particle.infection.time = 0;
+                delete particle.infection.delay;
+                delete particle.infection.delayStage;
+            }
+            else {
+                particle.infection.delay += delta;
+            }
+        }
+        else {
+            delete particle.infection.delay;
+            delete particle.infection.delayStage;
+        }
+        if (particle.infection.stage !== undefined && particle.infection.time !== undefined) {
+            const infectionStage = stages[particle.infection.stage];
+            if (infectionStage.duration !== undefined && infectionStage.duration >= 0) {
+                if (particle.infection.time > infectionStage.duration * 1000) {
+                    this.nextInfectionStage(particle);
+                }
+                else {
+                    particle.infection.time += delta;
+                }
+            }
+            else {
+                particle.infection.time += delta;
+            }
+        }
+        else {
+            delete particle.infection.stage;
+            delete particle.infection.time;
+        }
+    }
+    updateInfectionStage(particle, stage) {
+        const options = this.container.actualOptions;
+        if (!options.infection || !particle.infection) {
+            return;
+        }
+        const stagesCount = options.infection.stages.length;
+        if (stage > stagesCount ||
+            stage < 0 ||
+            (particle.infection.stage !== undefined && particle.infection.stage > stage)) {
+            return;
+        }
+        particle.infection.stage = stage;
+        particle.infection.time = 0;
+    }
+    nextInfectionStage(particle) {
+        const options = this.container.actualOptions;
+        if (!options.infection || !particle.infection) {
+            return;
+        }
+        const stagesCount = options.infection.stages.length;
+        if (stagesCount <= 0 || particle.infection.stage === undefined) {
+            return;
+        }
+        particle.infection.time = 0;
+        if (stagesCount <= ++particle.infection.stage) {
+            if (options.infection.cure) {
+                delete particle.infection.stage;
+                delete particle.infection.time;
+                return;
+            }
+            else {
+                particle.infection.stage = 0;
+                particle.infection.time = 0;
+            }
+        }
+    }
+}

package/browser/InfectionInstance.js

@@ -0,0 +1,37 @@
+import { Infecter } from "./Infecter";
+import { itemFromArray } from "@tsparticles/engine";
+export class InfectionInstance {
+    constructor(container) {
+        this.container = container;
+        this.container.infecter = new Infecter(this.container);
+    }
+    particleFillColor(particle) {
+        const options = this.container.actualOptions;
+        if (!particle.infection || !options.infection) {
+            return;
+        }
+        const infectionStage = particle.infection.stage, infection = options.infection, infectionStages = infection.stages;
+        return infectionStage !== undefined ? infectionStages[infectionStage].color : undefined;
+    }
+    particleStrokeColor(particle) {
+        return this.particleFillColor(particle);
+    }
+    particlesSetup() {
+        var _a;
+        const options = this.container.actualOptions;
+        if (!options.infection) {
+            return;
+        }
+        for (let i = 0; i < options.infection.infections; i++) {
+            const notInfected = this.container.particles.array.filter((p) => {
+                const infP = p;
+                if (!infP.infection) {
+                    infP.infection = {};
+                }
+                return infP.infection.stage === undefined;
+            });
+            const infected = itemFromArray(notInfected);
+            (_a = this.container.infecter) === null || _a === void 0 ? void 0 : _a.startInfection(infected, 0);
+        }
+    }
+}

package/browser/Options/Classes/Infection.js

@@ -0,0 +1,35 @@
+import { InfectionStage } from "./InfectionStage";
+export class Infection {
+    constructor() {
+        this.cure = false;
+        this.delay = 0;
+        this.enable = false;
+        this.infections = 0;
+        this.stages = [];
+    }
+    load(data) {
+        if (data === undefined) {
+            return;
+        }
+        if (data.cure !== undefined) {
+            this.cure = data.cure;
+        }
+        if (data.delay !== undefined) {
+            this.delay = data.delay;
+        }
+        if (data.enable !== undefined) {
+            this.enable = data.enable;
+        }
+        if (data.infections !== undefined) {
+            this.infections = data.infections;
+        }
+        if (data.stages === undefined) {
+            return;
+        }
+        this.stages = data.stages.map((t) => {
+            const s = new InfectionStage();
+            s.load(t);
+            return s;
+        });
+    }
+}

package/browser/Options/Classes/InfectionStage.js

@@ -0,0 +1,25 @@
+import { OptionsColor } from "@tsparticles/engine";
+export class InfectionStage {
+    constructor() {
+        this.color = new OptionsColor();
+        this.color.value = "#ff0000";
+        this.radius = 0;
+        this.rate = 1;
+    }
+    load(data) {
+        if (data === undefined) {
+            return;
+        }
+        if (data.color !== undefined) {
+            this.color = OptionsColor.create(this.color, data.color);
+        }
+        this.duration = data.duration;
+        this.infectedStage = data.infectedStage;
+        if (data.radius !== undefined) {
+            this.radius = data.radius;
+        }
+        if (data.rate !== undefined) {
+            this.rate = data.rate;
+        }
+    }
+}

package/browser/Options/Interfaces/IInfection.js

@@ -0,0 +1 @@
+export {};

package/browser/Options/Interfaces/IInfectionStage.js

@@ -0,0 +1 @@
+export {};

package/browser/ParticlesInfecter.js

@@ -0,0 +1,54 @@
+import { ParticlesInteractorBase, getRandom } from "@tsparticles/engine";
+export class ParticlesInfecter extends ParticlesInteractorBase {
+    constructor(container) {
+        super(container);
+    }
+    clear() {
+    }
+    init() {
+    }
+    async interact(p1, delta) {
+        var _a, _b, _c, _d, _e;
+        const infecter = this.container.infecter;
+        if (!infecter) {
+            return;
+        }
+        infecter.updateInfection(p1, delta.value);
+        if (((_a = p1.infection) === null || _a === void 0 ? void 0 : _a.stage) === undefined) {
+            return;
+        }
+        const container = this.container, options = container.actualOptions, infectionOptions = options.infection;
+        if (!(infectionOptions === null || infectionOptions === void 0 ? void 0 : infectionOptions.enable) || infectionOptions.stages.length < 1) {
+            return;
+        }
+        const infectionStage1 = infectionOptions.stages[p1.infection.stage], pxRatio = container.retina.pixelRatio, radius = p1.getRadius() * 2 + infectionStage1.radius * pxRatio, pos = p1.getPosition(), infectedStage1 = (_b = infectionStage1.infectedStage) !== null && _b !== void 0 ? _b : p1.infection.stage, query = container.particles.quadTree.queryCircle(pos, radius), infections = infectionStage1.rate, neighbors = query.length;
+        for (const p2 of query) {
+            const infP2 = p2;
+            if (infP2 === p1 ||
+                infP2.destroyed ||
+                infP2.spawning ||
+                !(((_c = infP2.infection) === null || _c === void 0 ? void 0 : _c.stage) === undefined || infP2.infection.stage !== p1.infection.stage)) {
+                continue;
+            }
+            if (getRandom() < infections / neighbors) {
+                if (((_d = infP2.infection) === null || _d === void 0 ? void 0 : _d.stage) === undefined) {
+                    infecter.startInfection(infP2, infectedStage1);
+                }
+                else if (infP2.infection.stage < p1.infection.stage) {
+                    infecter.updateInfectionStage(infP2, infectedStage1);
+                }
+                else if (infP2.infection.stage > p1.infection.stage) {
+                    const infectionStage2 = infectionOptions.stages[infP2.infection.stage];
+                    const infectedStage2 = (_e = infectionStage2 === null || infectionStage2 === void 0 ? void 0 : infectionStage2.infectedStage) !== null && _e !== void 0 ? _e : infP2.infection.stage;
+                    infecter.updateInfectionStage(p1, infectedStage2);
+                }
+            }
+        }
+    }
+    isEnabled() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.container.actualOptions) === null || _a === void 0 ? void 0 : _a.infection) === null || _b === void 0 ? void 0 : _b.enable) !== null && _c !== void 0 ? _c : false;
+    }
+    reset() {
+    }
+}

package/browser/Types.js

@@ -0,0 +1 @@
+export {};

package/browser/index.js

@@ -0,0 +1,32 @@
+import { Infection } from "./Options/Classes/Infection";
+import { InfectionInstance } from "./InfectionInstance";
+import { ParticlesInfecter } from "./ParticlesInfecter";
+class InfectionPlugin {
+    constructor() {
+        this.id = "infection";
+    }
+    getPlugin(container) {
+        return new InfectionInstance(container);
+    }
+    loadOptions(options, source) {
+        if (!this.needsPlugin(source)) {
+            return;
+        }
+        let infectionOptions = options.infection;
+        if ((infectionOptions === null || infectionOptions === void 0 ? void 0 : infectionOptions.load) === undefined) {
+            options.infection = infectionOptions = new Infection();
+        }
+        infectionOptions.load(source === null || source === void 0 ? void 0 : source.infection);
+    }
+    needsPlugin(options) {
+        var _a, _b;
+        return (_b = (_a = options === null || options === void 0 ? void 0 : options.infection) === null || _a === void 0 ? void 0 : _a.enable) !== null && _b !== void 0 ? _b : false;
+    }
+}
+export async function loadInfectionPlugin(engine) {
+    const plugin = new InfectionPlugin();
+    await engine.addPlugin(plugin);
+    await engine.addInteractor("particlesInfection", (container) => new ParticlesInfecter(container));
+}
+export * from "./Options/Interfaces/IInfection";
+export * from "./Options/Interfaces/IInfectionStage";

package/cjs/Infecter.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Infecter = void 0;
+class Infecter {
+    constructor(container) {
+        this.container = container;
+    }
+    startInfection(particle, stage) {
+        const options = this.container.actualOptions;
+        if (!options.infection || !particle.infection) {
+            return;
+        }
+        const stages = options.infection.stages, stagesCount = stages.length;
+        if (stage > stagesCount || stage < 0) {
+            return;
+        }
+        particle.infection.delay = 0;
+        particle.infection.delayStage = stage;
+    }
+    updateInfection(particle, delta) {
+        const infection = this.container.actualOptions.infection;
+        if (!infection || !particle.infection) {
+            return;
+        }
+        const stages = infection.stages, stagesCount = stages.length;
+        if (particle.infection.delay !== undefined && particle.infection.delayStage !== undefined) {
+            const stage = particle.infection.delayStage;
+            if (stage > stagesCount || stage < 0) {
+                return;
+            }
+            if (particle.infection.delay >= infection.delay * 1000) {
+                particle.infection.stage = stage;
+                particle.infection.time = 0;
+                delete particle.infection.delay;
+                delete particle.infection.delayStage;
+            }
+            else {
+                particle.infection.delay += delta;
+            }
+        }
+        else {
+            delete particle.infection.delay;
+            delete particle.infection.delayStage;
+        }
+        if (particle.infection.stage !== undefined && particle.infection.time !== undefined) {
+            const infectionStage = stages[particle.infection.stage];
+            if (infectionStage.duration !== undefined && infectionStage.duration >= 0) {
+                if (particle.infection.time > infectionStage.duration * 1000) {
+                    this.nextInfectionStage(particle);
+                }
+                else {
+                    particle.infection.time += delta;
+                }
+            }
+            else {
+                particle.infection.time += delta;
+            }
+        }
+        else {
+            delete particle.infection.stage;
+            delete particle.infection.time;
+        }
+    }
+    updateInfectionStage(particle, stage) {
+        const options = this.container.actualOptions;
+        if (!options.infection || !particle.infection) {
+            return;
+        }
+        const stagesCount = options.infection.stages.length;
+        if (stage > stagesCount ||
+            stage < 0 ||
+            (particle.infection.stage !== undefined && particle.infection.stage > stage)) {
+            return;
+        }
+        particle.infection.stage = stage;
+        particle.infection.time = 0;
+    }
+    nextInfectionStage(particle) {
+        const options = this.container.actualOptions;
+        if (!options.infection || !particle.infection) {
+            return;
+        }
+        const stagesCount = options.infection.stages.length;
+        if (stagesCount <= 0 || particle.infection.stage === undefined) {
+            return;
+        }
+        particle.infection.time = 0;
+        if (stagesCount <= ++particle.infection.stage) {
+            if (options.infection.cure) {
+                delete particle.infection.stage;
+                delete particle.infection.time;
+                return;
+            }
+            else {
+                particle.infection.stage = 0;
+                particle.infection.time = 0;
+            }
+        }
+    }
+}
+exports.Infecter = Infecter;

package/cjs/InfectionInstance.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InfectionInstance = void 0;
+const Infecter_1 = require("./Infecter");
+const engine_1 = require("@tsparticles/engine");
+class InfectionInstance {
+    constructor(container) {
+        this.container = container;
+        this.container.infecter = new Infecter_1.Infecter(this.container);
+    }
+    particleFillColor(particle) {
+        const options = this.container.actualOptions;
+        if (!particle.infection || !options.infection) {
+            return;
+        }
+        const infectionStage = particle.infection.stage, infection = options.infection, infectionStages = infection.stages;
+        return infectionStage !== undefined ? infectionStages[infectionStage].color : undefined;
+    }
+    particleStrokeColor(particle) {
+        return this.particleFillColor(particle);
+    }
+    particlesSetup() {
+        var _a;
+        const options = this.container.actualOptions;
+        if (!options.infection) {
+            return;
+        }
+        for (let i = 0; i < options.infection.infections; i++) {
+            const notInfected = this.container.particles.array.filter((p) => {
+                const infP = p;
+                if (!infP.infection) {
+                    infP.infection = {};
+                }
+                return infP.infection.stage === undefined;
+            });
+            const infected = (0, engine_1.itemFromArray)(notInfected);
+            (_a = this.container.infecter) === null || _a === void 0 ? void 0 : _a.startInfection(infected, 0);
+        }
+    }
+}
+exports.InfectionInstance = InfectionInstance;

package/cjs/Options/Classes/Infection.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Infection = void 0;
+const InfectionStage_1 = require("./InfectionStage");
+class Infection {
+    constructor() {
+        this.cure = false;
+        this.delay = 0;
+        this.enable = false;
+        this.infections = 0;
+        this.stages = [];
+    }
+    load(data) {
+        if (data === undefined) {
+            return;
+        }
+        if (data.cure !== undefined) {
+            this.cure = data.cure;
+        }
+        if (data.delay !== undefined) {
+            this.delay = data.delay;
+        }
+        if (data.enable !== undefined) {
+            this.enable = data.enable;
+        }
+        if (data.infections !== undefined) {
+            this.infections = data.infections;
+        }
+        if (data.stages === undefined) {
+            return;
+        }
+        this.stages = data.stages.map((t) => {
+            const s = new InfectionStage_1.InfectionStage();
+            s.load(t);
+            return s;
+        });
+    }
+}
+exports.Infection = Infection;

package/cjs/Options/Classes/InfectionStage.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InfectionStage = void 0;
+const engine_1 = require("@tsparticles/engine");
+class InfectionStage {
+    constructor() {
+        this.color = new engine_1.OptionsColor();
+        this.color.value = "#ff0000";
+        this.radius = 0;
+        this.rate = 1;
+    }
+    load(data) {
+        if (data === undefined) {
+            return;
+        }
+        if (data.color !== undefined) {
+            this.color = engine_1.OptionsColor.create(this.color, data.color);
+        }
+        this.duration = data.duration;
+        this.infectedStage = data.infectedStage;
+        if (data.radius !== undefined) {
+            this.radius = data.radius;
+        }
+        if (data.rate !== undefined) {
+            this.rate = data.rate;
+        }
+    }
+}
+exports.InfectionStage = InfectionStage;

package/cjs/Options/Interfaces/IInfection.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/Options/Interfaces/IInfectionStage.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/ParticlesInfecter.js

@@ -0,0 +1,69 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParticlesInfecter = void 0;
+const engine_1 = require("@tsparticles/engine");
+class ParticlesInfecter extends engine_1.ParticlesInteractorBase {
+    constructor(container) {
+        super(container);
+    }
+    clear() {
+    }
+    init() {
+    }
+    interact(p1, delta) {
+        var _a, _b, _c, _d, _e;
+        return __awaiter(this, void 0, void 0, function* () {
+            const infecter = this.container.infecter;
+            if (!infecter) {
+                return;
+            }
+            infecter.updateInfection(p1, delta.value);
+            if (((_a = p1.infection) === null || _a === void 0 ? void 0 : _a.stage) === undefined) {
+                return;
+            }
+            const container = this.container, options = container.actualOptions, infectionOptions = options.infection;
+            if (!(infectionOptions === null || infectionOptions === void 0 ? void 0 : infectionOptions.enable) || infectionOptions.stages.length < 1) {
+                return;
+            }
+            const infectionStage1 = infectionOptions.stages[p1.infection.stage], pxRatio = container.retina.pixelRatio, radius = p1.getRadius() * 2 + infectionStage1.radius * pxRatio, pos = p1.getPosition(), infectedStage1 = (_b = infectionStage1.infectedStage) !== null && _b !== void 0 ? _b : p1.infection.stage, query = container.particles.quadTree.queryCircle(pos, radius), infections = infectionStage1.rate, neighbors = query.length;
+            for (const p2 of query) {
+                const infP2 = p2;
+                if (infP2 === p1 ||
+                    infP2.destroyed ||
+                    infP2.spawning ||
+                    !(((_c = infP2.infection) === null || _c === void 0 ? void 0 : _c.stage) === undefined || infP2.infection.stage !== p1.infection.stage)) {
+                    continue;
+                }
+                if ((0, engine_1.getRandom)() < infections / neighbors) {
+                    if (((_d = infP2.infection) === null || _d === void 0 ? void 0 : _d.stage) === undefined) {
+                        infecter.startInfection(infP2, infectedStage1);
+                    }
+                    else if (infP2.infection.stage < p1.infection.stage) {
+                        infecter.updateInfectionStage(infP2, infectedStage1);
+                    }
+                    else if (infP2.infection.stage > p1.infection.stage) {
+                        const infectionStage2 = infectionOptions.stages[infP2.infection.stage];
+                        const infectedStage2 = (_e = infectionStage2 === null || infectionStage2 === void 0 ? void 0 : infectionStage2.infectedStage) !== null && _e !== void 0 ? _e : infP2.infection.stage;
+                        infecter.updateInfectionStage(p1, infectedStage2);
+                    }
+                }
+            }
+        });
+    }
+    isEnabled() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.container.actualOptions) === null || _a === void 0 ? void 0 : _a.infection) === null || _b === void 0 ? void 0 : _b.enable) !== null && _c !== void 0 ? _c : false;
+    }
+    reset() {
+    }
+}
+exports.ParticlesInfecter = ParticlesInfecter;