sim.js

(function () {
  "use strict";

  function clamp01(value) {
    if (value < 0) {
      return 0;
    }
    if (value > 1) {
      return 1;
    }
    return value;
  }

  function createField(size, seedValue) {
    var field = new Float32Array(size);
    if (seedValue !== 0) {
      field.fill(seedValue);
    }
    return field;
  }

  function getDamping(config, concentration) {
    return Math.max(0, config.D0 * (1 - config.alpha * concentration));
  }

  function hashSeed(seedValue, salt) {
    var seedText = String(seedValue) + "|" + String(salt || "");
    var hash = 2166136261;

    for (var i = 0; i < seedText.length; i += 1) {
      hash ^= seedText.charCodeAt(i);
      hash = Math.imul(hash, 16777619);
    }

    return hash >>> 0;
  }

  function createRng(seedValue, salt) {
    var state = hashSeed(seedValue, salt) || 1;

    return function () {
      state = (Math.imul(state, 1664525) + 1013904223) >>> 0;
      return state / 4294967296;
    };
  }

  function clamp(value, min, max) {
    if (value < min) {
      return min;
    }
    if (value > max) {
      return max;
    }
    return value;
  }

  function createSalienceCenters(sim, side) {
    var count = 8;
    var centers = new Array(count);
    var rng = createRng(sim.config.seed, "event|" + side);
    var width = sim.width;
    var height = sim.height;

    for (var i = 0; i < count; i += 1) {
      var x = rng() * (width - 1);
      var y = rng() * (height - 1);

      if (side === "Left") {
        x *= 0.65;
      } else if (side === "Right") {
        x = (width - 1) - (((width - 1) - x) * 0.65);
      } else if (side === "Top") {
        y *= 0.65;
      } else if (side === "Bottom") {
        y = (height - 1) - (((height - 1) - y) * 0.65);
      }

      centers[i] = {
        x: clamp(x, 0, width - 1),
        y: clamp(y, 0, height - 1)
      };
    }

    return centers;
  }

  function seedInitialState(sim) {
    var size = sim.width * sim.height;
    var baseA = 0.18;
    var baseR = 0.07;
    var rng = createRng(sim.config.seed, sim.seedMode);
    var noiseScaleA = 0.08;
    var noiseScaleR = 0.06;

    for (var i = 0; i < size; i += 1) {
      sim.a[i] = clamp01(baseA + ((rng() - 0.5) * noiseScaleA));
      sim.r[i] = clamp01(baseR + ((rng() - 0.5) * noiseScaleR));
    }

    sim.event.centers = createSalienceCenters(sim, sim.config.pulseSide || "Left");

    if (sim.seedMode === "compare-right") {
      var leaderCount = 12;
      var leaderRadius = 3;
      for (var leader = 0; leader < leaderCount; leader += 1) {
        var leaderX = Math.floor(rng() * sim.width);
        var leaderY = Math.floor(rng() * sim.height);
        for (var oy = -leaderRadius; oy <= leaderRadius; oy += 1) {
          for (var ox = -leaderRadius; ox <= leaderRadius; ox += 1) {
            if ((ox * ox) + (oy * oy) > (leaderRadius * leaderRadius)) {
              continue;
            }

            var nx = leaderX + ox;
            var ny = leaderY + oy;
            if (nx < 0 || ny < 0 || nx >= sim.width || ny >= sim.height) {
              continue;
            }

            var leaderIdx = (ny * sim.width) + nx;
            sim.r[leaderIdx] = Math.max(sim.r[leaderIdx], 0.95);
            sim.a[leaderIdx] = clamp01(sim.a[leaderIdx] + 0.10);
          }
        }
      }
    }
  }

  function createSim(config, options) {
    var width = config.width || 120;
    var height = config.height || 80;
    var size = width * height;
    var simOptions = options || {};

    var sim = {
      width: width,
      height: height,
      size: size,
      config: config,
      lastDt: config.dt || (1 / 60),
      nanFixups: 0,
      seedMode: simOptions.seedMode || "default",
      a: createField(size, 0),
      aNext: createField(size, 0),
      r: createField(size, 0),
      rNext: createField(size, 0),
      event: {
        active: false,
        mode: "drop",
        origin: {
          x: Math.floor(width / 2),
          y: Math.floor(height / 2)
        },
        radius: 10,
        sigma: 10,
        centers: [],
        intensity: 0,
        duration: 0,
        remaining: 0,
        refPressure: 0
      }
    };

    seedInitialState(sim);
    return sim;
  }

  function resetSim(sim) {
    seedInitialState(sim);
    sim.nanFixups = 0;
    sim.lastDt = sim.config.dt || (1 / 60);
    sim.event.active = false;
    sim.event.remaining = 0;
  }

  function applyEvent(sim, dt) {
    if (!sim.event.active || sim.event.remaining <= 0) {
      sim.event.active = false;
      return;
    }

    var width = sim.width;
    var height = sim.height;
    var globalA = 0.08 * sim.event.intensity;
    var globalR = 0.02 * sim.event.refPressure;
    var localA = 0.18 * sim.event.intensity;
    var localR = 0.14 * sim.event.refPressure;
    var centers = sim.event.centers;
    var sigma = 10;
    var invTwoSigmaSq = 1 / (2 * sigma * sigma);

    for (var y = 0; y < height; y += 1) {
      for (var x = 0; x < width; x += 1) {
        var salience = 0;
        for (var c = 0; c < centers.length; c += 1) {
          var dx = x - centers[c].x;
          var dy = y - centers[c].y;
          var influence = Math.exp(-(((dx * dx) + (dy * dy)) * invTwoSigmaSq));
          if (influence > salience) {
            salience = influence;
          }
        }

        var idx = y * width + x;
        var aDelta = dt * (globalA + (localA * salience));
        var rDelta = dt * (globalR + (localR * salience));
        sim.a[idx] = clamp01(sim.a[idx] + aDelta);
        sim.r[idx] = clamp01(sim.r[idx] + rDelta);
      }
    }

    sim.event.remaining -= dt;
    if (sim.event.remaining <= 0) {
      sim.event.active = false;
    }
  }

  function injectPulse(sim, side, strength, duration, refBias, mode, radius, centerX, centerY) {
    sim.event.active = true;
    sim.event.mode = mode === "drop" ? "drop" : "edge";
    sim.event.origin = {
      x: Number.isFinite(centerX) ? centerX : Math.floor(sim.width / 2),
      y: Number.isFinite(centerY) ? centerY : Math.floor(sim.height / 2)
    };
    sim.event.radius = Math.max(1, radius || 10);
    sim.event.sigma = 10;
    if (!sim.event.centers || sim.event.centers.length === 0) {
      sim.event.centers = createSalienceCenters(sim, sim.config.pulseSide || side || "Left");
    }
    sim.event.intensity = Math.max(0, strength);
    sim.event.duration = Math.max(0, duration);
    sim.event.remaining = sim.event.duration;
    sim.event.refPressure = Math.max(0, refBias);

    if (sim.event.remaining === 0) {
      sim.event.remaining = 1 / 60;
    }
  }

  function stepSim(sim, dt) {
    if (!Number.isFinite(dt) || dt <= 0) {
      throw new Error("Bad dt: " + dt);
    }

    sim.lastDt = dt;
    applyEvent(sim, dt);

    var width = sim.width;
    var height = sim.height;
    var size = sim.size;
    var a = sim.a;
    var r = sim.r;
    var aNext = sim.aNext;
    var rNext = sim.rNext;
    var config = sim.config;

    var concentration = 0;
    for (var i = 0; i < size; i += 1) {
      concentration += r[i];
    }
    concentration /= size;

    var damping = getDamping(config, concentration);
    if (!Number.isFinite(damping)) {
      damping = 0;
      sim.nanFixups += 1;
    }
    for (var y = 0; y < height; y += 1) {
      for (var x = 0; x < width; x += 1) {
        var idx = y * width + x;
        var neighborDrive = 0;
        var neighborSumA = 0;

        for (var oy = -1; oy <= 1; oy += 1) {
          for (var ox = -1; ox <= 1; ox += 1) {
            if (ox === 0 && oy === 0) {
              continue;
            }

            var nx = x + ox;
            var ny = y + oy;

            if (nx < 0 || ny < 0 || nx >= width || ny >= height) {
              continue;
            }

            var nIdx = ny * width + nx;
            neighborSumA += a[nIdx];
            neighborDrive += a[nIdx] * r[nIdx];
          }
        }

        var neighborAvgA = neighborSumA / 8;
        var amp = config.kappa * neighborDrive;
        var prop = config.kappa * (neighborAvgA - a[idx]);
        var nextA = a[idx] + (dt * (prop + amp - (damping * a[idx])));
        var nextR = r[idx] + dt * (config.eta * (a[idx] - config.theta));

        if (!Number.isFinite(nextA)) {
          nextA = 0;
          sim.nanFixups += 1;
        }

        if (!Number.isFinite(nextR)) {
          nextR = 0;
          sim.nanFixups += 1;
        }

        aNext[idx] = clamp01(nextA);
        rNext[idx] = clamp01(nextR);
      }
    }

    sim.a = aNext;
    sim.aNext = a;
    sim.r = rNext;
    sim.rNext = r;
  }

  window.SimModule = {
    createSim: createSim,
    stepSim: stepSim,
    resetSim: resetSim,
    injectPulse: injectPulse,
    getDamping: getDamping
  };
}());