@tsparticles/plugin-infection 3.0.0-alpha.0

package/umd/InfectionInstance.js

@@ -0,0 +1,51 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./Infecter", "@tsparticles/engine"], factory);
+    }
+})(function (require, exports) {
+    "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/umd/Options/Classes/Infection.js

@@ -0,0 +1,49 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./InfectionStage"], factory);
+    }
+})(function (require, exports) {
+    "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/umd/Options/Classes/InfectionStage.js

@@ -0,0 +1,39 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "@tsparticles/engine"], factory);
+    }
+})(function (require, exports) {
+    "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/umd/Options/Interfaces/IInfection.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Options/Interfaces/IInfectionStage.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/ParticlesInfecter.js

@@ -0,0 +1,68 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "@tsparticles/engine"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    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() {
+        }
+        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 ((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;
+});

package/umd/Types.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/index.js

@@ -0,0 +1,60 @@
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./Options/Classes/Infection", "./InfectionInstance", "./ParticlesInfecter", "./Options/Interfaces/IInfection", "./Options/Interfaces/IInfectionStage"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadInfectionPlugin = void 0;
+    const Infection_1 = require("./Options/Classes/Infection");
+    const InfectionInstance_1 = require("./InfectionInstance");
+    const ParticlesInfecter_1 = require("./ParticlesInfecter");
+    class InfectionPlugin {
+        constructor() {
+            this.id = "infection";
+        }
+        getPlugin(container) {
+            return new InfectionInstance_1.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_1.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;
+        }
+    }
+    async function loadInfectionPlugin(engine) {
+        const plugin = new InfectionPlugin();
+        await engine.addPlugin(plugin);
+        await engine.addInteractor("particlesInfection", (container) => new ParticlesInfecter_1.ParticlesInfecter(container));
+    }
+    exports.loadInfectionPlugin = loadInfectionPlugin;
+    __exportStar(require("./Options/Interfaces/IInfection"), exports);
+    __exportStar(require("./Options/Interfaces/IInfectionStage"), exports);
+});