@adatechnology/game-weather 0.1.2 → 0.2.1

package/dist/index.global.js

@@ -23,17 +23,27 @@ var GameWeather = (() => {
   __export(index_exports, {
     CLIMATES: () => CLIMATES,
     DAY_REAL_SECONDS: () => DAY_REAL_SECONDS,
+    DEFAULT_BRIDGE_RULES: () => DEFAULT_BRIDGE_RULES,
     DEFAULT_DRY_OUT_SECONDS: () => DEFAULT_DRY_OUT_SECONDS,
+    DEFAULT_RAIN_SOUND: () => DEFAULT_RAIN_SOUND,
     DEFAULT_START_HOUR: () => DEFAULT_START_HOUR,
     DEFAULT_TIME_SCALE: () => DEFAULT_TIME_SCALE,
     DEFAULT_WET_RISE_SECONDS: () => DEFAULT_WET_RISE_SECONDS,
+    DEFAULT_WIND_SOUND: () => DEFAULT_WIND_SOUND,
     DRY_VISIBILITY_METERS: () => DRY_VISIBILITY_METERS,
     FLASH_END_SECONDS: () => FLASH_END_SECONDS,
     GAME_DAY_SECONDS: () => GAME_DAY_SECONDS,
     NIGHT_SIGHT_LOSS: () => NIGHT_SIGHT_LOSS,
+    RAIN_HISS_GAME: () => RAIN_HISS_GAME,
+    RAIN_LOOP: () => RAIN_LOOP,
     SPEED_OF_SOUND: () => SPEED_OF_SOUND,
     STATE_VALUE_KEYS: () => STATE_VALUE_KEYS,
+    THUNDER: () => THUNDER,
+    WEATHER_BANK: () => WEATHER_BANK,
+    WEATHER_LOOPS: () => WEATHER_LOOPS,
+    WEATHER_SOUNDS: () => WEATHER_SOUNDS,
     WEATHER_STATES: () => WEATHER_STATES,
+    WIND_LOOP: () => WIND_LOOP,
     blendValues: () => blendValues,
     createLightningStream: () => createLightningStream,
     createRng: () => createRng,
@@ -41,19 +51,25 @@ var GameWeather = (() => {
     createStream: () => createStream,
     createTimeline: () => createTimeline,
     createWeather: () => createWeather,
+    createWeatherBridges: () => createWeatherBridges,
     createWeatherRegistry: () => createWeatherRegistry,
+    createWeatherSound: () => createWeatherSound,
     createWeatherTestModule: () => createWeatherTestModule,
     createWetness: () => createWetness,
     dayFractionAt: () => dayFractionAt,
     daylight: () => daylight,
     deriveEffects: () => deriveEffects,
+    environmentOf: () => environmentOf,
     flashIntensity: () => flashIntensity,
     heatIndexC: () => heatIndexC,
     heatStress: () => heatStress,
+    rainVolume: () => rainVolume,
     streamSeed: () => streamSeed,
+    strikePosition: () => strikePosition,
     thunderDelay: () => thunderDelay,
     valuesOf: () => valuesOf,
-    weatherBenchTextOf: () => weatherBenchTextOf
+    weatherBenchTextOf: () => weatherBenchTextOf,
+    windVolume: () => windVolume
   });
 
   // src/blend.ts
@@ -829,6 +845,343 @@ var GameWeather = (() => {
     };
   }
 
+  // ../game-audio/dist/index.js
+  var DISTANCE_CURVES = {
+    /** The game's `sfx`: `vol / (1 + d² × 0.004)`, cutoff `/ (1 + d × 0.01)`, silent below 0.01 (jogo L62091–62092, L62101). */
+    game_sfx: { model: "inverse_square", k: 4e-3, cutoffK: 0.01, minGain: 0.01 },
+    /** The game's `grito`: `1 / (1 + d² × 0.006)`, silent below 0.02 (jogo L62129–62130). */
+    game_scream: { model: "inverse_square", k: 6e-3, minGain: 0.02 },
+    /** The game's `voz`: `1 / (1 + d² × 0.01)`, silent below 0.02 (jogo L62146–62147). */
+    game_voice: { model: "inverse_square", k: 0.01, minGain: 0.02 },
+    /** The game's `boom`: `1.4 / (1 + d² × 0.002)`, never silent (jogo L68280). */
+    game_boom: { model: "inverse_square", k: 2e-3, scale: 1.4 },
+    /** The art scene's `outAt`: `vol / (1 + d² × 0.008)` (cena L1320). */
+    art_scene: { model: "inverse_square", k: 8e-3 },
+    /** The game's animal calls: `max(0, 1 − d / 70) × 0.25`, silent at or below 0.005 (jogo L66627–66628). */
+    animals: { model: "linear", range: 70, scale: 0.25, minGain: 5e-3 }
+  };
+  var mix_profiles_default = [
+    {
+      id: "game",
+      master: 0.5,
+      noise: { seconds: 1.5, create: "lazy" },
+      sources: ["jogo:L62077-62081 master 0.5 to the output", "jogo:L62082-62088 noise 1.5 s made by the first sound that needs it"]
+    },
+    {
+      id: "art_scene",
+      master: 0.85,
+      compressor: { threshold: -12, ratio: 5 },
+      reverb: { seconds: 2.2, decay: 3.4, wet: 0.4 },
+      noise: { seconds: 2, create: "eager" },
+      sources: [
+        "cena:L1308 compressor -12 dB, ratio 5",
+        "cena:L1309 master 0.85",
+        "cena:L1310 convolver, impulse 2.2 s of (1 - i/len)^3.4",
+        "cena:L1311 wet 0.4",
+        "cena:L1312 noise 2 s made with the chain"
+      ]
+    }
+  ];
+  var MIX_PROFILES = Object.fromEntries(
+    mix_profiles_default.map((profile) => [profile.id, profile])
+  );
+  var game_sfx_default = {
+    sources: ["jogo:L62089-62107"],
+    note: "The game's sfx table P: [lowpass cutoff Hz, peak gain, seconds]. Played as a noise burst with the game's distance curve (falloff game_sfx) and a 0.05 s tail. Team names in `team`.",
+    classes: [
+      { id: "pistol", team: "pistola", bus: "weapons", cutoff: 1800, gain: 0.9, seconds: 0.18 },
+      { id: "shotgun", team: "escopeta", bus: "weapons", cutoff: 900, gain: 1.2, seconds: 0.35 },
+      { id: "rifle", team: "fuzil", bus: "weapons", cutoff: 1400, gain: 1.1, seconds: 0.28 },
+      { id: "long_rifle", team: "rifle", bus: "weapons", cutoff: 1100, gain: 1.3, seconds: 0.45 },
+      { id: "impact", team: "impacto", bus: "world", cutoff: 2500, gain: 0.25, seconds: 0.05 },
+      { id: "flesh", team: "carne", bus: "world", cutoff: 600, gain: 0.35, seconds: 0.08 },
+      { id: "step", team: "passo", bus: "world", cutoff: 400, gain: 0.08, seconds: 0.05 },
+      { id: "glass", team: "vidro", bus: "world", cutoff: 5e3, gain: 0.5, seconds: 0.3 },
+      { id: "wood", team: "madeira", bus: "world", cutoff: 700, gain: 0.5, seconds: 0.2 },
+      { id: "reload", team: "recarga", bus: "weapons", cutoff: 3e3, gain: 0.15, seconds: 0.06 },
+      { id: "empty", team: "vazio", bus: "weapons", cutoff: 4e3, gain: 0.12, seconds: 0.03 },
+      { id: "explosion", team: "explosao", bus: "world", cutoff: 200, gain: 1.6, seconds: 1.4 }
+    ],
+    fallback: { id: "unknown", team: "(any other name)", bus: "world", cutoff: 1e3, gain: 0.5, seconds: 0.1 }
+  };
+  var GAME_SFX = game_sfx_default;
+  var GAME_SFX_CLASSES = GAME_SFX.classes;
+  var GAME_SFX_FALLBACK = GAME_SFX.fallback;
+  function noiseClassRecipe(row, id = `sfx_${row.id}`) {
+    return {
+      id,
+      bus: row.bus,
+      order: "burst",
+      duration: row.seconds,
+      tail: 0.05,
+      layers: [
+        {
+          source: { kind: "noise", offset: "random" },
+          filters: { mode: "serial", bank: [{ type: "lowpass", frequency: { set: row.cutoff } }] },
+          envelope: [
+            [0, row.gain, "set"],
+            ["1d", 1e-3, "exp", "fixed"]
+          ]
+        }
+      ],
+      falloff: DISTANCE_CURVES.game_sfx,
+      sources: [...GAME_SFX.sources.map((source) => `${source} ${row.team}`)]
+    };
+  }
+  var GAME_SFX_BANK = { id: "game_sfx", sounds: [...GAME_SFX_CLASSES, GAME_SFX_FALLBACK].map((row) => noiseClassRecipe(row)) };
+  var ATTACK = 2e-3;
+  function lengthOf(d, attack) {
+    if (typeof d === "number") return attack + d;
+    if (Array.isArray(d)) return [attack + d[0], attack + d[1]];
+    return { ...d, add: (d.add ?? 0) + attack };
+  }
+  var envelope = (attack) => [
+    [0, 1e-4, "set", "fixed"],
+    [attack, 1, "exp"],
+    ["1d", 1e-4, "exp", "fixed"]
+  ];
+  function sceneNoise(o) {
+    const a = o.a ?? ATTACK;
+    const over = typeof o.d === "number" ? o.d : 0;
+    return {
+      filters: {
+        mode: "serial",
+        bank: [{ type: o.type ?? "lowpass", frequency: o.f2 === void 0 ? { set: o.f } : { set: o.f, to: o.f2, curve: "exp", over }, q: o.q ?? 0.7 }]
+      },
+      duration: lengthOf(o.d, a),
+      gain: o.vol,
+      ...o.delay === void 0 ? {} : { at: o.delay },
+      ...o.wet === void 0 ? {} : { wet: o.wet },
+      source: { kind: "noise", offset: "random", offsetScale: 1.5, loop: true },
+      envelope: envelope(a)
+    };
+  }
+  function sceneTone(o) {
+    return {
+      source: { kind: "osc", wave: o.wave ?? "sine", frequency: { from: o.f, to: o.f2 ?? "from", curve: "exp", over: "duration" } },
+      duration: lengthOf(o.d, ATTACK),
+      gain: o.vol,
+      ...o.delay === void 0 ? {} : { at: o.delay },
+      ...o.wet === void 0 ? {} : { wet: o.wet },
+      envelope: envelope(ATTACK)
+    };
+  }
+  var BENCH_BANK = {
+    id: "audio_bench",
+    sounds: [
+      {
+        id: "bench_ping",
+        bus: "ui",
+        pan: true,
+        duration: 0.25,
+        layers: [
+          {
+            gain: 0.5,
+            wet: 0.3,
+            source: { kind: "osc", wave: "sine", frequency: { from: 880 } },
+            envelope: [
+              [0, 1e-4, "set", "fixed"],
+              [2e-3, 1, "exp"],
+              ["1d", 1e-4, "exp", "fixed"]
+            ]
+          }
+        ],
+        falloff: DISTANCE_CURVES.art_scene,
+        sources: ["sdk: bench probe, a 880 Hz ping through the art scene output stage"]
+      },
+      {
+        id: "bench_hiss",
+        bus: "ui",
+        pan: true,
+        duration: [0.3, 0.9],
+        layers: [
+          {
+            gain: 0.4,
+            source: { kind: "noise", offset: "random", offsetScale: 1.5, loop: true },
+            filters: { mode: "serial", bank: [{ type: "highpass", frequency: { set: 3e3 }, q: 0.7 }] },
+            envelope: [
+              [0, 1e-4, "set", "fixed"],
+              [2e-3, 1, "exp"],
+              ["1d", 1e-4, "exp", "fixed"]
+            ]
+          }
+        ],
+        falloff: DISTANCE_CURVES.art_scene,
+        sources: ["sdk: bench probe, a highpass hiss of random length"]
+      }
+    ]
+  };
+
+  // src/audio/recipes.ts
+  var RAIN_LOOP = {
+    id: "rain_loop",
+    bus: "weather",
+    order: "chain_loop",
+    source: { kind: "noise", loop: true },
+    filters: {
+      mode: "serial",
+      bank: [
+        { type: "highpass", frequency: { set: 600 } },
+        { type: "lowpass", frequency: { set: 6e3 } }
+      ]
+    },
+    sources: ["cena:L1314"]
+  };
+  var WIND_LOOP = {
+    id: "wind_loop",
+    bus: "weather",
+    order: "chain_loop",
+    source: { kind: "noise", loop: true },
+    filters: { mode: "serial", bank: [{ type: "lowpass", frequency: { set: 320 } }] },
+    modulators: [{ target: "gain", rate: 0.07, depth: 0.035 }],
+    sources: ["cena:L1315"]
+  };
+  var RAIN_HISS_GAME = {
+    id: "rain_hiss_game",
+    bus: "weather",
+    order: "game_loop",
+    source: { kind: "noise", loop: true },
+    filters: { mode: "serial", bank: [{ type: "highpass", frequency: { set: 2500 } }] },
+    sources: ["jogo:L62116 chuva"]
+  };
+  var THUNDER = {
+    id: "thunder",
+    bus: "weather",
+    pan: true,
+    layers: [sceneTone({ f: 70, f2: 28, d: 1.2, vol: 1 }), sceneNoise({ f: 260, f2: 50, d: 3.2, vol: 0.9, wet: 0.8 })],
+    falloff: { model: "inverse_square", k: 1e-5, scale: 1.4 },
+    sources: ["jogo:L68278-68285 boom", "sdk: rumble and falloff"]
+  };
+  var WEATHER_BANK = { id: "weather", sounds: [THUNDER], loops: [RAIN_LOOP, WIND_LOOP, RAIN_HISS_GAME] };
+  var WEATHER_SOUNDS = WEATHER_BANK.sounds ?? [];
+  var WEATHER_LOOPS = WEATHER_BANK.loops ?? [];
+
+  // src/audio/sound.ts
+  var DEFAULT_RAIN_SOUND = { light: 0.035, heavy: 0.06, lightAt: 2.5, heavyAt: 15 };
+  var DEFAULT_WIND_SOUND = { base: 0.05, referenceSpeed: 3.8, max: 0.12 };
+  function rainVolume(rain, options = {}) {
+    if (!(rain > 0)) return 0;
+    const { light, heavy, lightAt, heavyAt } = { ...DEFAULT_RAIN_SOUND, ...options };
+    if (heavyAt <= lightAt) return rain >= heavyAt ? heavy : light;
+    const t = Math.min(1, Math.max(0, (rain - lightAt) / (heavyAt - lightAt)));
+    return light + (heavy - light) * t;
+  }
+  function windVolume(speed, options = {}) {
+    const { base, referenceSpeed, max } = { ...DEFAULT_WIND_SOUND, ...options };
+    return Math.min(max, base * Math.max(0, speed) / referenceSpeed);
+  }
+  function strikePosition(strike, origin = [0, 0, 0]) {
+    const angle = strike.bearing * Math.PI / 180;
+    return [origin[0] + Math.sin(angle) * strike.distance, origin[1], origin[2] - Math.cos(angle) * strike.distance];
+  }
+  function createWeatherSound(sink, options = {}) {
+    if (sink && options.register !== false) sink.register?.(WEATHER_BANK);
+    const rainSound = options.style === "game" ? "rain_hiss_game" : "rain_loop";
+    const loops = /* @__PURE__ */ new Map();
+    const set = (id, volume) => {
+      let loop = loops.get(id);
+      if (!loop) {
+        if (!(volume > 0) || !sink?.loop) return;
+        loop = sink.loop(id);
+        loops.set(id, loop);
+      }
+      loop.set({ volume });
+    };
+    return {
+      update(sample) {
+        set(rainSound, rainVolume(sample.rain, options.rain));
+        set("wind_loop", windVolume(sample.windSpeed, options.wind));
+      },
+      thunder(strike) {
+        sink?.play({ sound: "thunder", position: strikePosition(strike, options.listener?.()), ...options.thunderVolume === void 0 ? {} : { volume: options.thunderVolume } });
+      },
+      dispose() {
+        for (const loop of loops.values()) loop.stop();
+        loops.clear();
+      }
+    };
+  }
+
+  // src/bridges.ts
+  var DEFAULT_BRIDGE_RULES = { filmRainFullAt: 2.5, washFrom: 15, washBelow: 0.5, washEvery: 1, windFull: 20 };
+  function environmentOf(sample) {
+    return {
+      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
+    };
+  }
+  function createWeatherBridges(targets, options = {}) {
+    const rules = { ...DEFAULT_BRIDGE_RULES, ...options };
+    const sound = options.sound === false || !targets.audio ? void 0 : createWeatherSound(targets.audio, options.sound ?? {});
+    let weather;
+    let offThunder;
+    let sinceWash = 0;
+    let last = {};
+    const push = () => {
+      if (!weather) return;
+      const sample = weather.sample();
+      const { film, interactables, vegetation, vfx, environment } = targets;
+      environment?.set(environmentOf(sample));
+      if (film) {
+        const rain = Math.min(1, Math.max(0, sample.rain / rules.filmRainFullAt));
+        const drying = sample.effects.dryingScale;
+        if (rain !== last.filmRain || drying !== last.drying) film.setWeather({ rain, drying });
+        last.filmRain = rain;
+        last.drying = drying;
+      }
+      if (interactables && sample.rain !== last.rain) interactables.water.setRain(sample.rain);
+      const windChanged = sample.windX !== last.windX || sample.windZ !== last.windZ;
+      if (windChanged) {
+        interactables?.setWind(sample.windX, sample.windZ);
+        vfx?.setWind([sample.windX, 0, sample.windZ]);
+        if (vegetation) {
+          const wind = { strength: Math.min(1, sample.windSpeed / rules.windFull), gust: Math.min(1, sample.gust / rules.windFull) };
+          vegetation.setWind(sample.windSpeed > 1e-6 ? { direction: [sample.windX, sample.windZ], ...wind } : wind);
+        }
+      }
+      last = { ...last, rain: sample.rain, windX: sample.windX, windZ: sample.windZ };
+      sound?.update(sample);
+    };
+    const onThunder = (strike) => sound?.thunder(strike);
+    return {
+      bind(next) {
+        offThunder?.();
+        weather = next;
+        offThunder = next.on("thunder", onThunder);
+        last = {};
+        sinceWash = 0;
+        push();
+      },
+      update(dt) {
+        push();
+        if (!weather || !targets.film?.wash) return;
+        if (weather.sample().rain < rules.washFrom) {
+          sinceWash = 0;
+          return;
+        }
+        sinceWash += dt;
+        if (sinceWash >= rules.washEvery) {
+          sinceWash = 0;
+          targets.film.wash(rules.washBelow);
+        }
+      },
+      dispose() {
+        offThunder?.();
+        offThunder = void 0;
+        weather = void 0;
+        sound?.dispose();
+      }
+    };
+  }
+
   // src/bench/locale.ts
   var EN = {
     group: "Weather",
@@ -931,9 +1284,12 @@ var GameWeather = (() => {
   function createWeatherTestModule(options = {}) {
     const locale = options.locale ?? "pt-BR";
     const text = weatherBenchTextOf(locale);
-    const { locale: _locale, translate, weather: given, fog: _fog, ...weatherOptions } = options;
+    const { locale: _locale, translate, weather: given, fog: _fog, targets: _targets, sound: _sound, visual: _visual, ...weatherOptions } = options;
     void _locale;
     void _fog;
+    void _targets;
+    void _sound;
+    void _visual;
     const state = {
       seed: options.seed ?? 1,
       hour: options.startHour ?? 8,
@@ -945,6 +1301,8 @@ var GameWeather = (() => {
     let host = null;
     let strikes = 0;
     let offStrike;
+    let bridges;
+    let visual;
     let weather = given ?? createWeather({ ...weatherOptions, autoSchedule: state.auto, ...state.auto ? { timeScale: FAST_SCALE } : {} });
     const watch = () => {
       offStrike?.();
@@ -957,19 +1315,8 @@ var GameWeather = (() => {
       weather = createWeather({ ...weatherOptions, seed: state.seed, start: current, startHour: state.hour, autoSchedule: state.auto, timeScale: state.auto ? FAST_SCALE : NORMAL_SCALE });
       strikes = 0;
       watch();
+      bridges?.bind(weather);
     };
-    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;
@@ -980,12 +1327,13 @@ var GameWeather = (() => {
     };
     const publish = () => {
       const sample = weather.sample();
-      if (state.environment) host?.environment?.set(toEnvironment(sample));
-      if (state.fog) applyFog(sample.fogFar);
+      if (state.environment) host?.environment?.set(environmentOf(sample));
+      if (state.fog && !visual) applyFog(sample.fogFar);
     };
     const onChange = (change) => {
       if (change.kind === "layer") {
         if (change.id === "environment" || change.id === "fog") state[change.id] = change.on;
+        visual?.setLayer(change.id, change.on);
         return;
       }
       if (change.kind === "action") return;
@@ -1023,7 +1371,8 @@ var GameWeather = (() => {
     ];
     const layers = () => [
       { id: "environment", name: text.layers.environment },
-      { id: "fog", name: text.layers.fog, default: state.fog }
+      { id: "fog", name: text.layers.fog, default: state.fog },
+      ...options.visual?.layers(locale) ?? []
     ];
     const metrics = () => [
       { id: "current_state", name: text.metrics.state, read: () => nameOf(weather.state()) },
@@ -1112,14 +1461,24 @@ var GameWeather = (() => {
       attach(lent) {
         host = lent;
         const off = lent.bench?.onChange(onChange);
+        bridges = createWeatherBridges({ ...options.targets, ...lent.audio ? { audio: lent.audio } : {} }, { sound: options.sound ?? {} });
+        bridges.bind(weather);
+        visual = options.visual?.create({ host: lent, locale, weather: { sample: () => weather.sample() } });
+        if (visual && !state.fog) visual.setLayer("fog", false);
         publish();
         const offFrame = lent.onFrame((dt) => {
           weather.advance(dt);
           publish();
+          bridges?.update(dt);
+          visual?.update(dt);
         });
         return () => {
+          visual?.dispose();
+          visual = void 0;
           off?.();
           offFrame();
+          bridges?.dispose();
+          bridges = void 0;
           host = null;
         };
       }