@tsparticles/interaction-particles-collisions 3.9.0 → 4.0.0-alpha.0

package/umd/Destroy.js

@@ -15,13 +15,14 @@
         if (!p1.unbreakable && !p2.unbreakable) {
             (0, Bounce_js_1.bounce)(p1, p2);
         }
-        if (p1.getRadius() === undefined && p2.getRadius() !== undefined) {
+        const p1Radius = p1.getRadius(), p2Radius = p2.getRadius();
+        if (!p1Radius && p2Radius) {
             p1.destroy();
         }
-        else if (p1.getRadius() !== undefined && p2.getRadius() === undefined) {
+        else if (p1Radius && !p2Radius) {
             p2.destroy();
         }
-        else if (p1.getRadius() !== undefined && p2.getRadius() !== undefined) {
+        else if (p1Radius && p2Radius) {
             const deleteP = p1.getRadius() >= p2.getRadius() ? p2 : p1;
             deleteP.destroy();
         }

package/umd/Options/Classes/Collisions.js

@@ -0,0 +1,45 @@
+(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", "../../CollisionMode.js", "./CollisionsAbsorb.js", "./CollisionsOverlap.js"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Collisions = void 0;
+    const engine_1 = require("@tsparticles/engine");
+    const CollisionMode_js_1 = require("../../CollisionMode.js");
+    const CollisionsAbsorb_js_1 = require("./CollisionsAbsorb.js");
+    const CollisionsOverlap_js_1 = require("./CollisionsOverlap.js");
+    class Collisions {
+        constructor() {
+            this.absorb = new CollisionsAbsorb_js_1.CollisionsAbsorb();
+            this.bounce = new engine_1.ParticlesBounce();
+            this.enable = false;
+            this.maxSpeed = 50;
+            this.mode = CollisionMode_js_1.CollisionMode.bounce;
+            this.overlap = new CollisionsOverlap_js_1.CollisionsOverlap();
+        }
+        load(data) {
+            if ((0, engine_1.isNull)(data)) {
+                return;
+            }
+            this.absorb.load(data.absorb);
+            this.bounce.load(data.bounce);
+            if (data.enable !== undefined) {
+                this.enable = data.enable;
+            }
+            if (data.maxSpeed !== undefined) {
+                this.maxSpeed = (0, engine_1.setRangeValue)(data.maxSpeed);
+            }
+            if (data.mode !== undefined) {
+                this.mode = data.mode;
+            }
+            this.overlap.load(data.overlap);
+        }
+    }
+    exports.Collisions = Collisions;
+});

package/umd/Options/Classes/CollisionsAbsorb.js

@@ -0,0 +1,28 @@
+(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.CollisionsAbsorb = void 0;
+    const engine_1 = require("@tsparticles/engine");
+    class CollisionsAbsorb {
+        constructor() {
+            this.speed = 2;
+        }
+        load(data) {
+            if ((0, engine_1.isNull)(data)) {
+                return;
+            }
+            if (data.speed !== undefined) {
+                this.speed = data.speed;
+            }
+        }
+    }
+    exports.CollisionsAbsorb = CollisionsAbsorb;
+});

package/umd/Options/Classes/CollisionsOverlap.js

@@ -0,0 +1,32 @@
+(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.CollisionsOverlap = void 0;
+    const engine_1 = require("@tsparticles/engine");
+    class CollisionsOverlap {
+        constructor() {
+            this.enable = true;
+            this.retries = 0;
+        }
+        load(data) {
+            if ((0, engine_1.isNull)(data)) {
+                return;
+            }
+            if (data.enable !== undefined) {
+                this.enable = data.enable;
+            }
+            if (data.retries !== undefined) {
+                this.retries = data.retries;
+            }
+        }
+    }
+    exports.CollisionsOverlap = CollisionsOverlap;
+});

package/umd/Options/Interfaces/ICollisions.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/ICollisionsAbsorb.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/ICollisionsOverlap.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/OverlapPlugin.js

@@ -0,0 +1,28 @@
+(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", "./OverlapPluginInstance.js"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.OverlapPlugin = void 0;
+    const OverlapPluginInstance_js_1 = require("./OverlapPluginInstance.js");
+    class OverlapPlugin {
+        constructor() {
+            this.id = "overlap";
+        }
+        getPlugin(container) {
+            return Promise.resolve(new OverlapPluginInstance_js_1.OverlapPluginInstance(container));
+        }
+        loadOptions() {
+        }
+        needsPlugin() {
+            return true;
+        }
+    }
+    exports.OverlapPlugin = OverlapPlugin;
+});

package/umd/OverlapPluginInstance.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.OverlapPluginInstance = void 0;
+    const engine_1 = require("@tsparticles/engine");
+    const minRetries = 0;
+    class OverlapPluginInstance {
+        constructor(container) {
+            this._checkOverlap = (particle, pos, tryCount) => {
+                const collisionsOptions = particle.options.collisions, radius = particle.getRadius();
+                if (!collisionsOptions?.enable) {
+                    return false;
+                }
+                const overlapOptions = collisionsOptions.overlap;
+                if (overlapOptions.enable) {
+                    return false;
+                }
+                const retries = overlapOptions.retries;
+                if (retries >= minRetries && tryCount > retries) {
+                    throw new Error(`Particle is overlapping and can't be placed`);
+                }
+                return !!this._container.particles.find(p => (0, engine_1.getDistance)(pos, p.position) < radius + p.getRadius());
+            };
+            this._container = container;
+        }
+        checkParticlePosition(particle, position, tryCount) {
+            return this._checkOverlap(particle, position, tryCount);
+        }
+    }
+    exports.OverlapPluginInstance = OverlapPluginInstance;
+});

package/umd/ResolveCollision.js

@@ -4,27 +4,30 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "@tsparticles/engine", "./Absorb.js", "./Bounce.js", "./Destroy.js"], factory);
+        define(["require", "exports", "./CollisionMode.js", "./Absorb.js", "./Bounce.js", "./Destroy.js"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.resolveCollision = resolveCollision;
-    const engine_1 = require("@tsparticles/engine");
+    const CollisionMode_js_1 = require("./CollisionMode.js");
     const Absorb_js_1 = require("./Absorb.js");
     const Bounce_js_1 = require("./Bounce.js");
     const Destroy_js_1 = require("./Destroy.js");
     function resolveCollision(p1, p2, delta, pixelRatio) {
+        if (!p1.options.collisions || !p2.options.collisions) {
+            return;
+        }
         switch (p1.options.collisions.mode) {
-            case engine_1.CollisionMode.absorb: {
+            case CollisionMode_js_1.CollisionMode.absorb: {
                 (0, Absorb_js_1.absorb)(p1, p2, delta, pixelRatio);
                 break;
             }
-            case engine_1.CollisionMode.bounce: {
+            case CollisionMode_js_1.CollisionMode.bounce: {
                 (0, Bounce_js_1.bounce)(p1, p2);
                 break;
             }
-            case engine_1.CollisionMode.destroy: {
+            case CollisionMode_js_1.CollisionMode.destroy: {
                 (0, Destroy_js_1.destroy)(p1, p2);
                 break;
             }

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

@@ -1,20 +1,58 @@
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 (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", "./Collider.js"], factory);
+        define(["require", "exports"], factory);
     }
 })(function (require, exports) {
     "use strict";
+    var __syncRequire = typeof module === "object" && typeof module.exports === "object";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.loadParticlesCollisionsInteraction = loadParticlesCollisionsInteraction;
-    const Collider_js_1 = require("./Collider.js");
-    async function loadParticlesCollisionsInteraction(engine, refresh = true) {
-        engine.checkVersion("3.9.0");
-        await engine.addInteractor("particlesCollisions", container => {
-            return Promise.resolve(new Collider_js_1.Collider(container));
-        }, refresh);
+    function loadParticlesCollisionsInteraction(engine) {
+        engine.checkVersion("4.0.0-alpha.0");
+        engine.register(async (e) => {
+            const { OverlapPlugin } = await (__syncRequire ? Promise.resolve().then(() => __importStar(require("./OverlapPlugin.js"))) : new Promise((resolve_1, reject_1) => { require(["./OverlapPlugin.js"], resolve_1, reject_1); }).then(__importStar));
+            e.addPlugin(new OverlapPlugin());
+            e.addInteractor("particlesCollisions", async (container) => {
+                const { Collider } = await (__syncRequire ? Promise.resolve().then(() => __importStar(require("./Collider.js"))) : new Promise((resolve_2, reject_2) => { require(["./Collider.js"], resolve_2, reject_2); }).then(__importStar));
+                return new Collider(container);
+            });
+        });
     }
 });