@tsparticles/plugin-emitters 3.0.0-alpha.0

package/browser/Shapes/Square/SquareShape.js

@@ -0,0 +1,40 @@
+import { getRandom } from "@tsparticles/engine";
+function randomSquareCoordinate(position, offset) {
+    return position + offset * (getRandom() - 0.5);
+}
+export class SquareShape {
+    randomPosition(position, size, fill) {
+        if (fill) {
+            return {
+                x: randomSquareCoordinate(position.x, size.width),
+                y: randomSquareCoordinate(position.y, size.height),
+            };
+        }
+        else {
+            const halfW = size.width / 2, halfH = size.height / 2, side = Math.floor(getRandom() * 4), v = (getRandom() - 0.5) * 2;
+            switch (side) {
+                case 0:
+                    return {
+                        x: position.x + v * halfW,
+                        y: position.y - halfH,
+                    };
+                case 1:
+                    return {
+                        x: position.x - halfW,
+                        y: position.y + v * halfH,
+                    };
+                case 2:
+                    return {
+                        x: position.x + v * halfW,
+                        y: position.y + halfH,
+                    };
+                case 3:
+                default:
+                    return {
+                        x: position.x + halfW,
+                        y: position.y + v * halfH,
+                    };
+            }
+        }
+    }
+}

package/browser/index.js

@@ -0,0 +1,113 @@
+import { executeOnSingleOrMultiple, isInArray } from "@tsparticles/engine";
+import { CircleShape } from "./Shapes/Circle/CircleShape";
+import { Emitter } from "./Options/Classes/Emitter";
+import { Emitters } from "./Emitters";
+import { ShapeManager } from "./ShapeManager";
+import { SquareShape } from "./Shapes/Square/SquareShape";
+class EmittersPlugin {
+    constructor(engine) {
+        this._engine = engine;
+        this.id = "emitters";
+    }
+    getPlugin(container) {
+        return new Emitters(this._engine, container);
+    }
+    loadOptions(options, source) {
+        var _a, _b, _c, _d, _e, _f;
+        if (!this.needsPlugin(options) && !this.needsPlugin(source)) {
+            return;
+        }
+        if (source === null || source === void 0 ? void 0 : source.emitters) {
+            options.emitters = executeOnSingleOrMultiple(source.emitters, (emitter) => {
+                const tmp = new Emitter();
+                tmp.load(emitter);
+                return tmp;
+            });
+        }
+        const interactivityEmitters = (_b = (_a = source === null || source === void 0 ? void 0 : source.interactivity) === null || _a === void 0 ? void 0 : _a.modes) === null || _b === void 0 ? void 0 : _b.emitters;
+        if (interactivityEmitters) {
+            if (interactivityEmitters instanceof Array) {
+                options.interactivity.modes.emitters = {
+                    random: {
+                        count: 1,
+                        enable: true,
+                    },
+                    value: interactivityEmitters.map((s) => {
+                        const tmp = new Emitter();
+                        tmp.load(s);
+                        return tmp;
+                    }),
+                };
+            }
+            else {
+                const emitterMode = interactivityEmitters;
+                if (emitterMode.value !== undefined) {
+                    if (emitterMode.value instanceof Array) {
+                        options.interactivity.modes.emitters = {
+                            random: {
+                                count: (_c = emitterMode.random.count) !== null && _c !== void 0 ? _c : 1,
+                                enable: (_d = emitterMode.random.enable) !== null && _d !== void 0 ? _d : false,
+                            },
+                            value: emitterMode.value.map((s) => {
+                                const tmp = new Emitter();
+                                tmp.load(s);
+                                return tmp;
+                            }),
+                        };
+                    }
+                    else {
+                        const tmp = new Emitter();
+                        tmp.load(emitterMode.value);
+                        options.interactivity.modes.emitters = {
+                            random: {
+                                count: (_e = emitterMode.random.count) !== null && _e !== void 0 ? _e : 1,
+                                enable: (_f = emitterMode.random.enable) !== null && _f !== void 0 ? _f : false,
+                            },
+                            value: tmp,
+                        };
+                    }
+                }
+                else {
+                    const emitterOptions = (options.interactivity.modes.emitters = {
+                        random: {
+                            count: 1,
+                            enable: false,
+                        },
+                        value: new Emitter(),
+                    });
+                    emitterOptions.value.load(interactivityEmitters);
+                }
+            }
+        }
+    }
+    needsPlugin(options) {
+        var _a, _b, _c;
+        if (!options) {
+            return false;
+        }
+        const emitters = options.emitters;
+        return ((emitters instanceof Array && !!emitters.length) ||
+            emitters !== undefined ||
+            (!!((_c = (_b = (_a = options.interactivity) === null || _a === void 0 ? void 0 : _a.events) === null || _b === void 0 ? void 0 : _b.onClick) === null || _c === void 0 ? void 0 : _c.mode) &&
+                isInArray("emitter", options.interactivity.events.onClick.mode)));
+    }
+}
+export async function loadEmittersPlugin(engine) {
+    if (!engine.emitterShapeManager) {
+        engine.emitterShapeManager = new ShapeManager(engine);
+    }
+    if (!engine.addEmitterShape) {
+        engine.addEmitterShape = (name, shape) => {
+            var _a;
+            (_a = engine.emitterShapeManager) === null || _a === void 0 ? void 0 : _a.addShape(name, shape);
+        };
+    }
+    const plugin = new EmittersPlugin(engine);
+    await engine.addPlugin(plugin);
+    engine.addEmitterShape("circle", new CircleShape());
+    engine.addEmitterShape("square", new SquareShape());
+}
+export * from "./EmitterContainer";
+export * from "./EmittersEngine";
+export * from "./Enums/EmitterClickMode";
+export * from "./Enums/EmitterShapeType";

package/browser/types.js

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

package/cjs/EmitterContainer.js

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

package/cjs/EmitterInstance.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmitterInstance = void 0;
+const engine_1 = require("@tsparticles/engine");
+const Emitter_1 = require("./Options/Classes/Emitter");
+const EmitterSize_1 = require("./Options/Classes/EmitterSize");
+class EmitterInstance {
+    constructor(engine, emitters, container, options, position) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        var _h;
+        this.emitters = emitters;
+        this.container = container;
+        this._engine = engine;
+        this._currentDuration = 0;
+        this._currentEmitDelay = 0;
+        this._currentSpawnDelay = 0;
+        this._initialPosition = position;
+        if (options instanceof Emitter_1.Emitter) {
+            this.options = options;
+        }
+        else {
+            this.options = new Emitter_1.Emitter();
+            this.options.load(options);
+        }
+        this._spawnDelay = (((_a = this.options.life.delay) !== null && _a !== void 0 ? _a : 0) * 1000) / this.container.retina.reduceFactor;
+        this.position = (_b = this._initialPosition) !== null && _b !== void 0 ? _b : this.calcPosition();
+        this.name = this.options.name;
+        this._shape = (_c = this._engine.emitterShapeManager) === null || _c === void 0 ? void 0 : _c.getShape(this.options.shape);
+        this.fill = this.options.fill;
+        this._firstSpawn = !this.options.life.wait;
+        this._startParticlesAdded = false;
+        let particlesOptions = (0, engine_1.deepExtend)({}, this.options.particles);
+        particlesOptions !== null && particlesOptions !== void 0 ? particlesOptions : (particlesOptions = {});
+        (_d = particlesOptions.move) !== null && _d !== void 0 ? _d : (particlesOptions.move = {});
+        (_e = (_h = particlesOptions.move).direction) !== null && _e !== void 0 ? _e : (_h.direction = this.options.direction);
+        if (this.options.spawnColor) {
+            this.spawnColor = (0, engine_1.rangeColorToHsl)(this.options.spawnColor);
+        }
+        this._paused = !this.options.autoPlay;
+        this._particlesOptions = particlesOptions;
+        this.size =
+            (_f = this.options.size) !== null && _f !== void 0 ? _f : (() => {
+                const size = new EmitterSize_1.EmitterSize();
+                size.load({
+                    height: 0,
+                    mode: "percent",
+                    width: 0,
+                });
+                return size;
+            })();
+        this._lifeCount = (_g = this.options.life.count) !== null && _g !== void 0 ? _g : -1;
+        this._immortal = this._lifeCount <= 0;
+        this._engine.dispatchEvent("emitterCreated", {
+            container,
+            data: {
+                emitter: this,
+            },
+        });
+        this.play();
+    }
+    externalPause() {
+        this._paused = true;
+        this.pause();
+    }
+    externalPlay() {
+        this._paused = false;
+        this.play();
+    }
+    getPosition() {
+        if (this.options.domId) {
+            const container = this.container, element = document.getElementById(this.options.domId);
+            if (element) {
+                const elRect = element.getBoundingClientRect();
+                return {
+                    x: (elRect.x + elRect.width / 2) * container.retina.pixelRatio,
+                    y: (elRect.y + elRect.height / 2) * container.retina.pixelRatio,
+                };
+            }
+        }
+        return this.position;
+    }
+    getSize() {
+        const container = this.container;
+        if (this.options.domId) {
+            const element = document.getElementById(this.options.domId);
+            if (element) {
+                const elRect = element.getBoundingClientRect();
+                return {
+                    width: elRect.width * container.retina.pixelRatio,
+                    height: elRect.height * container.retina.pixelRatio,
+                };
+            }
+        }
+        return {
+            width: this.size.mode === "percent"
+                ? (container.canvas.size.width * this.size.width) / 100
+                : this.size.width,
+            height: this.size.mode === "percent"
+                ? (container.canvas.size.height * this.size.height) / 100
+                : this.size.height,
+        };
+    }
+    pause() {
+        if (this._paused) {
+            return;
+        }
+        delete this._emitDelay;
+    }
+    play() {
+        var _a;
+        if (this._paused) {
+            return;
+        }
+        if (!(this.container.retina.reduceFactor &&
+            (this._lifeCount > 0 || this._immortal || !this.options.life.count) &&
+            (this._firstSpawn || this._currentSpawnDelay >= ((_a = this._spawnDelay) !== null && _a !== void 0 ? _a : 0)))) {
+            return;
+        }
+        if (this._emitDelay === undefined) {
+            const delay = (0, engine_1.getRangeValue)(this.options.rate.delay);
+            this._emitDelay = (1000 * delay) / this.container.retina.reduceFactor;
+        }
+        if (this._lifeCount > 0 || this._immortal) {
+            this.prepareToDie();
+        }
+    }
+    resize() {
+        const initialPosition = this._initialPosition;
+        this.position =
+            initialPosition && (0, engine_1.isPointInside)(initialPosition, this.container.canvas.size, engine_1.Vector.origin)
+                ? initialPosition
+                : this.calcPosition();
+    }
+    update(delta) {
+        var _a, _b, _c;
+        if (this._paused) {
+            return;
+        }
+        if (this._firstSpawn) {
+            this._firstSpawn = false;
+            this._currentSpawnDelay = (_a = this._spawnDelay) !== null && _a !== void 0 ? _a : 0;
+            this._currentEmitDelay = (_b = this._emitDelay) !== null && _b !== void 0 ? _b : 0;
+        }
+        if (!this._startParticlesAdded) {
+            this._startParticlesAdded = true;
+            this.emitParticles(this.options.startCount);
+        }
+        if (this._duration !== undefined) {
+            this._currentDuration += delta.value;
+            if (this._currentDuration >= this._duration) {
+                this.pause();
+                if (this._spawnDelay !== undefined) {
+                    delete this._spawnDelay;
+                }
+                if (!this._immortal) {
+                    this._lifeCount--;
+                }
+                if (this._lifeCount > 0 || this._immortal) {
+                    this.position = this.calcPosition();
+                    this._spawnDelay = (((_c = this.options.life.delay) !== null && _c !== void 0 ? _c : 0) * 1000) / this.container.retina.reduceFactor;
+                }
+                else {
+                    this.destroy();
+                }
+                this._currentDuration -= this._duration;
+                delete this._duration;
+            }
+        }
+        if (this._spawnDelay !== undefined) {
+            this._currentSpawnDelay += delta.value;
+            if (this._currentSpawnDelay >= this._spawnDelay) {
+                this._engine.dispatchEvent("emitterPlay", {
+                    container: this.container,
+                });
+                this.play();
+                this._currentSpawnDelay -= this._currentSpawnDelay;
+                delete this._spawnDelay;
+            }
+        }
+        if (this._emitDelay !== undefined) {
+            this._currentEmitDelay += delta.value;
+            if (this._currentEmitDelay >= this._emitDelay) {
+                this.emit();
+                this._currentEmitDelay -= this._emitDelay;
+            }
+        }
+    }
+    calcPosition() {
+        return (0, engine_1.calcPositionOrRandomFromSizeRanged)({
+            size: this.container.canvas.size,
+            position: this.options.position,
+        });
+    }
+    destroy() {
+        this.emitters.removeEmitter(this);
+        this._engine.dispatchEvent("emitterDestroyed", {
+            container: this.container,
+            data: {
+                emitter: this,
+            },
+        });
+    }
+    emit() {
+        if (this._paused) {
+            return;
+        }
+        const quantity = (0, engine_1.getRangeValue)(this.options.rate.quantity);
+        this.emitParticles(quantity);
+    }
+    emitParticles(quantity) {
+        var _a, _b, _c;
+        const position = this.getPosition(), size = this.getSize(), singleParticlesOptions = (0, engine_1.itemFromSingleOrMultiple)(this._particlesOptions);
+        for (let i = 0; i < quantity; i++) {
+            const particlesOptions = (0, engine_1.deepExtend)({}, singleParticlesOptions);
+            if (this.spawnColor) {
+                const hslAnimation = (_a = this.options.spawnColor) === null || _a === void 0 ? void 0 : _a.animation;
+                if (hslAnimation) {
+                    this.spawnColor.h = this.setColorAnimation(hslAnimation.h, this.spawnColor.h, 360);
+                    this.spawnColor.s = this.setColorAnimation(hslAnimation.s, this.spawnColor.s, 100);
+                    this.spawnColor.l = this.setColorAnimation(hslAnimation.l, this.spawnColor.l, 100);
+                }
+                if (!particlesOptions.color) {
+                    particlesOptions.color = {
+                        value: this.spawnColor,
+                    };
+                }
+                else {
+                    particlesOptions.color.value = this.spawnColor;
+                }
+            }
+            if (!position) {
+                return;
+            }
+            const pPosition = (_c = (_b = this._shape) === null || _b === void 0 ? void 0 : _b.randomPosition(position, size, this.fill)) !== null && _c !== void 0 ? _c : position;
+            this.container.particles.addParticle(pPosition, particlesOptions);
+        }
+    }
+    prepareToDie() {
+        var _a;
+        if (this._paused) {
+            return;
+        }
+        const duration = (_a = this.options.life) === null || _a === void 0 ? void 0 : _a.duration;
+        if (this.container.retina.reduceFactor &&
+            (this._lifeCount > 0 || this._immortal) &&
+            duration !== undefined &&
+            duration > 0) {
+            this._duration = duration * 1000;
+        }
+    }
+    setColorAnimation(animation, initValue, maxValue) {
+        var _a;
+        const container = this.container;
+        if (!animation.enable) {
+            return initValue;
+        }
+        const colorOffset = (0, engine_1.randomInRange)(animation.offset), delay = (0, engine_1.getRangeValue)(this.options.rate.delay), emitFactor = (1000 * delay) / container.retina.reduceFactor, colorSpeed = (0, engine_1.getRangeValue)((_a = animation.speed) !== null && _a !== void 0 ? _a : 0);
+        return (initValue + (colorSpeed * container.fpsLimit) / emitFactor + colorOffset * 3.6) % maxValue;
+    }
+}
+exports.EmitterInstance = EmitterInstance;

package/cjs/Emitters.js

@@ -0,0 +1,134 @@
+"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.Emitters = void 0;
+const engine_1 = require("@tsparticles/engine");
+const Emitter_1 = require("./Options/Classes/Emitter");
+const EmitterInstance_1 = require("./EmitterInstance");
+class Emitters {
+    constructor(engine, container) {
+        this.container = container;
+        this._engine = engine;
+        this.array = [];
+        this.emitters = [];
+        this.interactivityEmitters = {
+            random: {
+                count: 1,
+                enable: false,
+            },
+            value: [],
+        };
+        container.getEmitter = (idxOrName) => idxOrName === undefined || typeof idxOrName === "number"
+            ? this.array[idxOrName || 0]
+            : this.array.find((t) => t.name === idxOrName);
+        container.addEmitter = (options, position) => this.addEmitter(options, position);
+        container.removeEmitter = (idxOrName) => {
+            const emitter = container.getEmitter(idxOrName);
+            if (emitter) {
+                this.removeEmitter(emitter);
+            }
+        };
+        container.playEmitter = (idxOrName) => {
+            const emitter = container.getEmitter(idxOrName);
+            if (emitter) {
+                emitter.externalPlay();
+            }
+        };
+        container.pauseEmitter = (idxOrName) => {
+            const emitter = container.getEmitter(idxOrName);
+            if (emitter) {
+                emitter.externalPause();
+            }
+        };
+    }
+    addEmitter(options, position) {
+        const emitterOptions = new Emitter_1.Emitter();
+        emitterOptions.load(options);
+        const emitter = new EmitterInstance_1.EmitterInstance(this._engine, this, this.container, emitterOptions, position);
+        this.array.push(emitter);
+        return emitter;
+    }
+    handleClickMode(mode) {
+        const emitterOptions = this.emitters, modeEmitters = this.interactivityEmitters;
+        if (mode === "emitter") {
+            let emittersModeOptions;
+            if (modeEmitters && modeEmitters.value instanceof Array) {
+                if (modeEmitters.value.length > 0 && modeEmitters.random.enable) {
+                    emittersModeOptions = [];
+                    const usedIndexes = [];
+                    for (let i = 0; i < modeEmitters.random.count; i++) {
+                        const idx = (0, engine_1.arrayRandomIndex)(modeEmitters.value);
+                        if (usedIndexes.includes(idx) && usedIndexes.length < modeEmitters.value.length) {
+                            i--;
+                            continue;
+                        }
+                        usedIndexes.push(idx);
+                        emittersModeOptions.push((0, engine_1.itemFromArray)(modeEmitters.value, idx));
+                    }
+                }
+                else {
+                    emittersModeOptions = modeEmitters.value;
+                }
+            }
+            else {
+                emittersModeOptions = modeEmitters === null || modeEmitters === void 0 ? void 0 : modeEmitters.value;
+            }
+            const emittersOptions = emittersModeOptions !== null && emittersModeOptions !== void 0 ? emittersModeOptions : emitterOptions, ePosition = this.container.interactivity.mouse.clickPosition;
+            (0, engine_1.executeOnSingleOrMultiple)(emittersOptions, (emitter) => {
+                this.addEmitter(emitter, ePosition);
+            });
+        }
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.emitters = this.container.actualOptions.emitters;
+            this.interactivityEmitters = this.container.actualOptions.interactivity.modes.emitters;
+            if (this.emitters instanceof Array) {
+                for (const emitterOptions of this.emitters) {
+                    this.addEmitter(emitterOptions);
+                }
+            }
+            else {
+                this.addEmitter(this.emitters);
+            }
+        });
+    }
+    pause() {
+        for (const emitter of this.array) {
+            emitter.pause();
+        }
+    }
+    play() {
+        for (const emitter of this.array) {
+            emitter.play();
+        }
+    }
+    removeEmitter(emitter) {
+        const index = this.array.indexOf(emitter);
+        if (index >= 0) {
+            this.array.splice(index, 1);
+        }
+    }
+    resize() {
+        for (const emitter of this.array) {
+            emitter.resize();
+        }
+    }
+    stop() {
+        this.array = [];
+    }
+    update(delta) {
+        for (const emitter of this.array) {
+            emitter.update(delta);
+        }
+    }
+}
+exports.Emitters = Emitters;

package/cjs/EmittersEngine.js

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

package/cjs/Enums/EmitterClickMode.js

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

package/cjs/Enums/EmitterShapeType.js

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

package/cjs/IEmitterShape.js

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

package/cjs/Options/Classes/Emitter.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Emitter = void 0;
+const engine_1 = require("@tsparticles/engine");
+const EmitterLife_1 = require("./EmitterLife");
+const EmitterRate_1 = require("./EmitterRate");
+const EmitterSize_1 = require("./EmitterSize");
+class Emitter {
+    constructor() {
+        this.autoPlay = true;
+        this.fill = true;
+        this.life = new EmitterLife_1.EmitterLife();
+        this.rate = new EmitterRate_1.EmitterRate();
+        this.shape = "square";
+        this.startCount = 0;
+    }
+    load(data) {
+        if (data === undefined) {
+            return;
+        }
+        if (data.autoPlay !== undefined) {
+            this.autoPlay = data.autoPlay;
+        }
+        if (data.size !== undefined) {
+            if (this.size === undefined) {
+                this.size = new EmitterSize_1.EmitterSize();
+            }
+            this.size.load(data.size);
+        }
+        if (data.direction !== undefined) {
+            this.direction = data.direction;
+        }
+        this.domId = data.domId;
+        if (data.fill !== undefined) {
+            this.fill = data.fill;
+        }
+        this.life.load(data.life);
+        this.name = data.name;
+        this.particles = (0, engine_1.executeOnSingleOrMultiple)(data.particles, (particles) => {
+            return (0, engine_1.deepExtend)({}, particles);
+        });
+        this.rate.load(data.rate);
+        if (data.shape !== undefined) {
+            this.shape = data.shape;
+        }
+        if (data.position !== undefined) {
+            this.position = {};
+            if (data.position.x !== undefined) {
+                this.position.x = (0, engine_1.setRangeValue)(data.position.x);
+            }
+            if (data.position.y !== undefined) {
+                this.position.y = (0, engine_1.setRangeValue)(data.position.y);
+            }
+        }
+        if (data.spawnColor !== undefined) {
+            if (this.spawnColor === undefined) {
+                this.spawnColor = new engine_1.AnimatableColor();
+            }
+            this.spawnColor.load(data.spawnColor);
+        }
+        if (data.startCount !== undefined) {
+            this.startCount = data.startCount;
+        }
+    }
+}
+exports.Emitter = Emitter;

package/cjs/Options/Classes/EmitterLife.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmitterLife = void 0;
+class EmitterLife {
+    constructor() {
+        this.wait = false;
+    }
+    load(data) {
+        if (data === undefined) {
+            return;
+        }
+        if (data.count !== undefined) {
+            this.count = data.count;
+        }
+        if (data.delay !== undefined) {
+            this.delay = data.delay;
+        }
+        if (data.duration !== undefined) {
+            this.duration = data.duration;
+        }
+        if (data.wait !== undefined) {
+            this.wait = data.wait;
+        }
+    }
+}
+exports.EmitterLife = EmitterLife;

package/cjs/Options/Classes/EmitterRate.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmitterRate = void 0;
+const engine_1 = require("@tsparticles/engine");
+class EmitterRate {
+    constructor() {
+        this.quantity = 1;
+        this.delay = 0.1;
+    }
+    load(data) {
+        if (data === undefined) {
+            return;
+        }
+        if (data.quantity !== undefined) {
+            this.quantity = (0, engine_1.setRangeValue)(data.quantity);
+        }
+        if (data.delay !== undefined) {
+            this.delay = (0, engine_1.setRangeValue)(data.delay);
+        }
+    }
+}
+exports.EmitterRate = EmitterRate;