@sg-pattern-engine/algorithms 1.0.0

package/.turbo/turbo-build.log

@@ -0,0 +1,19 @@
+
+> @sg-pattern-engine/algorithms@1.0.0 build /workspace/packages/algorithms
+> tsup src/index.ts --format cjs,esm --dts --clean
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Target: es2020
+CLI Cleaning output folder
+CJS Build start
+ESM Build start
+ESM dist/index.mjs 4.55 KB
+ESM ⚡️ Build success in 69ms
+CJS dist/index.js 5.73 KB
+CJS ⚡️ Build success in 73ms
+DTS Build start
+DTS ⚡️ Build success in 2012ms
+DTS dist/index.d.ts  1.34 KB
+DTS dist/index.d.mts 1.34 KB

package/dist/index.d.mts

@@ -0,0 +1,44 @@
+import { AlgorithmPlugin, AlgorithmContext, AlgorithmOutput } from '@sg-pattern-engine/core';
+
+declare class PerlinNoisePlugin implements AlgorithmPlugin {
+    name: string;
+    generate(ctx: AlgorithmContext): AlgorithmOutput;
+    private noise;
+}
+
+declare class FlowFieldPlugin implements AlgorithmPlugin {
+    name: string;
+    generate(ctx: AlgorithmContext): AlgorithmOutput;
+}
+
+declare class VoronoiPlugin implements AlgorithmPlugin {
+    name: string;
+    generate(ctx: AlgorithmContext): AlgorithmOutput;
+}
+
+/**
+ * Gray-Scott reaction-diffusion.
+ * Two chemical species A and B diffuse and react:
+ *   A + 2B → 3B   (A is consumed, B is produced)
+ *   B → P         (B decays at kill rate k)
+ *
+ * Classic parameter sets:
+ *   Coral:    f=0.0545, k=0.062
+ *   Mitosis:  f=0.0367, k=0.0649
+ *   Solitons: f=0.030,  k=0.060
+ *   Worms:    f=0.058,  k=0.065
+ *   Spots:    f=0.035,  k=0.060
+ */
+declare class ReactionDiffusionPlugin implements AlgorithmPlugin {
+    name: string;
+    private readonly DA;
+    private readonly DB;
+    private readonly F;
+    private readonly K;
+    private readonly DT;
+    generate(ctx: AlgorithmContext): AlgorithmOutput;
+}
+
+declare const algorithms: (PerlinNoisePlugin | FlowFieldPlugin | VoronoiPlugin | ReactionDiffusionPlugin)[];
+
+export { FlowFieldPlugin, PerlinNoisePlugin, ReactionDiffusionPlugin, VoronoiPlugin, algorithms };

package/dist/index.d.ts

@@ -0,0 +1,44 @@
+import { AlgorithmPlugin, AlgorithmContext, AlgorithmOutput } from '@sg-pattern-engine/core';
+
+declare class PerlinNoisePlugin implements AlgorithmPlugin {
+    name: string;
+    generate(ctx: AlgorithmContext): AlgorithmOutput;
+    private noise;
+}
+
+declare class FlowFieldPlugin implements AlgorithmPlugin {
+    name: string;
+    generate(ctx: AlgorithmContext): AlgorithmOutput;
+}
+
+declare class VoronoiPlugin implements AlgorithmPlugin {
+    name: string;
+    generate(ctx: AlgorithmContext): AlgorithmOutput;
+}
+
+/**
+ * Gray-Scott reaction-diffusion.
+ * Two chemical species A and B diffuse and react:
+ *   A + 2B → 3B   (A is consumed, B is produced)
+ *   B → P         (B decays at kill rate k)
+ *
+ * Classic parameter sets:
+ *   Coral:    f=0.0545, k=0.062
+ *   Mitosis:  f=0.0367, k=0.0649
+ *   Solitons: f=0.030,  k=0.060
+ *   Worms:    f=0.058,  k=0.065
+ *   Spots:    f=0.035,  k=0.060
+ */
+declare class ReactionDiffusionPlugin implements AlgorithmPlugin {
+    name: string;
+    private readonly DA;
+    private readonly DB;
+    private readonly F;
+    private readonly K;
+    private readonly DT;
+    generate(ctx: AlgorithmContext): AlgorithmOutput;
+}
+
+declare const algorithms: (PerlinNoisePlugin | FlowFieldPlugin | VoronoiPlugin | ReactionDiffusionPlugin)[];
+
+export { FlowFieldPlugin, PerlinNoisePlugin, ReactionDiffusionPlugin, VoronoiPlugin, algorithms };

package/dist/index.js

@@ -0,0 +1,181 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FlowFieldPlugin: () => FlowFieldPlugin,
+  PerlinNoisePlugin: () => PerlinNoisePlugin,
+  ReactionDiffusionPlugin: () => ReactionDiffusionPlugin,
+  VoronoiPlugin: () => VoronoiPlugin,
+  algorithms: () => algorithms
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/noise/perlin.ts
+var PerlinNoisePlugin = class {
+  constructor() {
+    this.name = "perlin";
+  }
+  generate(ctx) {
+    const { width, height } = ctx.tile;
+    const field = ctx.fieldManager.createScalarField("perlin", width, height);
+    const scale = ctx.config.scale || 0.01;
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < ctx.tile.width; x++) {
+        const val = this.noise(
+          (ctx.tile.offsetX + x) * scale,
+          (ctx.tile.offsetY + y) * scale,
+          ctx.rng.random()
+        );
+        field.set(x, y, val);
+      }
+    }
+    return { type: "scalarField", data: field.data, width, height };
+  }
+  noise(x, y, seed) {
+    return Math.sin(x * 12.9898 + y * 78.233 + seed * 43758.5453) * 0.5 + 0.5;
+  }
+};
+
+// src/particles/flowField.ts
+var FlowFieldPlugin = class {
+  constructor() {
+    this.name = "flowField";
+  }
+  generate(ctx) {
+    const { width, height } = ctx.tile;
+    const field = ctx.fieldManager.createVectorField("flow", width, height);
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        const angle = ctx.rng.random() * Math.PI * 2;
+        field.set(x, y, Math.cos(angle), Math.sin(angle));
+      }
+    }
+    return { type: "vectorField", data: field.data, width, height };
+  }
+};
+
+// src/geometry/voronoi.ts
+var VoronoiPlugin = class {
+  constructor() {
+    this.name = "voronoi";
+  }
+  generate(ctx) {
+    const pointsCount = ctx.config.density || 50;
+    const points = [];
+    for (let i = 0; i < pointsCount; i++) {
+      points.push({
+        x: ctx.rng.random() * ctx.tile.totalWidth,
+        y: ctx.rng.random() * ctx.tile.totalHeight
+      });
+    }
+    return { type: "points", data: points };
+  }
+};
+
+// src/automata/reactionDiffusion.ts
+var ReactionDiffusionPlugin = class {
+  constructor() {
+    this.name = "reactionDiffusion";
+    // Default Gray-Scott parameters — coral growth preset
+    this.DA = 1;
+    // diffusion rate of A
+    this.DB = 0.5;
+    // diffusion rate of B
+    this.F = 0.0545;
+    // feed rate
+    this.K = 0.062;
+    // kill rate
+    this.DT = 1;
+  }
+  // time step
+  generate(ctx) {
+    const { width, height } = ctx.tile;
+    const iterations = ctx.config.iterations ?? 2e3;
+    let A = new Float32Array(width * height);
+    let B = new Float32Array(width * height);
+    let nextA = new Float32Array(width * height);
+    let nextB = new Float32Array(width * height);
+    const f = ctx.config.feedRate ?? this.F;
+    const k = ctx.config.killRate ?? this.K;
+    const da = this.DA;
+    const db = this.DB;
+    const dt = this.DT;
+    A.fill(1);
+    B.fill(0);
+    const patchCount = Math.max(1, Math.floor(width * height * 1e-3));
+    const patchRadius = Math.max(3, Math.floor(Math.min(width, height) * 0.04));
+    for (let p = 0; p < patchCount; p++) {
+      const cx = Math.floor(ctx.rng.random() * width);
+      const cy = Math.floor(ctx.rng.random() * height);
+      for (let dy = -patchRadius; dy <= patchRadius; dy++) {
+        for (let dx = -patchRadius; dx <= patchRadius; dx++) {
+          if (dx * dx + dy * dy > patchRadius * patchRadius) continue;
+          const nx = (cx + dx + width) % width;
+          const ny = (cy + dy + height) % height;
+          const i = ny * width + nx;
+          A[i] = 0.5 + ctx.rng.random() * 0.1;
+          B[i] = 0.25 + ctx.rng.random() * 0.1;
+        }
+      }
+    }
+    for (let iter = 0; iter < iterations; iter++) {
+      for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+          const i = y * width + x;
+          const xL = (x - 1 + width) % width;
+          const xR = (x + 1) % width;
+          const yU = (y - 1 + height) % height;
+          const yD = (y + 1) % height;
+          const lapA = A[yU * width + x] + A[yD * width + x] + A[y * width + xL] + A[y * width + xR] - 4 * A[i];
+          const lapB = B[yU * width + x] + B[yD * width + x] + B[y * width + xL] + B[y * width + xR] - 4 * B[i];
+          const a = A[i];
+          const b = B[i];
+          const reaction = a * b * b;
+          nextA[i] = Math.max(0, Math.min(1, a + dt * (da * lapA - reaction + f * (1 - a))));
+          nextB[i] = Math.max(0, Math.min(1, b + dt * (db * lapB + reaction - (k + f) * b)));
+        }
+      }
+      const tmpA = A;
+      A = nextA;
+      nextA = tmpA;
+      const tmpB = B;
+      B = nextB;
+      nextB = tmpB;
+    }
+    return { type: "scalarField", data: B, width, height };
+  }
+};
+
+// src/index.ts
+var algorithms = [
+  new PerlinNoisePlugin(),
+  new FlowFieldPlugin(),
+  new VoronoiPlugin(),
+  new ReactionDiffusionPlugin()
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FlowFieldPlugin,
+  PerlinNoisePlugin,
+  ReactionDiffusionPlugin,
+  VoronoiPlugin,
+  algorithms
+});

package/dist/index.mjs

@@ -0,0 +1,150 @@
+// src/noise/perlin.ts
+var PerlinNoisePlugin = class {
+  constructor() {
+    this.name = "perlin";
+  }
+  generate(ctx) {
+    const { width, height } = ctx.tile;
+    const field = ctx.fieldManager.createScalarField("perlin", width, height);
+    const scale = ctx.config.scale || 0.01;
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < ctx.tile.width; x++) {
+        const val = this.noise(
+          (ctx.tile.offsetX + x) * scale,
+          (ctx.tile.offsetY + y) * scale,
+          ctx.rng.random()
+        );
+        field.set(x, y, val);
+      }
+    }
+    return { type: "scalarField", data: field.data, width, height };
+  }
+  noise(x, y, seed) {
+    return Math.sin(x * 12.9898 + y * 78.233 + seed * 43758.5453) * 0.5 + 0.5;
+  }
+};
+
+// src/particles/flowField.ts
+var FlowFieldPlugin = class {
+  constructor() {
+    this.name = "flowField";
+  }
+  generate(ctx) {
+    const { width, height } = ctx.tile;
+    const field = ctx.fieldManager.createVectorField("flow", width, height);
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        const angle = ctx.rng.random() * Math.PI * 2;
+        field.set(x, y, Math.cos(angle), Math.sin(angle));
+      }
+    }
+    return { type: "vectorField", data: field.data, width, height };
+  }
+};
+
+// src/geometry/voronoi.ts
+var VoronoiPlugin = class {
+  constructor() {
+    this.name = "voronoi";
+  }
+  generate(ctx) {
+    const pointsCount = ctx.config.density || 50;
+    const points = [];
+    for (let i = 0; i < pointsCount; i++) {
+      points.push({
+        x: ctx.rng.random() * ctx.tile.totalWidth,
+        y: ctx.rng.random() * ctx.tile.totalHeight
+      });
+    }
+    return { type: "points", data: points };
+  }
+};
+
+// src/automata/reactionDiffusion.ts
+var ReactionDiffusionPlugin = class {
+  constructor() {
+    this.name = "reactionDiffusion";
+    // Default Gray-Scott parameters — coral growth preset
+    this.DA = 1;
+    // diffusion rate of A
+    this.DB = 0.5;
+    // diffusion rate of B
+    this.F = 0.0545;
+    // feed rate
+    this.K = 0.062;
+    // kill rate
+    this.DT = 1;
+  }
+  // time step
+  generate(ctx) {
+    const { width, height } = ctx.tile;
+    const iterations = ctx.config.iterations ?? 2e3;
+    let A = new Float32Array(width * height);
+    let B = new Float32Array(width * height);
+    let nextA = new Float32Array(width * height);
+    let nextB = new Float32Array(width * height);
+    const f = ctx.config.feedRate ?? this.F;
+    const k = ctx.config.killRate ?? this.K;
+    const da = this.DA;
+    const db = this.DB;
+    const dt = this.DT;
+    A.fill(1);
+    B.fill(0);
+    const patchCount = Math.max(1, Math.floor(width * height * 1e-3));
+    const patchRadius = Math.max(3, Math.floor(Math.min(width, height) * 0.04));
+    for (let p = 0; p < patchCount; p++) {
+      const cx = Math.floor(ctx.rng.random() * width);
+      const cy = Math.floor(ctx.rng.random() * height);
+      for (let dy = -patchRadius; dy <= patchRadius; dy++) {
+        for (let dx = -patchRadius; dx <= patchRadius; dx++) {
+          if (dx * dx + dy * dy > patchRadius * patchRadius) continue;
+          const nx = (cx + dx + width) % width;
+          const ny = (cy + dy + height) % height;
+          const i = ny * width + nx;
+          A[i] = 0.5 + ctx.rng.random() * 0.1;
+          B[i] = 0.25 + ctx.rng.random() * 0.1;
+        }
+      }
+    }
+    for (let iter = 0; iter < iterations; iter++) {
+      for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+          const i = y * width + x;
+          const xL = (x - 1 + width) % width;
+          const xR = (x + 1) % width;
+          const yU = (y - 1 + height) % height;
+          const yD = (y + 1) % height;
+          const lapA = A[yU * width + x] + A[yD * width + x] + A[y * width + xL] + A[y * width + xR] - 4 * A[i];
+          const lapB = B[yU * width + x] + B[yD * width + x] + B[y * width + xL] + B[y * width + xR] - 4 * B[i];
+          const a = A[i];
+          const b = B[i];
+          const reaction = a * b * b;
+          nextA[i] = Math.max(0, Math.min(1, a + dt * (da * lapA - reaction + f * (1 - a))));
+          nextB[i] = Math.max(0, Math.min(1, b + dt * (db * lapB + reaction - (k + f) * b)));
+        }
+      }
+      const tmpA = A;
+      A = nextA;
+      nextA = tmpA;
+      const tmpB = B;
+      B = nextB;
+      nextB = tmpB;
+    }
+    return { type: "scalarField", data: B, width, height };
+  }
+};
+
+// src/index.ts
+var algorithms = [
+  new PerlinNoisePlugin(),
+  new FlowFieldPlugin(),
+  new VoronoiPlugin(),
+  new ReactionDiffusionPlugin()
+];
+export {
+  FlowFieldPlugin,
+  PerlinNoisePlugin,
+  ReactionDiffusionPlugin,
+  VoronoiPlugin,
+  algorithms
+};

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@sg-pattern-engine/algorithms",
+  "version": "1.0.0",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@sg-pattern-engine/core": "1.0.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean"
+  }
+}

package/src/automata/reactionDiffusion.ts

@@ -0,0 +1,111 @@
+import { AlgorithmPlugin, AlgorithmContext, AlgorithmOutput } from '@sg-pattern-engine/core';
+
+/**
+ * Gray-Scott reaction-diffusion.
+ * Two chemical species A and B diffuse and react:
+ *   A + 2B → 3B   (A is consumed, B is produced)
+ *   B → P         (B decays at kill rate k)
+ *
+ * Classic parameter sets:
+ *   Coral:    f=0.0545, k=0.062
+ *   Mitosis:  f=0.0367, k=0.0649
+ *   Solitons: f=0.030,  k=0.060
+ *   Worms:    f=0.058,  k=0.065
+ *   Spots:    f=0.035,  k=0.060
+ */
+export class ReactionDiffusionPlugin implements AlgorithmPlugin {
+  name = 'reactionDiffusion';
+
+  // Default Gray-Scott parameters — coral growth preset
+  private readonly DA   = 1.0;    // diffusion rate of A
+  private readonly DB   = 0.5;    // diffusion rate of B
+  private readonly F    = 0.0545; // feed rate
+  private readonly K    = 0.062;  // kill rate
+  private readonly DT   = 1.0;    // time step
+
+  generate(ctx: AlgorithmContext): AlgorithmOutput {
+    const { width, height } = ctx.tile;
+    const iterations = ctx.config.iterations ?? 2000;
+
+    // Allocate two channels: A (activator) and B (inhibitor)
+    // Flat arrays: index = y * width + x
+    let A = new Float32Array(width * height);
+    let B = new Float32Array(width * height);
+    let nextA = new Float32Array(width * height);
+    let nextB = new Float32Array(width * height);
+
+    // Allow parameter overrides via config
+    const f = ctx.config.feedRate ?? this.F;
+    const k = ctx.config.killRate ?? this.K;
+    const da = this.DA;
+    const db = this.DB;
+    const dt = this.DT;
+
+    // ── Initialise ─────────────────────────────────────────────────────────
+    // Fill A=1 everywhere, seed random B=1 patches
+    A.fill(1.0);
+    B.fill(0.0);
+
+    const patchCount = Math.max(1, Math.floor(width * height * 0.001));
+    const patchRadius = Math.max(3, Math.floor(Math.min(width, height) * 0.04));
+
+    for (let p = 0; p < patchCount; p++) {
+      const cx = Math.floor(ctx.rng.random() * width);
+      const cy = Math.floor(ctx.rng.random() * height);
+      for (let dy = -patchRadius; dy <= patchRadius; dy++) {
+        for (let dx = -patchRadius; dx <= patchRadius; dx++) {
+          if (dx * dx + dy * dy > patchRadius * patchRadius) continue;
+          const nx = ((cx + dx) + width)  % width;
+          const ny = ((cy + dy) + height) % height;
+          const i  = ny * width + nx;
+          A[i] = 0.5 + ctx.rng.random() * 0.1;
+          B[i] = 0.25 + ctx.rng.random() * 0.1;
+        }
+      }
+    }
+
+    // ── Iterate Gray-Scott ──────────────────────────────────────────────────
+    for (let iter = 0; iter < iterations; iter++) {
+      for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+          const i = y * width + x;
+
+          // Wrap-around neighbour indices
+          const xL = (x - 1 + width)  % width;
+          const xR = (x + 1)          % width;
+          const yU = (y - 1 + height) % height;
+          const yD = (y + 1)          % height;
+
+          // Discrete Laplacian (5-point stencil)
+          const lapA =
+            A[yU * width + x ] +
+            A[yD * width + x ] +
+            A[y  * width + xL] +
+            A[y  * width + xR] -
+            4.0 * A[i];
+
+          const lapB =
+            B[yU * width + x ] +
+            B[yD * width + x ] +
+            B[y  * width + xL] +
+            B[y  * width + xR] -
+            4.0 * B[i];
+
+          const a = A[i];
+          const b = B[i];
+          const reaction = a * b * b;
+
+          nextA[i] = Math.max(0, Math.min(1, a + dt * (da * lapA - reaction + f * (1 - a))));
+          nextB[i] = Math.max(0, Math.min(1, b + dt * (db * lapB + reaction - (k + f) * b)));
+        }
+      }
+
+      // Swap buffers without allocation
+      const tmpA = A; A = nextA; nextA = tmpA;
+      const tmpB = B; B = nextB; nextB = tmpB;
+    }
+
+    // Return B channel — this is where the patterns form
+    return { type: 'scalarField', data: B, width, height };
+  }
+}

package/src/geometry/voronoi.ts

@@ -0,0 +1,19 @@
+import { AlgorithmPlugin, AlgorithmContext, AlgorithmOutput } from '@sg-pattern-engine/core';
+
+export class VoronoiPlugin implements AlgorithmPlugin {
+  name = 'voronoi';
+
+  generate(ctx: AlgorithmContext): AlgorithmOutput {
+    const pointsCount = ctx.config.density || 50;
+    const points = [];
+
+    for (let i = 0; i < pointsCount; i++) {
+      points.push({
+        x: ctx.rng.random() * ctx.tile.totalWidth,
+        y: ctx.rng.random() * ctx.tile.totalHeight
+      });
+    }
+
+    return { type: 'points', data: points };
+  }
+}

package/src/index.ts

@@ -0,0 +1,16 @@
+import { PerlinNoisePlugin } from './noise/perlin';
+import { FlowFieldPlugin } from './particles/flowField';
+import { VoronoiPlugin } from './geometry/voronoi';
+import { ReactionDiffusionPlugin } from './automata/reactionDiffusion';
+
+export const algorithms = [
+  new PerlinNoisePlugin(),
+  new FlowFieldPlugin(),
+  new VoronoiPlugin(),
+  new ReactionDiffusionPlugin()
+];
+
+export * from './noise/perlin';
+export * from './particles/flowField';
+export * from './geometry/voronoi';
+export * from './automata/reactionDiffusion';

package/src/noise/perlin.ts

@@ -0,0 +1,29 @@
+import { AlgorithmPlugin, AlgorithmContext, AlgorithmOutput } from '@sg-pattern-engine/core';
+
+// Simplified deterministic Perlin implementation
+export class PerlinNoisePlugin implements AlgorithmPlugin {
+  name = 'perlin';
+
+  generate(ctx: AlgorithmContext): AlgorithmOutput {
+    const { width, height } = ctx.tile;
+    const field = ctx.fieldManager.createScalarField('perlin', width, height);
+    const scale = ctx.config.scale || 0.01;
+
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < ctx.tile.width; x++) {
+        const val = this.noise(
+          (ctx.tile.offsetX + x) * scale, 
+          (ctx.tile.offsetY + y) * scale,
+          ctx.rng.random()
+        );
+        field.set(x, y, val);
+      }
+    }
+    return { type: 'scalarField', data: field.data, width, height };
+  }
+
+  private noise(x: number, y: number, seed: number): number {
+    // Deterministic hash-based noise approximation
+    return Math.sin(x * 12.9898 + y * 78.233 + seed * 43758.5453) * 0.5 + 0.5;
+  }
+}

package/src/particles/flowField.ts

@@ -0,0 +1,18 @@
+import { AlgorithmPlugin, AlgorithmContext, AlgorithmOutput } from '@sg-pattern-engine/core';
+
+export class FlowFieldPlugin implements AlgorithmPlugin {
+  name = 'flowField';
+
+  generate(ctx: AlgorithmContext): AlgorithmOutput {
+    const { width, height } = ctx.tile;
+    const field = ctx.fieldManager.createVectorField('flow', width, height);
+    
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        const angle = ctx.rng.random() * Math.PI * 2;
+        field.set(x, y, Math.cos(angle), Math.sin(angle));
+      }
+    }
+    return { type: 'vectorField', data: field.data, width, height };
+  }
+}

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "moduleResolution": "bundler",
+    "paths": {
+      "@sg-pattern-engine/core": ["../core/dist/index.d.ts"]
+    }
+  },
+  "include": ["src"]
+}