@tsparticles/path-polygon 3.0.0-alpha.0

package/tsparticles.path.polygon.js

@@ -0,0 +1,162 @@
+/*!
+ * Author : Matteo Bruni
+ * MIT license: https://opensource.org/licenses/MIT
+ * Demo / Generator : https://particles.js.org/
+ * GitHub : https://www.github.com/matteobruni/tsparticles
+ * How to use? : Check the GitHub README
+ * v3.0.0-alpha.0
+ */
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory(require("@tsparticles/engine"));
+	else if(typeof define === 'function' && define.amd)
+		define(["@tsparticles/engine"], factory);
+	else {
+		var a = typeof exports === 'object' ? factory(require("@tsparticles/engine")) : factory(root["window"]);
+		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
+	}
+})(this, (__WEBPACK_EXTERNAL_MODULE__533__) => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 533:
+/***/ ((module) => {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE__533__;
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
+(() => {
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "loadPolygonPath": () => (/* binding */ loadPolygonPath),
+  "polygonPathName": () => (/* binding */ polygonPathName)
+});
+
+// EXTERNAL MODULE: external {"commonjs":"@tsparticles/engine","commonjs2":"@tsparticles/engine","amd":"@tsparticles/engine","root":"window"}
+var engine_root_window_ = __webpack_require__(533);
+;// CONCATENATED MODULE: ./dist/browser/PolygonPathGenerator.js
+
+class PolygonPathGenerator {
+  constructor() {
+    this.dirsList = [];
+    this.options = {
+      sides: 6,
+      turnSteps: 20,
+      angle: 30
+    };
+  }
+  generate(p) {
+    if (p.hexStep === undefined) {
+      p.hexStep = 0;
+    }
+    if (p.hexDirection === undefined) {
+      p.hexDirection = this.options.sides === 6 ? ((0,engine_root_window_.getRandom)() * 3 | 0) * 2 : (0,engine_root_window_.getRandom)() * this.options.sides | 0;
+    }
+    if (p.hexSpeed === undefined) {
+      p.hexSpeed = p.velocity.length;
+    }
+    if (p.hexStep % this.options.turnSteps === 0) {
+      p.hexDirection = (0,engine_root_window_.getRandom)() > 0.5 ? (p.hexDirection + 1) % this.options.sides : (p.hexDirection + this.options.sides - 1) % this.options.sides;
+    }
+    p.velocity.x = 0;
+    p.velocity.y = 0;
+    p.hexStep++;
+    return engine_root_window_.Vector.create(this.dirsList[p.hexDirection].x * p.hexSpeed, this.dirsList[p.hexDirection].y * p.hexSpeed);
+  }
+  init(container) {
+    var _a;
+    const options = container.actualOptions.particles.move.path.options;
+    this.options.sides = options.sides > 0 ? options.sides : 6;
+    this.options.angle = (_a = options.angle) !== null && _a !== void 0 ? _a : 30;
+    this.options.turnSteps = options.turnSteps >= 0 ? options.turnSteps : 20;
+    this.createDirs();
+  }
+  reset(particle) {
+    delete particle.hexStep;
+    delete particle.hexDirection;
+    delete particle.hexSpeed;
+  }
+  update() {}
+  createDirs() {
+    this.dirsList = [];
+    for (let i = 0; i < 360; i += 360 / this.options.sides) {
+      const angle = this.options.angle + i;
+      this.dirsList.push(engine_root_window_.Vector.create(Math.cos(angle * Math.PI / 180), Math.sin(angle * Math.PI / 180)));
+    }
+  }
+}
+;// CONCATENATED MODULE: ./dist/browser/index.js
+
+const polygonPathName = "polygonPathGenerator";
+function loadPolygonPath(engine) {
+  engine.addPathGenerator(polygonPathName, new PolygonPathGenerator());
+}
+})();
+
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

package/tsparticles.path.polygon.min.js

@@ -0,0 +1,2 @@
+/*! For license information please see tsparticles.path.polygon.min.js.LICENSE.txt */
+!function(e,t){if("object"==typeof exports&&"object"==typeof module)module.exports=t(require("@tsparticles/engine"));else if("function"==typeof define&&define.amd)define(["@tsparticles/engine"],t);else{var i="object"==typeof exports?t(require("@tsparticles/engine")):t(e.window);for(var o in i)("object"==typeof exports?exports:e)[o]=i[o]}}(this,(e=>(()=>{"use strict";var t={533:t=>{t.exports=e}},i={};function o(e){var s=i[e];if(void 0!==s)return s.exports;var r=i[e]={exports:{}};return t[e](r,r.exports,o),r.exports}o.d=(e,t)=>{for(var i in t)o.o(t,i)&&!o.o(e,i)&&Object.defineProperty(e,i,{enumerable:!0,get:t[i]})},o.o=(e,t)=>Object.prototype.hasOwnProperty.call(e,t),o.r=e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})};var s={};return(()=>{o.r(s),o.d(s,{loadPolygonPath:()=>r,polygonPathName:()=>i});var e=o(533);class t{constructor(){this.dirsList=[],this.options={sides:6,turnSteps:20,angle:30}}generate(t){return void 0===t.hexStep&&(t.hexStep=0),void 0===t.hexDirection&&(t.hexDirection=6===this.options.sides?2*(3*(0,e.getRandom)()|0):(0,e.getRandom)()*this.options.sides|0),void 0===t.hexSpeed&&(t.hexSpeed=t.velocity.length),t.hexStep%this.options.turnSteps==0&&(t.hexDirection=(0,e.getRandom)()>.5?(t.hexDirection+1)%this.options.sides:(t.hexDirection+this.options.sides-1)%this.options.sides),t.velocity.x=0,t.velocity.y=0,t.hexStep++,e.Vector.create(this.dirsList[t.hexDirection].x*t.hexSpeed,this.dirsList[t.hexDirection].y*t.hexSpeed)}init(e){var t;const i=e.actualOptions.particles.move.path.options;this.options.sides=i.sides>0?i.sides:6,this.options.angle=null!==(t=i.angle)&&void 0!==t?t:30,this.options.turnSteps=i.turnSteps>=0?i.turnSteps:20,this.createDirs()}reset(e){delete e.hexStep,delete e.hexDirection,delete e.hexSpeed}update(){}createDirs(){this.dirsList=[];for(let t=0;t<360;t+=360/this.options.sides){const i=this.options.angle+t;this.dirsList.push(e.Vector.create(Math.cos(i*Math.PI/180),Math.sin(i*Math.PI/180)))}}}const i="polygonPathGenerator";function r(e){e.addPathGenerator(i,new t)}})(),s})()));

package/tsparticles.path.polygon.min.js.LICENSE.txt

@@ -0,0 +1,8 @@
+/*!
+ * Author : Matteo Bruni
+ * MIT license: https://opensource.org/licenses/MIT
+ * Demo / Generator : https://particles.js.org/
+ * GitHub : https://www.github.com/matteobruni/tsparticles
+ * How to use? : Check the GitHub README
+ * v3.0.0-alpha.0
+ */

package/types/IPolygonPathOptions.d.ts

@@ -0,0 +1,5 @@
+export interface IPolygonPathOptions {
+    angle: number;
+    sides: number;
+    turnSteps: number;
+}

package/types/PolygonPathGenerator.d.ts

@@ -0,0 +1,14 @@
+import type { Container, ICoordinates, IMovePathGenerator } from "@tsparticles/engine";
+import { Vector } from "@tsparticles/engine";
+import type { IPolygonPathOptions } from "./IPolygonPathOptions";
+import type { PolygonPathParticle } from "./PolygonPathParticle";
+export declare class PolygonPathGenerator implements IMovePathGenerator {
+    dirsList: ICoordinates[];
+    readonly options: IPolygonPathOptions;
+    constructor();
+    generate(p: PolygonPathParticle): Vector;
+    init(container: Container): void;
+    reset(particle: PolygonPathParticle): void;
+    update(): void;
+    private createDirs;
+}

package/types/PolygonPathParticle.d.ts

@@ -0,0 +1,6 @@
+import type { IParticle } from "@tsparticles/engine";
+export type PolygonPathParticle = IParticle & {
+    hexDirection?: number;
+    hexSpeed?: number;
+    hexStep?: number;
+};

package/types/index.d.ts

@@ -0,0 +1,3 @@
+import type { Engine } from "@tsparticles/engine";
+export declare const polygonPathName = "polygonPathGenerator";
+export declare function loadPolygonPath(engine: Engine): void;

package/umd/IPolygonPathOptions.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/PolygonPathGenerator.js

@@ -0,0 +1,69 @@
+(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.PolygonPathGenerator = void 0;
+    const engine_1 = require("@tsparticles/engine");
+    class PolygonPathGenerator {
+        constructor() {
+            this.dirsList = [];
+            this.options = {
+                sides: 6,
+                turnSteps: 20,
+                angle: 30,
+            };
+        }
+        generate(p) {
+            if (p.hexStep === undefined) {
+                p.hexStep = 0;
+            }
+            if (p.hexDirection === undefined) {
+                p.hexDirection =
+                    this.options.sides === 6 ? (((0, engine_1.getRandom)() * 3) | 0) * 2 : ((0, engine_1.getRandom)() * this.options.sides) | 0;
+            }
+            if (p.hexSpeed === undefined) {
+                p.hexSpeed = p.velocity.length;
+            }
+            if (p.hexStep % this.options.turnSteps === 0) {
+                p.hexDirection =
+                    (0, engine_1.getRandom)() > 0.5
+                        ? (p.hexDirection + 1) % this.options.sides
+                        : (p.hexDirection + this.options.sides - 1) % this.options.sides;
+            }
+            p.velocity.x = 0;
+            p.velocity.y = 0;
+            p.hexStep++;
+            return engine_1.Vector.create(this.dirsList[p.hexDirection].x * p.hexSpeed, this.dirsList[p.hexDirection].y * p.hexSpeed);
+        }
+        init(container) {
+            var _a;
+            const options = container.actualOptions.particles.move.path.options;
+            this.options.sides = options.sides > 0 ? options.sides : 6;
+            this.options.angle = (_a = options.angle) !== null && _a !== void 0 ? _a : 30;
+            this.options.turnSteps = options.turnSteps >= 0 ? options.turnSteps : 20;
+            this.createDirs();
+        }
+        reset(particle) {
+            delete particle.hexStep;
+            delete particle.hexDirection;
+            delete particle.hexSpeed;
+        }
+        update() {
+        }
+        createDirs() {
+            this.dirsList = [];
+            for (let i = 0; i < 360; i += 360 / this.options.sides) {
+                const angle = this.options.angle + i;
+                this.dirsList.push(engine_1.Vector.create(Math.cos((angle * Math.PI) / 180), Math.sin((angle * Math.PI) / 180)));
+            }
+        }
+    }
+    exports.PolygonPathGenerator = PolygonPathGenerator;
+});

package/umd/PolygonPathParticle.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,19 @@
+(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", "./PolygonPathGenerator"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadPolygonPath = exports.polygonPathName = void 0;
+    const PolygonPathGenerator_1 = require("./PolygonPathGenerator");
+    exports.polygonPathName = "polygonPathGenerator";
+    function loadPolygonPath(engine) {
+        engine.addPathGenerator(exports.polygonPathName, new PolygonPathGenerator_1.PolygonPathGenerator());
+    }
+    exports.loadPolygonPath = loadPolygonPath;
+});