@adatechnology/game-weather 0.0.0-stage → 0.1.1

package/dist/index.global.js

@@ -0,0 +1,1131 @@
+"use strict";
+var GameWeather = (() => {
+  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, {
+    CLIMATES: () => CLIMATES,
+    DAY_REAL_SECONDS: () => DAY_REAL_SECONDS,
+    DEFAULT_DRY_OUT_SECONDS: () => DEFAULT_DRY_OUT_SECONDS,
+    DEFAULT_START_HOUR: () => DEFAULT_START_HOUR,
+    DEFAULT_TIME_SCALE: () => DEFAULT_TIME_SCALE,
+    DEFAULT_WET_RISE_SECONDS: () => DEFAULT_WET_RISE_SECONDS,
+    DRY_VISIBILITY_METERS: () => DRY_VISIBILITY_METERS,
+    FLASH_END_SECONDS: () => FLASH_END_SECONDS,
+    GAME_DAY_SECONDS: () => GAME_DAY_SECONDS,
+    NIGHT_SIGHT_LOSS: () => NIGHT_SIGHT_LOSS,
+    SPEED_OF_SOUND: () => SPEED_OF_SOUND,
+    STATE_VALUE_KEYS: () => STATE_VALUE_KEYS,
+    WEATHER_STATES: () => WEATHER_STATES,
+    blendValues: () => blendValues,
+    createLightningStream: () => createLightningStream,
+    createRng: () => createRng,
+    createScheduler: () => createScheduler,
+    createStream: () => createStream,
+    createTimeline: () => createTimeline,
+    createWeather: () => createWeather,
+    createWeatherRegistry: () => createWeatherRegistry,
+    createWeatherTestModule: () => createWeatherTestModule,
+    createWetness: () => createWetness,
+    dayFractionAt: () => dayFractionAt,
+    daylight: () => daylight,
+    deriveEffects: () => deriveEffects,
+    flashIntensity: () => flashIntensity,
+    heatIndexC: () => heatIndexC,
+    heatStress: () => heatStress,
+    streamSeed: () => streamSeed,
+    thunderDelay: () => thunderDelay,
+    valuesOf: () => valuesOf,
+    weatherBenchTextOf: () => weatherBenchTextOf
+  });
+
+  // src/blend.ts
+  var STATE_VALUE_KEYS = [
+    "rain",
+    "drops",
+    "sheets",
+    "windX",
+    "windZ",
+    "gust",
+    "fogFar",
+    "fogDensity",
+    "skyScale",
+    "visibility",
+    "humidity",
+    "temperatureDeltaC",
+    "wetness",
+    "hearingScale",
+    "footstepScale",
+    "dryingScale",
+    "debrisPush",
+    "haze",
+    "mistPerSecond",
+    "ashPerSecond"
+  ];
+  function valuesOf(state) {
+    const values = {};
+    for (const key of STATE_VALUE_KEYS) values[key] = state[key];
+    return values;
+  }
+  function blendValues(from, to, progress) {
+    const amount = Math.min(1, Math.max(0, progress));
+    const blended = {};
+    for (const key of STATE_VALUE_KEYS) blended[key] = from[key] + (to[key] - from[key]) * amount;
+    return blended;
+  }
+
+  // src/daylight.ts
+  var DAY_REAL_SECONDS = 1200;
+  var GAME_DAY_SECONDS = 86400;
+  var DEFAULT_TIME_SCALE = GAME_DAY_SECONDS / DAY_REAL_SECONDS;
+  var NIGHT_SPAN = 2.2;
+  var clamp = (value, low, high) => value < low ? low : value > high ? high : value;
+  function daylight(dayFraction) {
+    const sun = clamp(Math.sin(dayFraction * Math.PI * 2 - Math.PI / 2) * 0.5 + 0.5, 0, 1);
+    return { sun, nightFactor: 1 - clamp(sun * NIGHT_SPAN, 0, 1) };
+  }
+  function dayFractionAt(startHour, gameSeconds) {
+    const fraction = (startHour / 24 + gameSeconds / GAME_DAY_SECONDS) % 1;
+    return fraction < 0 ? fraction + 1 : fraction;
+  }
+
+  // src/heat.ts
+  var HEAT_STRESS_BANDS = [
+    [27, 0],
+    [32, 1 / 3],
+    [41, 2 / 3],
+    [54, 1]
+  ];
+  var NOAA_REGRESSION_FROM_F = 80;
+  var toFahrenheit = (celsius) => celsius * 9 / 5 + 32;
+  var toCelsius = (fahrenheit) => (fahrenheit - 32) * 5 / 9;
+  function heatIndexC(temperatureC, relativeHumidityPercent) {
+    const t = toFahrenheit(temperatureC);
+    const r = relativeHumidityPercent;
+    const steadman = 0.5 * (t + 61 + (t - 68) * 1.2 + r * 0.094);
+    const simple = (steadman + t) / 2;
+    if (simple < NOAA_REGRESSION_FROM_F) return toCelsius(simple);
+    let index = -42.379 + 2.04901523 * t + 10.14333127 * r - 0.22475541 * t * r - 683783e-8 * t * t - 0.05481717 * r * r + 122874e-8 * t * t * r + 85282e-8 * t * r * r - 199e-8 * t * t * r * r;
+    if (r < 13 && t >= 80 && t <= 112) index -= (13 - r) / 4 * Math.sqrt((17 - Math.abs(t - 95)) / 17);
+    else if (r > 85 && t >= 80 && t <= 87) index += (r - 85) / 10 * ((87 - t) / 5);
+    return toCelsius(index);
+  }
+  function heatStress(heatIndex) {
+    const first = HEAT_STRESS_BANDS[0];
+    const last = HEAT_STRESS_BANDS[HEAT_STRESS_BANDS.length - 1];
+    if (heatIndex <= first[0]) return first[1];
+    if (heatIndex >= last[0]) return last[1];
+    for (let index = 1; index < HEAT_STRESS_BANDS.length; index++) {
+      const [upperC, upperStress] = HEAT_STRESS_BANDS[index];
+      const [lowerC, lowerStress] = HEAT_STRESS_BANDS[index - 1];
+      if (heatIndex <= upperC) return lowerStress + (heatIndex - lowerC) / (upperC - lowerC) * (upperStress - lowerStress);
+    }
+    return last[1];
+  }
+
+  // src/effects.ts
+  var DRY_VISIBILITY_METERS = 220;
+  var NIGHT_SIGHT_LOSS = 0.4;
+  function deriveEffects(input) {
+    const { values, nightFactor } = input;
+    const weatherSight = Math.min(1, Math.max(0, values.visibility / DRY_VISIBILITY_METERS));
+    const heatIndex = heatIndexC(input.temperatureC, input.humidityPercent);
+    return {
+      visibility: values.visibility,
+      sightScale: weatherSight * (1 - NIGHT_SIGHT_LOSS * nightFactor),
+      hearingScale: values.hearingScale,
+      footstepScale: values.footstepScale,
+      heatIndexC: heatIndex,
+      heatStress: heatStress(heatIndex),
+      lightningReveal: input.lightningReveal,
+      dryingScale: values.dryingScale,
+      debrisPush: values.debrisPush
+    };
+  }
+
+  // src/rng.ts
+  var FNV_OFFSET = 2166136261;
+  var FNV_PRIME = 16777619;
+  var MIX = 2654435761;
+  function createRng(seed) {
+    let state = seed >>> 0;
+    return () => {
+      state = state + 1831565813 >>> 0;
+      let mixed = Math.imul(state ^ state >>> 15, state | 1);
+      mixed ^= mixed + Math.imul(mixed ^ mixed >>> 7, mixed | 61);
+      return ((mixed ^ mixed >>> 14) >>> 0) / 4294967296;
+    };
+  }
+  function streamSeed(seed, name) {
+    let hash = FNV_OFFSET;
+    for (let index = 0; index < name.length; index++) hash = Math.imul(hash ^ name.charCodeAt(index), FNV_PRIME) >>> 0;
+    return Math.imul(seed >>> 0 ^ hash, MIX) >>> 0;
+  }
+  function createStream(seed, name) {
+    return createRng(streamSeed(seed, name));
+  }
+  function drawBetween(rng, range) {
+    return range[0] + rng() * (range[1] - range[0]);
+  }
+
+  // src/lightning.ts
+  var SPEED_OF_SOUND = 343;
+  var FLASH_END_SECONDS = 0.4;
+  function thunderDelay(distance) {
+    return distance / SPEED_OF_SOUND;
+  }
+  function flashIntensity(elapsed) {
+    if (elapsed < 0 || elapsed >= FLASH_END_SECONDS) return 0;
+    if (elapsed < 0.08) return 1;
+    if (elapsed < 0.16) return 0.2;
+    if (elapsed < 0.26) return 0.8;
+    return 0;
+  }
+  function createLightningStream(seed) {
+    const rng = createStream(seed, "lightning");
+    return {
+      first: (config) => drawBetween(rng, config.first),
+      interval: (config) => drawBetween(rng, config.interval),
+      place(config) {
+        const distance = drawBetween(rng, config.distance);
+        return { distance, bearing: rng() * 360 };
+      }
+    };
+  }
+
+  // src/data/climates.json
+  var climates_default = [
+    {
+      id: "temperate",
+      sources: ["galeria-vale-cinzento:L1393 (changes every 2-6 h, arrives from the west)", "design:T6 3.2 kit default: mostly clear and overcast, no extremes"],
+      start: "clear",
+      dwellHours: [2, 6],
+      blendMinutes: 10,
+      frontDirection: [1, 0],
+      temperatureC: { mean: 16, swing: 6 },
+      humidityOffset: 0,
+      transitions: {
+        clear: { overcast: 4, windy: 1, fog: 1, light_rain: 1 },
+        overcast: { clear: 3, light_rain: 3, heavy_rain: 1, fog: 1, windy: 1 },
+        light_rain: { overcast: 3, clear: 2, heavy_rain: 2 },
+        heavy_rain: { light_rain: 3, overcast: 2, storm: 1 },
+        storm: { heavy_rain: 3, light_rain: 2, overcast: 1 },
+        fog: { clear: 3, overcast: 2 },
+        windy: { clear: 3, overcast: 3, light_rain: 1 }
+      }
+    },
+    {
+      id: "tropical",
+      sources: ["galeria-vale-cinzento:L1393 (changes every 2-6 h, arrives from the west)", "design:T6 3.2 and Q3: extremes rare and enabled"],
+      start: "clear",
+      dwellHours: [2, 6],
+      blendMinutes: 10,
+      frontDirection: [1, 0],
+      temperatureC: { mean: 29, swing: 3 },
+      humidityOffset: 0.1,
+      transitions: {
+        clear: { overcast: 3, light_rain: 2, windy: 1, extreme_heat: 0.8 },
+        overcast: { clear: 3, light_rain: 3, heavy_rain: 2, fog: 0.5 },
+        light_rain: { overcast: 3, clear: 2, heavy_rain: 2 },
+        heavy_rain: { light_rain: 3, overcast: 2, storm: 1.5 },
+        storm: { heavy_rain: 3, light_rain: 2, overcast: 1, cyclone: 0.5 },
+        fog: { clear: 3, overcast: 2 },
+        windy: { clear: 3, overcast: 2, light_rain: 1, storm: 0.5 },
+        extreme_heat: { clear: 4, overcast: 2, storm: 0.8 },
+        cyclone: { storm: 3, heavy_rain: 2, typhoon: 0.5 },
+        typhoon: { cyclone: 3, storm: 2 }
+      }
+    }
+  ];
+
+  // src/data/states.json
+  var states_default = [
+    {
+      id: "clear",
+      sources: ["jogo:L69141 (fog far 220 dry)", "showroom.js:L1693-1710 (breeze 3.5, 1.5 m/s)"],
+      rain: 0,
+      drops: 0,
+      sheets: 0,
+      windX: 3.5,
+      windZ: 1.5,
+      gust: 5,
+      fogFar: 220,
+      fogDensity: 0,
+      skyScale: 1,
+      visibility: 220,
+      humidity: 0.5,
+      temperatureDeltaC: 0,
+      wetness: 0,
+      hearingScale: 1,
+      footstepScale: 1,
+      dryingScale: 1,
+      debrisPush: 0,
+      haze: 0,
+      mistPerSecond: 0,
+      ashPerSecond: 0
+    },
+    {
+      id: "overcast",
+      sources: ["cena-de-arte:L413 (wind .35, .12)", "cena-de-arte:L36 (FogExp2 .03)", "design:T6 sky x0.9"],
+      rain: 0,
+      drops: 0,
+      sheets: 0,
+      windX: 0.35,
+      windZ: 0.12,
+      gust: 0.6,
+      fogFar: 220,
+      fogDensity: 0.03,
+      skyScale: 0.9,
+      visibility: 200,
+      humidity: 0.65,
+      temperatureDeltaC: -1,
+      wetness: 0,
+      hearingScale: 1,
+      footstepScale: 1,
+      dryingScale: 1,
+      debrisPush: 0,
+      haze: 0,
+      mistPerSecond: 0,
+      ashPerSecond: 0
+    },
+    {
+      id: "light_rain",
+      sources: ["oficina-vfx:W1065 (Garoa: 900 drops, slant .3)", "jogo:L70416-70427 (rain level .035)", "design:T6 2.5 mm/h, wetness .35, visibility 160, hearing x0.8 (Q4)"],
+      rain: 2.5,
+      drops: 900,
+      sheets: 0,
+      windX: 0.3,
+      windZ: 0,
+      gust: 0.6,
+      fogFar: 180,
+      fogDensity: 0,
+      skyScale: 0.9,
+      visibility: 160,
+      humidity: 0.85,
+      temperatureDeltaC: -2,
+      wetness: 0.35,
+      hearingScale: 0.8,
+      footstepScale: 0.85,
+      dryingScale: 1,
+      debrisPush: 0,
+      haze: 0,
+      mistPerSecond: 0,
+      ashPerSecond: 0
+    },
+    {
+      id: "heavy_rain",
+      sources: ["oficina-vfx:W1065 (Chuva: 2200 drops, slant 1.2)", "cena-de-arte:L1314 (rain gain .06)", "jogo:L69141 (fog far 140, sky x0.8)", "galeria-vale-cinzento:L1393 (vision 120 m, quieter steps)", "design:T6 15 mm/h, hearing x0.6 (Q4)"],
+      rain: 15,
+      drops: 2200,
+      sheets: 0,
+      windX: 1.2,
+      windZ: 0,
+      gust: 2,
+      fogFar: 140,
+      fogDensity: 0,
+      skyScale: 0.8,
+      visibility: 120,
+      humidity: 0.9,
+      temperatureDeltaC: -4,
+      wetness: 0.8,
+      hearingScale: 0.6,
+      footstepScale: 0.7,
+      dryingScale: 1,
+      debrisPush: 0,
+      haze: 0,
+      mistPerSecond: 0,
+      ashPerSecond: 0
+    },
+    {
+      id: "storm",
+      sources: ["oficina-vfx:W1065-1069 (Temporal: 4000 drops, slant 4.5, lightning 3.5-6 s, first at 2-4 s, sheets)", "showroom.js (60 mm/h)", "design:T6 hearing x0.5 (Q4)"],
+      rain: 60,
+      drops: 4e3,
+      sheets: 1,
+      windX: 4.5,
+      windZ: 0,
+      gust: 6,
+      fogFar: 110,
+      fogDensity: 0,
+      skyScale: 0.7,
+      visibility: 100,
+      humidity: 0.92,
+      temperatureDeltaC: -5,
+      wetness: 1,
+      hearingScale: 0.5,
+      footstepScale: 0.6,
+      dryingScale: 1,
+      debrisPush: 0,
+      haze: 0,
+      mistPerSecond: 0,
+      ashPerSecond: 0,
+      lightning: { interval: [3.5, 6], first: [2, 4], distance: [200, 4e3], reveal: 0.2 }
+    },
+    {
+      id: "fog",
+      sources: ["oficina-vfx:W1073-1080 (density .075, ground mist 5/s, ash 14/s)", "jogo:L69101 (zone fog far 60)"],
+      rain: 0,
+      drops: 0,
+      sheets: 0,
+      windX: 0.3,
+      windZ: 0.1,
+      gust: 0.5,
+      fogFar: 60,
+      fogDensity: 0.075,
+      skyScale: 0.85,
+      visibility: 40,
+      humidity: 0.95,
+      temperatureDeltaC: -3,
+      wetness: 0.15,
+      hearingScale: 1,
+      footstepScale: 1,
+      dryingScale: 1,
+      debrisPush: 0,
+      haze: 0,
+      mistPerSecond: 5,
+      ashPerSecond: 14
+    },
+    {
+      id: "windy",
+      sources: ["cena-de-arte:L1315 (wind loop)", "design:T6 Q3 8 m/s, gust 12"],
+      rain: 0,
+      drops: 0,
+      sheets: 0,
+      windX: 8,
+      windZ: 0,
+      gust: 12,
+      fogFar: 220,
+      fogDensity: 0,
+      skyScale: 1,
+      visibility: 220,
+      humidity: 0.45,
+      temperatureDeltaC: -1,
+      wetness: 0,
+      hearingScale: 0.85,
+      footstepScale: 0.9,
+      dryingScale: 1,
+      debrisPush: 0,
+      haze: 0,
+      mistPerSecond: 0,
+      ashPerSecond: 0
+    },
+    {
+      id: "cyclone",
+      sources: ["design:T6 Q3 physics preset, no team source: tropical cyclone 33 m/s sustained, gust x1.3, storm rain, debris push"],
+      rain: 60,
+      drops: 4e3,
+      sheets: 1,
+      windX: 33,
+      windZ: 0,
+      gust: 42.9,
+      fogFar: 80,
+      fogDensity: 0,
+      skyScale: 0.6,
+      visibility: 60,
+      humidity: 0.9,
+      temperatureDeltaC: 0,
+      wetness: 1,
+      hearingScale: 0.3,
+      footstepScale: 0.5,
+      dryingScale: 1,
+      debrisPush: 8,
+      haze: 0,
+      mistPerSecond: 0,
+      ashPerSecond: 0,
+      lightning: { interval: [3.5, 6], first: [2, 4], distance: [200, 4e3], reveal: 0.2 }
+    },
+    {
+      id: "typhoon",
+      sources: ["design:T6 Q3 physics preset, no team source: typhoon 50 m/s sustained, gust x1.3, storm rain, debris push"],
+      rain: 60,
+      drops: 4e3,
+      sheets: 1,
+      windX: 50,
+      windZ: 0,
+      gust: 65,
+      fogFar: 60,
+      fogDensity: 0,
+      skyScale: 0.5,
+      visibility: 40,
+      humidity: 0.9,
+      temperatureDeltaC: 0,
+      wetness: 1,
+      hearingScale: 0.25,
+      footstepScale: 0.4,
+      dryingScale: 1,
+      debrisPush: 18,
+      haze: 0,
+      mistPerSecond: 0,
+      ashPerSecond: 0,
+      lightning: { interval: [3.5, 6], first: [2, 4], distance: [200, 4e3], reveal: 0.2 }
+    },
+    {
+      id: "extreme_heat",
+      sources: ["design:T6 Q3 no team source: 38 C at the tropical noon (+6 over the climate), 60 % humidity, haze, drying x2"],
+      rain: 0,
+      drops: 0,
+      sheets: 0,
+      windX: 0.8,
+      windZ: 0.3,
+      gust: 1.5,
+      fogFar: 220,
+      fogDensity: 0,
+      skyScale: 1,
+      visibility: 200,
+      humidity: 0.6,
+      temperatureDeltaC: 6,
+      wetness: 0,
+      hearingScale: 1,
+      footstepScale: 1,
+      dryingScale: 2,
+      debrisPush: 0,
+      haze: 1,
+      mistPerSecond: 0,
+      ashPerSecond: 0
+    }
+  ];
+
+  // src/registry.ts
+  var WEATHER_STATES = states_default;
+  var CLIMATES = climates_default;
+  function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  function mergeRecords(base, patch) {
+    const merged = { ...base };
+    for (const [key, value] of Object.entries(patch)) {
+      if (value === void 0) continue;
+      const current = merged[key];
+      merged[key] = isPlainObject(current) && isPlainObject(value) ? mergeRecords(current, value) : value;
+    }
+    return merged;
+  }
+  function deepMerge(base, patch) {
+    return mergeRecords(base, patch);
+  }
+  function createTable(shipped) {
+    return new Map(shipped.map((entry) => [entry.id, entry]));
+  }
+  function patchEntry(table, id, patch) {
+    const entry = table.get(id);
+    if (entry) table.set(id, deepMerge(entry, patch));
+  }
+  function createWeatherRegistry(options = {}) {
+    const states = createTable(WEATHER_STATES);
+    const climates = createTable(CLIMATES);
+    for (const state of options.states ?? []) states.set(state.id, state);
+    for (const climate of options.climates ?? []) climates.set(climate.id, climate);
+    for (const [id, patch] of Object.entries(options.patch?.states ?? {})) patchEntry(states, id, patch);
+    for (const [id, patch] of Object.entries(options.patch?.climates ?? {})) patchEntry(climates, id, patch);
+    for (const id of options.remove?.states ?? []) states.delete(id);
+    for (const id of options.remove?.climates ?? []) climates.delete(id);
+    return {
+      state: (id) => states.get(id),
+      climate: (id) => climates.get(id),
+      stateIds: () => [...states.keys()],
+      climateIds: () => [...climates.keys()],
+      registerState: (state) => void states.set(state.id, state),
+      registerClimate: (climate) => void climates.set(climate.id, climate),
+      patchState: (id, patch) => patchEntry(states, id, patch),
+      patchClimate: (id, patch) => patchEntry(climates, id, patch),
+      removeState: (id) => void states.delete(id),
+      removeClimate: (id) => void climates.delete(id)
+    };
+  }
+
+  // src/scheduler.ts
+  var SECONDS_PER_HOUR = 3600;
+  var MIN_DWELL_SECONDS = 1;
+  function createScheduler(climate, seed, isKnown) {
+    const rng = createStream(seed, "schedule");
+    let changeAt = 0;
+    const drawDwell = (from) => from + Math.max(MIN_DWELL_SECONDS, drawBetween(rng, climate.dwellHours) * SECONDS_PER_HOUR);
+    changeAt = drawDwell(0);
+    return {
+      nextChangeAt: () => changeAt,
+      next(current, at) {
+        const options = Object.entries(climate.transitions[current] ?? {}).filter(([id, weight]) => weight > 0 && isKnown(id));
+        const total = options.reduce((sum, [, weight]) => sum + weight, 0);
+        let chosen = current;
+        if (total > 0) {
+          let pick = rng() * total;
+          chosen = options[options.length - 1][0];
+          for (const [id, weight] of options) {
+            if (pick < weight) {
+              chosen = id;
+              break;
+            }
+            pick -= weight;
+          }
+        }
+        changeAt = drawDwell(at);
+        return chosen;
+      },
+      restart(at) {
+        changeAt = drawDwell(at);
+      }
+    };
+  }
+
+  // src/wetness.ts
+  var DEFAULT_WET_RISE_SECONDS = 120;
+  var DEFAULT_DRY_OUT_SECONDS = 180;
+  function createWetness(options = {}) {
+    const riseSeconds = options.riseSeconds ?? DEFAULT_WET_RISE_SECONDS;
+    const dryOutSeconds = options.dryOutSeconds ?? DEFAULT_DRY_OUT_SECONDS;
+    let current = 0;
+    let peak = 0;
+    let isDrying = false;
+    return {
+      value: () => current,
+      update(seconds, target, dryingScale = 1) {
+        if (target > current) {
+          isDrying = false;
+          current = Math.min(target, current + seconds / riseSeconds);
+        } else if (target < current) {
+          if (!isDrying) {
+            isDrying = true;
+            peak = current;
+          }
+          current = Math.max(target, current - peak * seconds * dryingScale / dryOutSeconds);
+        } else isDrying = false;
+        return current;
+      },
+      reset(value = 0) {
+        current = value;
+        peak = value;
+        isDrying = false;
+      }
+    };
+  }
+
+  // src/weather.ts
+  var DEFAULT_START_HOUR = 8;
+  var SECONDS_PER_MINUTE = 60;
+  var WETNESS_STEP_SECONDS = 1;
+  var clamp01 = (value) => Math.min(1, Math.max(0, value));
+  function requireClimate(registry, id) {
+    const climate = registry.climate(id);
+    if (!climate) throw new Error(`game-weather: unknown climate "${id}"`);
+    return climate;
+  }
+  function requireState(registry, id) {
+    const state = registry.state(id);
+    if (!state) throw new Error(`game-weather: unknown state "${id}"`);
+    return state;
+  }
+  function createWeather(options = {}) {
+    const registry = options.registry ?? createWeatherRegistry(options);
+    const seed = options.seed ?? 1;
+    const climateId = options.climate ?? "temperate";
+    const startClimate = requireClimate(registry, climateId);
+    const startState = requireState(registry, options.start ?? startClimate.start);
+    const startHour = options.startHour ?? DEFAULT_START_HOUR;
+    const scheduler = createScheduler(startClimate, seed, (id) => registry.state(id) !== void 0);
+    const lightning = createLightningStream(seed);
+    const wetness = createWetness(options.wetness);
+    const listeners = /* @__PURE__ */ new Map();
+    let timeScale = options.timeScale ?? DEFAULT_TIME_SCALE;
+    let isAutoSchedule = options.autoSchedule ?? true;
+    let gameSeconds = 0;
+    let simSeconds = 0;
+    let target = startState;
+    let targetValues = valuesOf(startState);
+    let fromValues = targetValues;
+    let previousId;
+    let blend = { startedAt: 0, duration: 0 };
+    let nextStrikeAt;
+    let strikeCount = 0;
+    let lastStrike;
+    const pendingThunder = [];
+    const climate = () => registry.climate(climateId) ?? startClimate;
+    const emit = (event, payload) => {
+      for (const listener of [...listeners.get(event) ?? []]) listener(payload);
+    };
+    const progressAt = (at) => blend.duration <= 0 ? 1 : clamp01((at - blend.startedAt) / blend.duration);
+    const valuesAt = (at) => blendValues(fromValues, targetValues, progressAt(at));
+    const scheduleFirstStrike = (atSim) => {
+      nextStrikeAt = target.lightning ? atSim + lightning.first(target.lightning) : void 0;
+    };
+    const enter = (id, atGame, atSim, blendGameSeconds) => {
+      const next = requireState(registry, id);
+      fromValues = valuesAt(atGame);
+      previousId = target.id;
+      target = next;
+      targetValues = valuesOf(next);
+      blend = { startedAt: atGame, duration: blendGameSeconds };
+      scheduleFirstStrike(atSim);
+      emit("transition", { from: previousId, to: id, gameSeconds: atGame });
+    };
+    const strikeAt = (atSim, startGame, startSim) => {
+      const config = target.lightning;
+      const place = lightning.place(config);
+      const strike = {
+        id: strikeCount++,
+        time: atSim,
+        gameSeconds: startGame + (atSim - startSim) * timeScale,
+        distance: place.distance,
+        bearing: place.bearing,
+        thunderDelay: thunderDelay(place.distance)
+      };
+      lastStrike = strike;
+      pendingThunder.push(strike);
+      pendingThunder.sort((a, b) => a.time + a.thunderDelay - (b.time + b.thunderDelay));
+      nextStrikeAt = atSim + lightning.interval(config);
+      emit("strike", strike);
+    };
+    scheduleFirstStrike(0);
+    const runEvents = (startGame, startSim, endSim) => {
+      for (; ; ) {
+        const changeSim = isAutoSchedule ? Math.max(startSim, startSim + (scheduler.nextChangeAt() - startGame) / timeScale) : Infinity;
+        const strikeSim = nextStrikeAt ?? Infinity;
+        const thunder = pendingThunder[0];
+        const thunderSim = thunder ? thunder.time + thunder.thunderDelay : Infinity;
+        const earliest = Math.min(changeSim, strikeSim, thunderSim);
+        if (earliest > endSim) return;
+        if (earliest === changeSim) {
+          const atGame = Math.max(startGame, scheduler.nextChangeAt());
+          const next = scheduler.next(target.id, atGame);
+          enter(next, atGame, changeSim, climate().blendMinutes * SECONDS_PER_MINUTE);
+        } else if (earliest === strikeSim) strikeAt(strikeSim, startGame, startSim);
+        else emit("thunder", pendingThunder.shift());
+      }
+    };
+    const wet = (startGame, endGame, seconds) => {
+      const steps = Math.max(1, Math.ceil(seconds / WETNESS_STEP_SECONDS));
+      for (let step = 1; step <= steps; step++) {
+        const values = valuesAt(startGame + (endGame - startGame) * step / steps);
+        wetness.update(seconds / steps, values.wetness, values.dryingScale);
+      }
+    };
+    const api = {
+      registry,
+      advance(dt) {
+        if (!(dt > 0)) return;
+        const startGame = gameSeconds;
+        const startSim = simSeconds;
+        const endGame = startGame + dt * timeScale;
+        runEvents(startGame, startSim, startSim + dt);
+        gameSeconds = endGame;
+        simSeconds = startSim + dt;
+        wet(startGame, endGame, dt);
+      },
+      sample() {
+        const values = valuesAt(gameSeconds);
+        const dayFraction = dayFractionAt(startHour, gameSeconds);
+        const { sun, nightFactor } = daylight(dayFraction);
+        const current = climate();
+        const temperatureC = current.temperatureC.mean + current.temperatureC.swing * (2 * sun - 1) + values.temperatureDeltaC;
+        const humidityPercent = clamp01(values.humidity + current.humidityOffset) * 100;
+        const progress = progressAt(gameSeconds);
+        return {
+          ...values,
+          gameSeconds,
+          dayFraction,
+          hour: dayFraction * 24,
+          nightFactor,
+          sun,
+          state: target.id,
+          previous: progress < 1 ? previousId : void 0,
+          blend: progress,
+          front: { direction: current.frontDirection, progress },
+          windSpeed: Math.sqrt(values.windX * values.windX + values.windZ * values.windZ),
+          temperatureC,
+          humidityPercent,
+          groundWetness: wetness.value(),
+          flash: lastStrike ? flashIntensity(simSeconds - lastStrike.time) : 0,
+          effects: deriveEffects({ values, nightFactor, temperatureC, humidityPercent, lightningReveal: target.lightning?.reveal ?? 0 })
+        };
+      },
+      state: () => target.id,
+      force(id, blendSeconds = 0) {
+        enter(id, gameSeconds, simSeconds, blendSeconds * timeScale);
+        scheduler.restart(gameSeconds);
+      },
+      setTimeScale(next) {
+        if (!(next > 0)) throw new Error("game-weather: timeScale must be above 0");
+        timeScale = next;
+      },
+      setAutoSchedule(isOn) {
+        if (isOn && !isAutoSchedule) scheduler.restart(gameSeconds);
+        isAutoSchedule = isOn;
+      },
+      timeline: (hours, sampleMinutes) => createTimeline({ ...options, registry, hours, ...sampleMinutes === void 0 ? {} : { sampleMinutes } }),
+      on(event, listener) {
+        const set = listeners.get(event) ?? /* @__PURE__ */ new Set();
+        set.add(listener);
+        listeners.set(event, set);
+        return () => void set.delete(listener);
+      }
+    };
+    return api;
+  }
+  var TIMELINE_DECIMALS = 6;
+  var round = (value) => Math.round(value * 10 ** TIMELINE_DECIMALS) / 10 ** TIMELINE_DECIMALS + 0;
+  function createTimeline(options) {
+    const weather = createWeather(options);
+    const timeScale = options.timeScale ?? DEFAULT_TIME_SCALE;
+    const sampleMinutes = options.sampleMinutes ?? 10;
+    const transitions = [];
+    const strikes = [];
+    weather.on("transition", (event) => transitions.push({ gameSeconds: round(event.gameSeconds), from: event.from, to: event.to }));
+    weather.on(
+      "strike",
+      (strike) => strikes.push({ id: strike.id, time: round(strike.time), gameSeconds: round(strike.gameSeconds), distance: round(strike.distance), bearing: round(strike.bearing), thunderDelay: round(strike.thunderDelay) })
+    );
+    const samples = [];
+    const record = (minute) => {
+      const sample = weather.sample();
+      samples.push({
+        at: minute * SECONDS_PER_MINUTE,
+        hour: round(sample.hour),
+        state: sample.state,
+        blend: round(sample.blend),
+        rain: round(sample.rain),
+        windSpeed: round(sample.windSpeed),
+        gust: round(sample.gust),
+        visibility: round(sample.effects.visibility),
+        sightScale: round(sample.effects.sightScale),
+        hearingScale: round(sample.effects.hearingScale),
+        temperatureC: round(sample.temperatureC),
+        heatIndexC: round(sample.effects.heatIndexC),
+        heatStress: round(sample.effects.heatStress),
+        wetness: round(sample.groundWetness),
+        nightFactor: round(sample.nightFactor)
+      });
+    };
+    record(0);
+    const minutes = Math.round(options.hours * 60);
+    for (let minute = 1; minute <= minutes; minute++) {
+      weather.advance(SECONDS_PER_MINUTE / timeScale);
+      if (minute % sampleMinutes === 0) record(minute);
+    }
+    return {
+      seed: options.seed ?? 1,
+      climate: options.climate ?? "temperate",
+      start: options.start ?? weather.registry.climate(options.climate ?? "temperate").start,
+      hours: options.hours,
+      sampleMinutes,
+      transitions,
+      strikes,
+      samples
+    };
+  }
+
+  // src/bench/locale.ts
+  var EN = {
+    group: "Weather",
+    name: "Weather area",
+    controls: { state: "Weather", transition: "Transition", time_of_day: "Time of day", auto_schedule: "Automatic schedule", seed: "Seed" },
+    hints: {
+      transition: "How long the change to the chosen weather takes, in real seconds.",
+      time_of_day: "Hour of the day (the world restarts the clock there and keeps the weather).",
+      auto_schedule: "On: the climate changes the weather by itself and the clock runs 600 times faster than real time. Off: the weather stays until you change it.",
+      seed: "The same seed gives the same schedule and the same lightning."
+    },
+    options: { instant: "At once", ten_seconds: "10 seconds" },
+    layers: { environment: "Write host environment", fog: "Fog in the scene" },
+    metrics: {
+      state: "Weather",
+      hour: "Hour",
+      rain: "Rain",
+      visibility: "Visibility",
+      sight: "Sight scale",
+      hearing: "Hearing scale",
+      wind: "Wind",
+      heat_index: "Heat index",
+      wetness: "Ground wetness",
+      strikes: "Lightning strikes",
+      blend: "Blend",
+      temperature: "Temperature"
+    },
+    scenarios: {
+      storm: "A storm sees less and is heard less than a clear day, and strikes lightning",
+      blend: "A change blends over its time and settles in the new weather",
+      determinism: "The same seed gives the same day, another seed another one",
+      dry_ground: "Rain wets the ground and it dries after the rain stops"
+    },
+    states: {
+      clear: "Clear",
+      overcast: "Overcast",
+      light_rain: "Light rain",
+      heavy_rain: "Heavy rain",
+      storm: "Storm",
+      fog: "Fog",
+      windy: "Windy",
+      cyclone: "Cyclone",
+      typhoon: "Typhoon",
+      extreme_heat: "Extreme heat"
+    }
+  };
+  var PT_BR = {
+    group: "Clima",
+    name: "\xC1rea de clima",
+    controls: { state: "Clima", transition: "Transi\xE7\xE3o", time_of_day: "Hora do dia", auto_schedule: "Sorteio autom\xE1tico", seed: "Semente" },
+    hints: {
+      transition: "Quanto demora a mudan\xE7a para o clima escolhido, em segundos reais.",
+      time_of_day: "Hora do dia (o mundo reinicia o rel\xF3gio nela e mant\xE9m o clima).",
+      auto_schedule: "Ligado: o clima do lugar muda sozinho e o rel\xF3gio corre 600 vezes mais r\xE1pido que o real. Desligado: o clima fica at\xE9 voc\xEA trocar.",
+      seed: "A mesma semente d\xE1 o mesmo sorteio e os mesmos raios."
+    },
+    options: { instant: "De uma vez", ten_seconds: "10 segundos" },
+    layers: { environment: "Escrever no ambiente do host", fog: "N\xE9voa na cena" },
+    metrics: {
+      state: "Clima",
+      hour: "Hora",
+      rain: "Chuva",
+      visibility: "Visibilidade",
+      sight: "Escala de vis\xE3o",
+      hearing: "Escala de audi\xE7\xE3o",
+      wind: "Vento",
+      heat_index: "\xCDndice de calor",
+      wetness: "Ch\xE3o molhado",
+      strikes: "Raios",
+      blend: "Mistura",
+      temperature: "Temperatura"
+    },
+    scenarios: {
+      storm: "Tempestade enxerga e \xE9 ouvida menos que um dia limpo, e solta raios",
+      blend: "Uma mudan\xE7a se mistura no tempo dela e assenta no clima novo",
+      determinism: "A mesma semente d\xE1 o mesmo dia, outra semente d\xE1 outro",
+      dry_ground: "A chuva molha o ch\xE3o e ele seca depois que a chuva para"
+    },
+    states: {
+      clear: "Limpo",
+      overcast: "Nublado",
+      light_rain: "Chuva fraca",
+      heavy_rain: "Chuva forte",
+      storm: "Tempestade",
+      fog: "Neblina",
+      windy: "Ventania",
+      cyclone: "Ciclone",
+      typhoon: "Tuf\xE3o",
+      extreme_heat: "Calor extremo"
+    }
+  };
+  var weatherBenchTextOf = (locale) => locale === "en" ? EN : PT_BR;
+
+  // src/bench/module.ts
+  var FAST_SCALE = 600;
+  var NORMAL_SCALE = 72;
+  var BLEND_SECONDS = 10;
+  var HOURS_PER_DAY = 24;
+  var FOG_NEAR = 1;
+  function createWeatherTestModule(options = {}) {
+    const locale = options.locale ?? "pt-BR";
+    const text = weatherBenchTextOf(locale);
+    const { locale: _locale, translate, weather: given, fog: _fog, ...weatherOptions } = options;
+    void _locale;
+    void _fog;
+    const state = {
+      seed: options.seed ?? 1,
+      hour: options.startHour ?? 8,
+      transition: 0,
+      auto: options.autoSchedule ?? false,
+      environment: true,
+      fog: options.fog ?? true
+    };
+    let host = null;
+    let strikes = 0;
+    let offStrike;
+    let weather = given ?? createWeather({ ...weatherOptions, autoSchedule: state.auto, ...state.auto ? { timeScale: FAST_SCALE } : {} });
+    const watch = () => {
+      offStrike?.();
+      offStrike = weather.on("strike", (_strike) => void (strikes += 1));
+    };
+    watch();
+    const nameOf = (id) => translate?.(`weather.${id}`, locale) ?? text.states[id] ?? id;
+    const rebuild = () => {
+      const current = weather.state();
+      weather = createWeather({ ...weatherOptions, seed: state.seed, start: current, startHour: state.hour, autoSchedule: state.auto, timeScale: state.auto ? FAST_SCALE : NORMAL_SCALE });
+      strikes = 0;
+      watch();
+    };
+    const toEnvironment = (sample) => ({
+      rain: sample.rain,
+      windX: sample.windX,
+      windZ: sample.windZ,
+      windSpeed: sample.windSpeed,
+      gust: sample.gust,
+      fogFar: sample.fogFar,
+      visibility: sample.effects.visibility,
+      nightFactor: sample.nightFactor,
+      temperatureC: sample.temperatureC,
+      wetness: sample.groundWetness
+    });
+    const applyFog = (far) => {
+      const scene = host?.scene;
+      const Fog = host?.THREE?.Fog;
+      if (!scene || typeof Fog !== "function") return;
+      const fog = scene.fog;
+      if (fog && typeof fog.far === "number") fog.far = far;
+      else scene.fog = new Fog(11056320, FOG_NEAR, far);
+    };
+    const publish = () => {
+      const sample = weather.sample();
+      if (state.environment) host?.environment?.set(toEnvironment(sample));
+      if (state.fog) applyFog(sample.fogFar);
+    };
+    const onChange = (change) => {
+      if (change.kind === "layer") {
+        if (change.id === "environment" || change.id === "fog") state[change.id] = change.on;
+        return;
+      }
+      if (change.kind === "action") return;
+      const { id, value } = change;
+      if (id === "state" && typeof value === "string") weather.force(value, state.transition);
+      else if (id === "transition" && typeof value === "string") state.transition = value === "instant" ? 0 : BLEND_SECONDS;
+      else if (id === "time_of_day" && typeof value === "number") {
+        state.hour = value;
+        rebuild();
+      } else if (id === "auto_schedule" && typeof value === "boolean") {
+        state.auto = value;
+        weather.setAutoSchedule(value);
+        weather.setTimeScale(value ? FAST_SCALE : NORMAL_SCALE);
+      } else if (id === "seed" && typeof value === "number") {
+        state.seed = value;
+        rebuild();
+      }
+    };
+    const controls = () => [
+      { kind: "choice", id: "state", name: text.controls.state, options: weather.registry.stateIds().map((id) => ({ id, name: nameOf(id) })), default: weather.state() },
+      {
+        kind: "choice",
+        id: "transition",
+        name: text.controls.transition,
+        hint: text.hints.transition,
+        options: [
+          { id: "instant", name: text.options.instant },
+          { id: "ten_seconds", name: text.options.ten_seconds }
+        ],
+        default: "instant"
+      },
+      { kind: "number", id: "time_of_day", name: text.controls.time_of_day, hint: text.hints.time_of_day, unit: "h", min: 0, max: HOURS_PER_DAY - 1, step: 1, default: state.hour },
+      { kind: "boolean", id: "auto_schedule", name: text.controls.auto_schedule, hint: text.hints.auto_schedule, default: state.auto },
+      { kind: "number", id: "seed", name: text.controls.seed, hint: text.hints.seed, min: 1, max: 9999, step: 1, default: state.seed }
+    ];
+    const layers = () => [
+      { id: "environment", name: text.layers.environment },
+      { id: "fog", name: text.layers.fog, default: state.fog }
+    ];
+    const metrics = () => [
+      { id: "current_state", name: text.metrics.state, read: () => nameOf(weather.state()) },
+      { id: "hour", name: text.metrics.hour, unit: "h", digits: 1, read: () => weather.sample().hour },
+      { id: "blend", name: text.metrics.blend, digits: 2, read: () => weather.sample().blend },
+      { id: "rain", name: text.metrics.rain, unit: "mm/h", digits: 1, read: () => weather.sample().rain },
+      { id: "visibility", name: text.metrics.visibility, unit: "m", digits: 0, read: () => weather.sample().effects.visibility },
+      { id: "sight", name: text.metrics.sight, digits: 2, read: () => weather.sample().effects.sightScale },
+      { id: "hearing", name: text.metrics.hearing, digits: 2, read: () => weather.sample().effects.hearingScale },
+      { id: "wind", name: text.metrics.wind, unit: "m/s", digits: 1, read: () => weather.sample().windSpeed },
+      { id: "temperature", name: text.metrics.temperature, unit: "\xB0C", digits: 1, read: () => weather.sample().temperatureC },
+      { id: "heat_index", name: text.metrics.heat_index, unit: "\xB0C", digits: 1, read: () => weather.sample().effects.heatIndexC },
+      { id: "wetness", name: text.metrics.wetness, digits: 2, read: () => weather.sample().groundWetness },
+      { id: "strikes", name: text.metrics.strikes, digits: 0, read: () => strikes }
+    ];
+    const fresh = (extra = {}) => createWeather({ ...weatherOptions, autoSchedule: false, ...extra });
+    const run = (world, seconds) => {
+      for (let elapsed = 0; elapsed < seconds; elapsed += 0.5) world.advance(0.5);
+    };
+    const scenarios = () => [
+      {
+        id: "storm",
+        name: text.scenarios.storm,
+        run: ({ expect }) => {
+          const clear = fresh({ seed: 3, start: "clear" });
+          const storm = fresh({ seed: 3, start: "storm" });
+          let hits = 0;
+          storm.on("strike", () => void (hits += 1));
+          run(storm, 120);
+          const calm = clear.sample().effects;
+          const rough = storm.sample().effects;
+          expect(rough.visibility < calm.visibility, "a storm sees less far", { storm: rough.visibility, clear: calm.visibility });
+          expect(rough.hearingScale < calm.hearingScale, "rain masks sound", { storm: rough.hearingScale, clear: calm.hearingScale });
+          expect(hits > 0, "a storm strikes lightning", { strikes: hits });
+        }
+      },
+      {
+        id: "blend",
+        name: text.scenarios.blend,
+        run: ({ expect }) => {
+          const world = fresh({ seed: 3, start: "clear" });
+          world.force("heavy_rain", 10);
+          run(world, 5);
+          const middle = world.sample();
+          expect(middle.blend > 0 && middle.blend < 1, "halfway through the change it is still blending", { blend: middle.blend });
+          expect(middle.rain > 0 && middle.rain < 15, "the rain is between the two weathers", { rain: middle.rain });
+          run(world, 6);
+          expect(world.sample().blend === 1 && world.sample().state === "heavy_rain", "after its time it has settled", { blend: world.sample().blend });
+        }
+      },
+      {
+        id: "determinism",
+        name: text.scenarios.determinism,
+        run: ({ expect }) => {
+          const day = (seed) => JSON.stringify(createWeather({ ...weatherOptions, seed }).timeline(48).samples);
+          expect(day(5) === day(5), "the same seed gives the same two days");
+          expect(day(5) !== day(6), "another seed gives another one");
+        }
+      },
+      {
+        id: "dry_ground",
+        name: text.scenarios.dry_ground,
+        run: ({ expect }) => {
+          const world = fresh({ seed: 3, start: "heavy_rain" });
+          run(world, 60);
+          const wet = world.sample().groundWetness;
+          expect(wet > 0.3, "rain wets the ground", { wetness: wet });
+          world.force("clear", 0);
+          run(world, 600);
+          expect(world.sample().groundWetness < wet, "it dries after the rain stops", { wet, after: world.sample().groundWetness });
+        }
+      }
+    ];
+    const module = {
+      id: "weather_area",
+      name: text.name,
+      group: text.group,
+      get weather() {
+        return weather;
+      },
+      items: () => [],
+      controls: () => controls(),
+      layers: () => layers(),
+      metrics: () => metrics(),
+      scenarios: () => scenarios(),
+      attach(lent) {
+        host = lent;
+        const off = lent.bench?.onChange(onChange);
+        publish();
+        const offFrame = lent.onFrame((dt) => {
+          weather.advance(dt);
+          publish();
+        });
+        return () => {
+          off?.();
+          offFrame();
+          host = null;
+        };
+      }
+    };
+    return module;
+  }
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=index.global.js.map