1681-engine 0.0.0-stage → 0.5.8

package/dist/1681-engine.js

@@ -0,0 +1,417 @@
+import { Engine as o } from "./engine/Engine.js";
+import { Scene as m } from "./engine/Scene.js";
+import { SceneManager as a } from "./engine/SceneManager.js";
+import { FixedLoop as i } from "./engine/FixedLoop.js";
+import { World as s, defineComponent as n, defineFields as l, entityIndex as c, system as d } from "./ecs/World.js";
+import { EventBus as S } from "./events/EventBus.js";
+import { engineSettings as C } from "./settings.js";
+import { Stage as g } from "./core/Stage.js";
+import { Camera as L } from "./core/Camera.js";
+import { Clock as h } from "./core/Clock.js";
+import { Tween as y, Tweener as O } from "./core/Tweener.js";
+import { Timeline as F } from "./core/Timeline.js";
+import { TimelineBuilder as M } from "./core/TimelineBuilder.js";
+import { easeByName as N } from "./core/eases.js";
+import { ObjectFactory as b } from "./core/ObjectFactory.js";
+import { Graphics as B } from "./core/Graphics.js";
+import { Image as H } from "./core/Image.js";
+import { Group as U } from "./core/Group.js";
+import { Rectangle as W } from "./core/Rectangle.js";
+import { Text as Y } from "./core/Text.js";
+import { BitmapLabel as X, addLabelGlyphs as j, installLabelFont as Z } from "./core/BitmapLabel.js";
+import { Pointer as J } from "./core/Pointer.js";
+import { CanvasTexture as $, TextureRegistry as ee } from "./core/TextureRegistry.js";
+import { AtlasBuilder as oe } from "./core/atlas.js";
+import { atlasPageLimit as me, planAtlas as pe } from "./core/atlasPlan.js";
+import { AssetLoader as xe, resolveUrl as ie } from "./assets/AssetLoader.js";
+import { Animator as se } from "./anim/Animator.js";
+import { clipMarkers as le, frameNamed as ce, parseAseprite as de } from "./anim/parseAseprite.js";
+import { tagDirection as Se, tagFrames as Ae, tagRepeat as Ce } from "./anim/asepriteTags.js";
+import { sliceAt as ge, sliceBorders as Ee, sliceNamed as Le } from "./anim/asepriteSlices.js";
+import { addAsepriteTextures as he, loadAseprite as ue } from "./assets/loadAseprite.js";
+import { AnimStateMachine as Oe } from "./anim/AnimStateMachine.js";
+import { AnimStateComponent as Fe, animStateSystem as Ie } from "./anim/animStateSystem.js";
+import { AnimationComponent as ve, SpriteComponent as Ne, animationSystem as De } from "./anim/animationSystem.js";
+import { FLIP_D as ke, FLIP_H as Be, FLIP_V as Ge, gidOf as He, layerByName as we, objectsOf as Ue, parseTiled as Ke, tileAt as We, tileRect as Ve } from "./tilemap/tiled.js";
+import { collisionFromTiled as ze } from "./tilemap/collision.js";
+import { TilemapView as je } from "./tilemap/TilemapView.js";
+import { Skeleton as qe } from "./rig/Skeleton.js";
+import { HUMANOID_RIG as Qe } from "./rig/humanoid.js";
+import { blendPose as er, overlay as rr, upperOver as or } from "./rig/poseMath.js";
+import { HUMANOID_CLIPS as mr, HUMANOID_POSES as pr } from "./rig/humanoidPoses.js";
+import { PosePlayer as xr } from "./rig/PosePlayer.js";
+import { RIG_PARTS as fr, RigView as sr } from "./rig/RigView.js";
+import { LightLayer as lr } from "./light/LightLayer.js";
+import { HEAVY_FLASH_GAP_MS as dr, RECOIL_MS as Tr, hitStopMs as Sr, hurtFlashGapMs as Ar, hurtFlashMs as Cr, recoilAt as _r, recoilPx as gr } from "./fx/hitStop.js";
+import { FloatingText as Lr } from "./fx/FloatingText.js";
+import { inView as hr } from "./fx/viewCull.js";
+import { SoundEngine as yr, sound as Or } from "./audio/SoundEngine.js";
+import { MusicPlayer as Fr, music as Ir } from "./audio/MusicPlayer.js";
+import { MusicChannel as vr } from "./audio/music/MusicChannel.js";
+import { elementVolumeLocked as Dr } from "./audio/music/musicVoice.js";
+import { registerSounds as kr } from "./audio/soundTable.js";
+import { hasTakes as Gr, registerTakes as Hr } from "./audio/sampleBank.js";
+import { Footsteps as Ur } from "./audio/Footsteps.js";
+import { SYNTH_RATE as Wr, renderRecipe as Vr } from "./audio/synth.js";
+import { Keyboard as zr } from "./input/Keyboard.js";
+import { Actions as jr, PAD_BUTTONS as Zr } from "./input/Actions.js";
+import { chordHeld as Jr, parseChord as Qr } from "./input/keyChord.js";
+import { aimAxis as eo } from "./input/aimAxis.js";
+import { STICK_DEAD_ZONE as oo, stickActive as to, stickToAxis as mo, stickVector as po } from "./input/stickAxis.js";
+import { LongPress as xo } from "./input/longPress.js";
+import { AIM_CENTRE as fo, AIM_EARLY_SLOP as so, AIM_PRESS_MS as no, AIM_TAP_SLOP as lo, AimGesture as co, aimPoint as To, dragSlop as So, spotReach as Ao, spotShare as Co } from "./input/AimGesture.js";
+import { LOCK_KEEP_RANGE as go, LOCK_PICK_CONE as Eo, LOCK_PICK_RANGE as Lo, TargetLock as Po, keptTarget as ho, nearestTarget as uo, pickTarget as yo } from "./input/TargetLock.js";
+import { Keymap as Ro, keyLabel as Fo, keymapStorage as Io, mergeKeymap as Mo } from "./input/Keymap.js";
+import { isTouchUi as No, setNativeShell as Do, setTouchOverrideKey as bo } from "./platform/touch.js";
+import { detectTouch as Bo } from "./input/touchDetect.js";
+import { DayClock as Ho, clockText as wo, mixRgb as Uo, tintNight as Ko } from "./ambient/DayClock.js";
+import { hash01 as Vo, weatherAt as Yo } from "./ambient/weather.js";
+import { WeatherLayer as Xo } from "./ambient/WeatherLayer.js";
+import { gradeAt as Zo, mixToWhite as qo } from "./ambient/grade.js";
+import { ColorGrade as Qo } from "./ambient/ColorGrade.js";
+import { Parallax as et } from "./parallax/Parallax.js";
+import { ParallaxLayer as ot } from "./parallax/ParallaxLayer.js";
+import { parallaxOrigin as mt, placeAxis as pt, spanVisible as at, wrap as xt } from "./parallax/parallaxMath.js";
+import { Emitter as ft } from "./particles/Emitter.js";
+import { ParticleSim as nt } from "./particles/ParticleSim.js";
+import { ParticleBudget as ct, particleBudget as dt } from "./particles/ParticleBudget.js";
+import { lerpColor as St, sampleColor as At, sampleCurve as Ct } from "./particles/particleCurves.js";
+import { dueParticles as gt, sampleRange as Et, scaleCount as Lt, seededRandom as Pt, spreadAngle as ht } from "./particles/particleSampling.js";
+import { PhysicsWorld as yt } from "./physics/PhysicsWorld.js";
+import { Body as Rt } from "./physics/Body.js";
+import { Contact as It, ContactPoint as Mt } from "./physics/Contact.js";
+import { MAX_POLYGON_VERTICES as Nt, polygonCentroid as Dt, polygonShape as bt, regularPolygon as kt } from "./physics/polygon.js";
+import { mergeTileRects as Gt, tileBodies as Ht, tileBodiesFromGrid as wt } from "./physics/tileBodies.js";
+import { physicsSystem as Kt } from "./physics/physicsSystem.js";
+import { syncToBody as Vt } from "./physics/syncToBody.js";
+import { COLLIDER_COLORS as zt, colliderColor as Xt, drawColliders as jt } from "./physics/drawColliders.js";
+import { FACE_BOTTOM as qt, FACE_LEFT as Jt, FACE_RIGHT as Qt, FACE_TOP as $t } from "./physics/types.js";
+import { MinHeap as rm } from "./nav/MinHeap.js";
+import { NAV_STEPS as tm, canStep as mm, isOpen as pm, navGrid as am, navGridFromCollision as xm, nearWallCost as im } from "./nav/navGrid.js";
+import { nearestOpen as sm } from "./nav/nearestOpen.js";
+import { findPath as lm, floodFill as cm, octile as dm, reachedCount as Tm } from "./nav/findPath.js";
+import { simplifyPath as Am, straightenPath as Cm } from "./nav/straightenPath.js";
+import { SaveStore as gm } from "./save/SaveStore.js";
+import { MemoryBackend as Lm } from "./save/MemoryBackend.js";
+import { WebStorageBackend as hm } from "./save/WebStorageBackend.js";
+import { MigrationError as ym, migrateSave as Om } from "./save/migrateSave.js";
+import { checksum as Fm } from "./save/checksum.js";
+import { Autosaver as Mm } from "./save/Autosaver.js";
+import { transitionTo as Nm } from "./transitions/transitionTo.js";
+import { tweenDone as bm } from "./transitions/tweenDone.js";
+import { FadeTransition as Bm } from "./transitions/FadeTransition.js";
+import { CrossfadeTransition as Hm } from "./transitions/CrossfadeTransition.js";
+import { DitherWipeTransition as Um } from "./transitions/DitherWipeTransition.js";
+import { BAYER4 as Wm, DITHER_LEVELS as Vm, ditherCovered as Ym, wipeLevel as zm } from "./transitions/ditherMask.js";
+import { Letterbox as jm } from "./transitions/Letterbox.js";
+import { Translator as qm } from "./i18n/Translator.js";
+import { CONTEXT_MARK as Qm, formatMessage as $m, sourceText as ep } from "./i18n/formatMessage.js";
+import { extractStrings as op } from "./i18n/extractStrings.js";
+import { noteContextLoss as mp, rebuildDelayMs as pp, watchContextLoss as ap } from "./diagnostics/contextLoss.js";
+import { bootWatch as ip } from "./diagnostics/bootWatch.js";
+import { describeError as sp, guardRender as np } from "./diagnostics/renderGuard.js";
+import { gpuName as cp, maxTextureSize as dp } from "./diagnostics/gpuInfo.js";
+import { countHitches as Sp, looksThrottled as Ap, percentile as Cp, summarizeFrames as _p } from "./diagnostics/frameStats.js";
+import { FrameSampler as Ep } from "./diagnostics/FrameSampler.js";
+import { ErrorDeduper as Pp, trimStack as hp } from "./diagnostics/ErrorDeduper.js";
+import { captureErrors as yp } from "./diagnostics/captureErrors.js";
+import { DebugOverlay as Rp } from "./debug/DebugOverlay.js";
+import { FrameStats as Ip } from "./debug/FrameStats.js";
+import { ErrorLog as vp } from "./debug/ErrorLog.js";
+import { inspectWorld as Dp } from "./debug/inspectWorld.js";
+import { DrawCallCounter as kp } from "./debug/DrawCallCounter.js";
+import { BODY_HALF_HEIGHT as Gp, BODY_HALF_WIDTH as Hp, INPUT_FLAG_DASH as wp, INPUT_STEP_DT as Up, INPUT_STEP_RATE as Kp, TILE_SIZE as Wp } from "./net/constants.js";
+import { DIAGONAL as Yp, blocksShot as zp, bodyCollides as Xp, createCollisionGrid as jp, createMover as Zp, isSolidTile as qp, moveX as Jp, moveY as Qp, stepMover as $p } from "./net/movement.js";
+import { UPDATE_RECORD_BYTES as ra, decodeSnapshotFrame as oa, decodeUpdates as ta, encodeSnapshotFrame as ma, encodeUpdates as pa, quantizeUpdates as aa } from "./net/snapshotCodec.js";
+import { CADENCE as ia, cadenceEarly as fa, cadenceNext as sa } from "./net/cadence.js";
+import { noteServerTime as la, resetServerClock as ca, serverNow as da, serverOffset as Ta } from "./net/serverClock.js";
+import { PredictedMover as Aa } from "./net/PredictedMover.js";
+import { InterpolationBuffer as _a } from "./net/InterpolationBuffer.js";
+import { Room as Ea } from "./net/Room.js";
+import { RoomHost as Pa } from "./net/RoomHost.js";
+import { Connection as ua } from "./net/Connection.js";
+import { moverFromWire as Oa, moverToWire as Ra } from "./net/protocol.js";
+import { LobbyClient as Ia } from "./net/lobby/LobbyClient.js";
+import { LobbyHost as va } from "./net/lobby/LobbyHost.js";
+import { LobbyRooms as Da } from "./net/lobby/LobbyRooms.js";
+import { Matchmaker as ka, balanceTeams as Ba } from "./net/lobby/Matchmaker.js";
+export {
+  fo as AIM_CENTRE,
+  so as AIM_EARLY_SLOP,
+  no as AIM_PRESS_MS,
+  lo as AIM_TAP_SLOP,
+  jr as Actions,
+  co as AimGesture,
+  Fe as AnimStateComponent,
+  Oe as AnimStateMachine,
+  ve as AnimationComponent,
+  se as Animator,
+  xe as AssetLoader,
+  oe as AtlasBuilder,
+  Mm as Autosaver,
+  Wm as BAYER4,
+  Gp as BODY_HALF_HEIGHT,
+  Hp as BODY_HALF_WIDTH,
+  X as BitmapLabel,
+  Rt as Body,
+  ia as CADENCE,
+  zt as COLLIDER_COLORS,
+  Qm as CONTEXT_MARK,
+  L as Camera,
+  $ as CanvasTexture,
+  h as Clock,
+  Qo as ColorGrade,
+  ua as Connection,
+  It as Contact,
+  Mt as ContactPoint,
+  Hm as CrossfadeTransition,
+  Yp as DIAGONAL,
+  Vm as DITHER_LEVELS,
+  Ho as DayClock,
+  Rp as DebugOverlay,
+  Um as DitherWipeTransition,
+  kp as DrawCallCounter,
+  ft as Emitter,
+  o as Engine,
+  Pp as ErrorDeduper,
+  vp as ErrorLog,
+  S as EventBus,
+  qt as FACE_BOTTOM,
+  Jt as FACE_LEFT,
+  Qt as FACE_RIGHT,
+  $t as FACE_TOP,
+  ke as FLIP_D,
+  Be as FLIP_H,
+  Ge as FLIP_V,
+  Bm as FadeTransition,
+  i as FixedLoop,
+  Lr as FloatingText,
+  Ur as Footsteps,
+  Ep as FrameSampler,
+  Ip as FrameStats,
+  B as Graphics,
+  U as Group,
+  dr as HEAVY_FLASH_GAP_MS,
+  mr as HUMANOID_CLIPS,
+  pr as HUMANOID_POSES,
+  Qe as HUMANOID_RIG,
+  wp as INPUT_FLAG_DASH,
+  Up as INPUT_STEP_DT,
+  Kp as INPUT_STEP_RATE,
+  H as Image,
+  _a as InterpolationBuffer,
+  zr as Keyboard,
+  Ro as Keymap,
+  go as LOCK_KEEP_RANGE,
+  Eo as LOCK_PICK_CONE,
+  Lo as LOCK_PICK_RANGE,
+  jm as Letterbox,
+  lr as LightLayer,
+  Ia as LobbyClient,
+  va as LobbyHost,
+  Da as LobbyRooms,
+  xo as LongPress,
+  Nt as MAX_POLYGON_VERTICES,
+  ka as Matchmaker,
+  Lm as MemoryBackend,
+  ym as MigrationError,
+  rm as MinHeap,
+  vr as MusicChannel,
+  Fr as MusicPlayer,
+  tm as NAV_STEPS,
+  b as ObjectFactory,
+  Zr as PAD_BUTTONS,
+  et as Parallax,
+  ot as ParallaxLayer,
+  ct as ParticleBudget,
+  nt as ParticleSim,
+  yt as PhysicsWorld,
+  J as Pointer,
+  xr as PosePlayer,
+  Aa as PredictedMover,
+  Tr as RECOIL_MS,
+  fr as RIG_PARTS,
+  W as Rectangle,
+  sr as RigView,
+  Ea as Room,
+  Pa as RoomHost,
+  oo as STICK_DEAD_ZONE,
+  Wr as SYNTH_RATE,
+  gm as SaveStore,
+  m as Scene,
+  a as SceneManager,
+  qe as Skeleton,
+  yr as SoundEngine,
+  Ne as SpriteComponent,
+  g as Stage,
+  Wp as TILE_SIZE,
+  Po as TargetLock,
+  Y as Text,
+  ee as TextureRegistry,
+  je as TilemapView,
+  F as Timeline,
+  M as TimelineBuilder,
+  qm as Translator,
+  y as Tween,
+  O as Tweener,
+  ra as UPDATE_RECORD_BYTES,
+  Xo as WeatherLayer,
+  hm as WebStorageBackend,
+  s as World,
+  he as addAsepriteTextures,
+  j as addLabelGlyphs,
+  eo as aimAxis,
+  To as aimPoint,
+  Ie as animStateSystem,
+  De as animationSystem,
+  me as atlasPageLimit,
+  Ba as balanceTeams,
+  er as blendPose,
+  zp as blocksShot,
+  Xp as bodyCollides,
+  ip as bootWatch,
+  fa as cadenceEarly,
+  sa as cadenceNext,
+  mm as canStep,
+  yp as captureErrors,
+  Fm as checksum,
+  Jr as chordHeld,
+  le as clipMarkers,
+  wo as clockText,
+  Xt as colliderColor,
+  ze as collisionFromTiled,
+  Sp as countHitches,
+  jp as createCollisionGrid,
+  Zp as createMover,
+  oa as decodeSnapshotFrame,
+  ta as decodeUpdates,
+  n as defineComponent,
+  l as defineFields,
+  sp as describeError,
+  Bo as detectTouch,
+  Ym as ditherCovered,
+  So as dragSlop,
+  jt as drawColliders,
+  gt as dueParticles,
+  N as easeByName,
+  Dr as elementVolumeLocked,
+  ma as encodeSnapshotFrame,
+  pa as encodeUpdates,
+  C as engineSettings,
+  c as entityIndex,
+  op as extractStrings,
+  lm as findPath,
+  cm as floodFill,
+  $m as formatMessage,
+  ce as frameNamed,
+  He as gidOf,
+  cp as gpuName,
+  Zo as gradeAt,
+  np as guardRender,
+  Gr as hasTakes,
+  Vo as hash01,
+  Sr as hitStopMs,
+  Ar as hurtFlashGapMs,
+  Cr as hurtFlashMs,
+  hr as inView,
+  Dp as inspectWorld,
+  Z as installLabelFont,
+  pm as isOpen,
+  qp as isSolidTile,
+  No as isTouchUi,
+  ho as keptTarget,
+  Fo as keyLabel,
+  Io as keymapStorage,
+  we as layerByName,
+  St as lerpColor,
+  ue as loadAseprite,
+  Ap as looksThrottled,
+  dp as maxTextureSize,
+  Mo as mergeKeymap,
+  Gt as mergeTileRects,
+  Om as migrateSave,
+  Uo as mixRgb,
+  qo as mixToWhite,
+  Jp as moveX,
+  Qp as moveY,
+  Oa as moverFromWire,
+  Ra as moverToWire,
+  Ir as music,
+  am as navGrid,
+  xm as navGridFromCollision,
+  im as nearWallCost,
+  sm as nearestOpen,
+  uo as nearestTarget,
+  mp as noteContextLoss,
+  la as noteServerTime,
+  Ue as objectsOf,
+  dm as octile,
+  rr as overlay,
+  mt as parallaxOrigin,
+  de as parseAseprite,
+  Qr as parseChord,
+  Ke as parseTiled,
+  dt as particleBudget,
+  Cp as percentile,
+  Kt as physicsSystem,
+  yo as pickTarget,
+  pt as placeAxis,
+  pe as planAtlas,
+  Dt as polygonCentroid,
+  bt as polygonShape,
+  aa as quantizeUpdates,
+  Tm as reachedCount,
+  pp as rebuildDelayMs,
+  _r as recoilAt,
+  gr as recoilPx,
+  kr as registerSounds,
+  Hr as registerTakes,
+  kt as regularPolygon,
+  Vr as renderRecipe,
+  ca as resetServerClock,
+  ie as resolveUrl,
+  At as sampleColor,
+  Ct as sampleCurve,
+  Et as sampleRange,
+  Lt as scaleCount,
+  Pt as seededRandom,
+  da as serverNow,
+  Ta as serverOffset,
+  Do as setNativeShell,
+  bo as setTouchOverrideKey,
+  Am as simplifyPath,
+  ge as sliceAt,
+  Ee as sliceBorders,
+  Le as sliceNamed,
+  Or as sound,
+  ep as sourceText,
+  at as spanVisible,
+  Ao as spotReach,
+  Co as spotShare,
+  ht as spreadAngle,
+  $p as stepMover,
+  to as stickActive,
+  mo as stickToAxis,
+  po as stickVector,
+  Cm as straightenPath,
+  _p as summarizeFrames,
+  Vt as syncToBody,
+  d as system,
+  Se as tagDirection,
+  Ae as tagFrames,
+  Ce as tagRepeat,
+  We as tileAt,
+  Ht as tileBodies,
+  wt as tileBodiesFromGrid,
+  Ve as tileRect,
+  Ko as tintNight,
+  Nm as transitionTo,
+  hp as trimStack,
+  bm as tweenDone,
+  or as upperOver,
+  ap as watchContextLoss,
+  Yo as weatherAt,
+  zm as wipeLevel,
+  xt as wrap
+};
+//# sourceMappingURL=1681-engine.js.map

package/dist/1681-engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"1681-engine.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/ambient/ColorGrade.js

@@ -0,0 +1,41 @@
+import { Sprite as a, Texture as d } from "pixi.js";
+import { mixToWhite as n } from "./grade.js";
+class c {
+  constructor(e, s, t = {}) {
+    this.stage = e, this.read = s, this.every = t.readEveryMs ?? 500, this.sheet.blendMode = "multiply", this.sheet.visible = !1;
+    const i = t.parent ?? e.screen;
+    t.placement === "bottom" ? i.addChildAt(this.sheet, 0) : i.addChild(this.sheet);
+  }
+  stage;
+  read;
+  sheet = new a({ texture: d.WHITE });
+  readAt = -1 / 0;
+  blank = !1;
+  every;
+  /** Reads the grade again on the next update (the place changed). */
+  invalidate() {
+    this.readAt = -1 / 0;
+  }
+  /** `enabled`: the game's setting, and off under a battery saver — a full-screen blend is a cost on a phone. */
+  update(e, s = !0) {
+    if (!s) {
+      this.sheet.visible = !1, this.readAt = -1 / 0;
+      return;
+    }
+    if (e - this.readAt >= this.every) {
+      this.readAt = e;
+      const h = this.read(), r = h ? n(h.color, h.alpha) : 16777215;
+      this.blank = r === 16777215, this.sheet.tint = r;
+    }
+    if (this.sheet.visible = !this.blank, this.blank) return;
+    const { width: t, height: i } = this.stage;
+    this.sheet.width !== t && (this.sheet.width = t), this.sheet.height !== i && (this.sheet.height = i);
+  }
+  destroy() {
+    this.sheet.destroy();
+  }
+}
+export {
+  c as ColorGrade
+};
+//# sourceMappingURL=ColorGrade.js.map

package/dist/ambient/ColorGrade.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ColorGrade.js","sources":["../../src/ambient/ColorGrade.ts"],"sourcesContent":["import { Sprite, Texture, type Container } from 'pixi.js';\nimport type { Stage } from '../core/Stage';\nimport { mixToWhite, type GradeState } from './grade';\n\n/** Where the sheet goes among its parent's children. */\nexport type GradePlacement = 'top' | 'bottom';\n\nexport interface ColorGradeOptions {\n  /** How often (ms) the grade is read again: the hour moves slowly, so not every frame (default 500). */\n  readEveryMs?: number;\n  /** The container the sheet is added to (default the stage's screen layer). */\n  parent?: Container;\n  /**\n   * `'top'` (the default) adds the sheet over everything already in `parent`, so it tints a HUD made before it and\n   * not one made after. `'bottom'` puts it under every child `parent` has or will have: on the screen layer that is\n   * over the world and under every HUD, whatever order they were made in — usually what a grade wants.\n   */\n  placement?: GradePlacement;\n}\n\n/**\n * A colour laid over the whole screen in **multiply**, so it tints the world (a marsh mossy, a peak ember, a dead\n * land pale) without washing the art toward white the way a normal-blend sheet would. One white quad, tinted: no\n * filter pass, which is what a phone can spare every frame.\n *\n * `read` returns the grade now (`gradeAt` from a place's `Grade` and `DayClock`'s night, say); it is asked a few\n * times a second, and a grade that comes to white is not drawn at all. Give `placement: 'bottom'` to keep it off the\n * HUD (see `ColorGradeOptions.placement`).\n */\nexport class ColorGrade {\n  private readonly sheet = new Sprite({ texture: Texture.WHITE });\n  private readAt = -Infinity;\n  private blank = false;\n  private readonly every: number;\n\n  constructor(\n    private readonly stage: Stage,\n    private readonly read: () => GradeState | null,\n    options: ColorGradeOptions = {},\n  ) {\n    this.every = options.readEveryMs ?? 500;\n    this.sheet.blendMode = 'multiply';\n    this.sheet.visible = false;\n    const parent = options.parent ?? stage.screen;\n    if (options.placement === 'bottom') parent.addChildAt(this.sheet, 0);\n    else parent.addChild(this.sheet);\n  }\n\n  /** Reads the grade again on the next update (the place changed). */\n  invalidate(): void {\n    this.readAt = -Infinity;\n  }\n\n  /** `enabled`: the game's setting, and off under a battery saver — a full-screen blend is a cost on a phone. */\n  update(now: number, enabled = true): void {\n    if (!enabled) {\n      this.sheet.visible = false;\n      this.readAt = -Infinity;\n      return;\n    }\n    if (now - this.readAt >= this.every) {\n      this.readAt = now;\n      const g = this.read();\n      const tint = g ? mixToWhite(g.color, g.alpha) : 0xffffff;\n      this.blank = tint === 0xffffff;\n      this.sheet.tint = tint;\n    }\n    this.sheet.visible = !this.blank;\n    if (this.blank) return;\n    const { width, height } = this.stage;\n    if (this.sheet.width !== width) this.sheet.width = width;\n    if (this.sheet.height !== height) this.sheet.height = height;\n  }\n\n  destroy(): void {\n    this.sheet.destroy();\n  }\n}\n"],"names":["ColorGrade","stage","read","options","parent","Sprite","Texture","now","enabled","g","tint","mixToWhite","width","height"],"mappings":";;AA6BO,MAAMA,EAAW;AAAA,EAMtB,YACmBC,GACAC,GACjBC,IAA6B,CAAA,GAC7B;AAHiB,SAAA,QAAAF,GACA,KAAA,OAAAC,GAGjB,KAAK,QAAQC,EAAQ,eAAe,KACpC,KAAK,MAAM,YAAY,YACvB,KAAK,MAAM,UAAU;AACrB,UAAMC,IAASD,EAAQ,UAAUF,EAAM;AACvC,IAAIE,EAAQ,cAAc,aAAiB,WAAW,KAAK,OAAO,CAAC,IAC9DC,EAAO,SAAS,KAAK,KAAK;AAAA,EACjC;AAAA,EAVmB;AAAA,EACA;AAAA,EAPF,QAAQ,IAAIC,EAAO,EAAE,SAASC,EAAQ,OAAO;AAAA,EACtD,SAAS;AAAA,EACT,QAAQ;AAAA,EACC;AAAA;AAAA,EAgBjB,aAAmB;AACjB,SAAK,SAAS;AAAA,EAChB;AAAA;AAAA,EAGA,OAAOC,GAAaC,IAAU,IAAY;AACxC,QAAI,CAACA,GAAS;AACZ,WAAK,MAAM,UAAU,IACrB,KAAK,SAAS;AACd;AAAA,IACF;AACA,QAAID,IAAM,KAAK,UAAU,KAAK,OAAO;AACnC,WAAK,SAASA;AACd,YAAME,IAAI,KAAK,KAAA,GACTC,IAAOD,IAAIE,EAAWF,EAAE,OAAOA,EAAE,KAAK,IAAI;AAChD,WAAK,QAAQC,MAAS,UACtB,KAAK,MAAM,OAAOA;AAAA,IACpB;AAEA,QADA,KAAK,MAAM,UAAU,CAAC,KAAK,OACvB,KAAK,MAAO;AAChB,UAAM,EAAE,OAAAE,GAAO,QAAAC,EAAA,IAAW,KAAK;AAC/B,IAAI,KAAK,MAAM,UAAUD,MAAO,KAAK,MAAM,QAAQA,IAC/C,KAAK,MAAM,WAAWC,MAAQ,KAAK,MAAM,SAASA;AAAA,EACxD;AAAA,EAEA,UAAgB;AACd,SAAK,MAAM,QAAA;AAAA,EACb;AACF;"}

package/dist/ambient/DayClock.js

@@ -0,0 +1,57 @@
+function f(h, s, t) {
+  const e = (a) => Math.round((h >> a & 255) * (1 - t) + (s >> a & 255) * t);
+  return e(16) << 16 | e(8) << 8 | e(0);
+}
+class u {
+  periodMs;
+  offsetMs;
+  keys;
+  phases;
+  maxAlpha;
+  /** A phase held still (a debug command, a cut scene at midnight); null follows the clock. */
+  held = null;
+  constructor(s) {
+    if (!(s.periodMs > 0)) throw new Error("DayClock: periodMs must be above 0");
+    if (!s.keys.length) throw new Error("DayClock: at least one key");
+    this.periodMs = s.periodMs, this.offsetMs = s.offsetMs ?? 0, this.keys = [...s.keys].sort((t, e) => t.at - e.at), this.phases = [...s.phases ?? []].sort((t, e) => t.from - e.from), this.maxAlpha = Math.max(0.01, ...this.keys.map((t) => t.alpha));
+  }
+  /** Holds the day at `phase` (0..1), or lets it run again with null. */
+  hold(s) {
+    this.held = s === null ? null : (s % 1 + 1) % 1;
+  }
+  /** Where the day stands at wall time `ms` (0..1). */
+  phaseAt(s) {
+    if (this.held !== null) return this.held;
+    const t = this.periodMs;
+    return ((s + this.offsetMs) % t + t) % t / t;
+  }
+  at(s) {
+    const t = this.phaseAt(s), e = this.keys;
+    let a = e[0], n = a.color, i = a.alpha;
+    t >= e[e.length - 1].at && (a = e[e.length - 1], n = a.color, i = a.alpha);
+    for (let o = 0; o < e.length - 1; o++) {
+      const r = e[o], l = e[o + 1];
+      if (t < r.at || t > l.at) continue;
+      const p = l.at > r.at ? (t - r.at) / (l.at - r.at) : 0;
+      n = f(r.color, l.color, p), i = r.alpha + (l.alpha - r.alpha) * p;
+      break;
+    }
+    let c = this.phases.length ? this.phases[this.phases.length - 1].id : "";
+    for (const o of this.phases) t >= o.from && (c = o.id);
+    return { phase: t, id: c, color: n, alpha: i, night: Math.min(1, i / this.maxAlpha) };
+  }
+}
+function d(h) {
+  const s = Math.floor((h % 1 + 1) % 1 * 24 * 60);
+  return `${String(Math.floor(s / 60)).padStart(2, "0")}:${String(s % 60).padStart(2, "0")}`;
+}
+function M(h, s, t = 0.6) {
+  return s === void 0 ? h.color : f(h.color, s, h.night * t);
+}
+export {
+  u as DayClock,
+  d as clockText,
+  f as mixRgb,
+  M as tintNight
+};
+//# sourceMappingURL=DayClock.js.map

package/dist/ambient/DayClock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DayClock.js","sources":["../../src/ambient/DayClock.ts"],"sourcesContent":["/**\n * A time of day read off a wall clock, so every client that agrees on the time (`serverNow`) stands in the same dusk\n * without a packet between them. Pure: no Pixi, no clock of its own — the caller hands in the time, and what draws\n * the night (a `LightLayer`, the pixel `NightShade`) or a HUD badge reads what this returns.\n *\n * ```ts\n * const clock = new DayClock({\n *   periodMs: 2 * 3600_000, // a game day every two real hours\n *   keys: [\n *     { at: 0, color: 0x0a1030, alpha: 0.52 },\n *     { at: 0.3, color: 0xfff0d8, alpha: 0 },\n *     { at: 0.7, color: 0xffb070, alpha: 0 },\n *     { at: 0.86, color: 0x0a1030, alpha: 0.52 },\n *   ],\n *   phases: [{ id: 'dawn', from: 0.2 }, { id: 'day', from: 0.3 }, { id: 'dusk', from: 0.7 }, { id: 'night', from: 0.8 }],\n * });\n * const day = clock.at(serverNow()); // { phase, id, color, alpha, night }\n * ```\n *\n * Phase 0 is midnight and 0.5 noon. Keys are the grade laid over the outdoor world at points of the day, mixed\n * between neighbours; a key at 0 and one at 1 with the same values make midnight seamless.\n */\n\n/** The world's grade at one point of the day: its colour (0xRRGGBB) and how strongly it is laid (0 by day). */\nexport interface DayKey {\n  at: number;\n  color: number;\n  alpha: number;\n}\n\n/** A named part of the day starting at `from` (0..1); the last one runs on through midnight. */\nexport interface DayPhase<P extends string = string> {\n  id: P;\n  from: number;\n}\n\nexport interface DayClockOptions<P extends string = string> {\n  /** Real milliseconds a whole game day lasts. */\n  periodMs: number;\n  /** Shifts the day against the wall clock (the same offset on every client keeps them together). */\n  offsetMs?: number;\n  /** At least one key. */\n  keys: readonly DayKey[];\n  /** Optional names for parts of the day; without them `id` is ''. */\n  phases?: readonly DayPhase<P>[];\n}\n\nexport interface DayState<P extends string = string> {\n  /** 0..1 through the game day: 0 midnight, 0.5 noon. */\n  phase: number;\n  /** The part of the day `phase` falls in. */\n  id: P | '';\n  /** The grade over the outdoor world, 0xRRGGBB. */\n  color: number;\n  /** How strongly the grade is laid (0 at full day). */\n  alpha: number;\n  /** 0 by day, 1 at the darkest key: how much lamps matter. */\n  night: number;\n}\n\n/** `a` taken `t` of the way to `b`, per channel, 0xRRGGBB. */\nexport function mixRgb(a: number, b: number, t: number): number {\n  const ch = (s: number) => Math.round(((a >> s) & 255) * (1 - t) + ((b >> s) & 255) * t);\n  return (ch(16) << 16) | (ch(8) << 8) | ch(0);\n}\n\nexport class DayClock<P extends string = string> {\n  private readonly periodMs: number;\n  private readonly offsetMs: number;\n  private readonly keys: DayKey[];\n  private readonly phases: DayPhase<P>[];\n  private readonly maxAlpha: number;\n  /** A phase held still (a debug command, a cut scene at midnight); null follows the clock. */\n  private held: number | null = null;\n\n  constructor(options: DayClockOptions<P>) {\n    if (!(options.periodMs > 0)) throw new Error('DayClock: periodMs must be above 0');\n    if (!options.keys.length) throw new Error('DayClock: at least one key');\n    this.periodMs = options.periodMs;\n    this.offsetMs = options.offsetMs ?? 0;\n    this.keys = [...options.keys].sort((a, b) => a.at - b.at);\n    this.phases = [...(options.phases ?? [])].sort((a, b) => a.from - b.from);\n    // a clock whose darkest key is barely dark still reaches night 1 there, and one with no dark never divides by 0\n    this.maxAlpha = Math.max(0.01, ...this.keys.map((k) => k.alpha));\n  }\n\n  /** Holds the day at `phase` (0..1), or lets it run again with null. */\n  hold(phase: number | null): void {\n    this.held = phase === null ? null : ((phase % 1) + 1) % 1;\n  }\n\n  /** Where the day stands at wall time `ms` (0..1). */\n  phaseAt(ms: number): number {\n    if (this.held !== null) return this.held;\n    const p = this.periodMs;\n    return ((((ms + this.offsetMs) % p) + p) % p) / p;\n  }\n\n  at(ms: number): DayState<P> {\n    const phase = this.phaseAt(ms);\n    const keys = this.keys;\n    let key = keys[0]!;\n    let color = key.color;\n    let alpha = key.alpha;\n    // past the last key it holds; before the first it holds the first\n    if (phase >= keys[keys.length - 1]!.at) {\n      key = keys[keys.length - 1]!;\n      color = key.color;\n      alpha = key.alpha;\n    }\n    for (let i = 0; i < keys.length - 1; i++) {\n      const a = keys[i]!;\n      const b = keys[i + 1]!;\n      if (phase < a.at || phase > b.at) continue;\n      const t = b.at > a.at ? (phase - a.at) / (b.at - a.at) : 0;\n      color = mixRgb(a.color, b.color, t);\n      alpha = a.alpha + (b.alpha - a.alpha) * t;\n      break;\n    }\n    // the stretch before the first `from` belongs to the last phase: night runs through midnight\n    let id: P | '' = this.phases.length ? this.phases[this.phases.length - 1]!.id : '';\n    for (const ph of this.phases) if (phase >= ph.from) id = ph.id;\n    return { phase, id, color, alpha, night: Math.min(1, alpha / this.maxAlpha) };\n  }\n}\n\n/** A day's phase as a 24-hour clock, \"HH:MM\" (phase 0 is midnight). */\nexport function clockText(phase: number): string {\n  const minutes = Math.floor((((phase % 1) + 1) % 1) * 24 * 60);\n  return `${String(Math.floor(minutes / 60)).padStart(2, '0')}:${String(minutes % 60).padStart(2, '0')}`;\n}\n\n/**\n * The night's colour pulled toward a place's own (a marsh mossy, a wood blue) as it deepens: `share` of the way at\n * full night, nothing by day.\n */\nexport function tintNight(day: Pick<DayState, 'color' | 'night'>, tint: number | undefined, share = 0.6): number {\n  return tint === undefined ? day.color : mixRgb(day.color, tint, day.night * share);\n}\n"],"names":["mixRgb","a","b","ch","s","DayClock","options","k","phase","ms","p","keys","key","color","alpha","i","t","id","ph","clockText","minutes","tintNight","day","tint","share"],"mappings":"AA6DO,SAASA,EAAOC,GAAWC,GAAW,GAAmB;AAC9D,QAAMC,IAAK,CAACC,MAAc,KAAK,OAAQH,KAAKG,IAAK,QAAQ,IAAI,MAAOF,KAAKE,IAAK,OAAO,CAAC;AACtF,SAAQD,EAAG,EAAE,KAAK,KAAOA,EAAG,CAAC,KAAK,IAAKA,EAAG,CAAC;AAC7C;AAEO,MAAME,EAAoC;AAAA,EAC9B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAET,OAAsB;AAAA,EAE9B,YAAYC,GAA6B;AACvC,QAAI,EAAEA,EAAQ,WAAW,GAAI,OAAM,IAAI,MAAM,oCAAoC;AACjF,QAAI,CAACA,EAAQ,KAAK,OAAQ,OAAM,IAAI,MAAM,4BAA4B;AACtE,SAAK,WAAWA,EAAQ,UACxB,KAAK,WAAWA,EAAQ,YAAY,GACpC,KAAK,OAAO,CAAC,GAAGA,EAAQ,IAAI,EAAE,KAAK,CAACL,GAAGC,MAAMD,EAAE,KAAKC,EAAE,EAAE,GACxD,KAAK,SAAS,CAAC,GAAII,EAAQ,UAAU,CAAA,CAAG,EAAE,KAAK,CAACL,GAAGC,MAAMD,EAAE,OAAOC,EAAE,IAAI,GAExE,KAAK,WAAW,KAAK,IAAI,MAAM,GAAG,KAAK,KAAK,IAAI,CAACK,MAAMA,EAAE,KAAK,CAAC;AAAA,EACjE;AAAA;AAAA,EAGA,KAAKC,GAA4B;AAC/B,SAAK,OAAOA,MAAU,OAAO,QAASA,IAAQ,IAAK,KAAK;AAAA,EAC1D;AAAA;AAAA,EAGA,QAAQC,GAAoB;AAC1B,QAAI,KAAK,SAAS,KAAM,QAAO,KAAK;AACpC,UAAMC,IAAI,KAAK;AACf,aAAWD,IAAK,KAAK,YAAYC,IAAKA,KAAKA,IAAKA;AAAA,EAClD;AAAA,EAEA,GAAGD,GAAyB;AAC1B,UAAMD,IAAQ,KAAK,QAAQC,CAAE,GACvBE,IAAO,KAAK;AAClB,QAAIC,IAAMD,EAAK,CAAC,GACZE,IAAQD,EAAI,OACZE,IAAQF,EAAI;AAEhB,IAAIJ,KAASG,EAAKA,EAAK,SAAS,CAAC,EAAG,OAClCC,IAAMD,EAAKA,EAAK,SAAS,CAAC,GAC1BE,IAAQD,EAAI,OACZE,IAAQF,EAAI;AAEd,aAASG,IAAI,GAAGA,IAAIJ,EAAK,SAAS,GAAGI,KAAK;AACxC,YAAMd,IAAIU,EAAKI,CAAC,GACVb,IAAIS,EAAKI,IAAI,CAAC;AACpB,UAAIP,IAAQP,EAAE,MAAMO,IAAQN,EAAE,GAAI;AAClC,YAAMc,IAAId,EAAE,KAAKD,EAAE,MAAMO,IAAQP,EAAE,OAAOC,EAAE,KAAKD,EAAE,MAAM;AACzD,MAAAY,IAAQb,EAAOC,EAAE,OAAOC,EAAE,OAAOc,CAAC,GAClCF,IAAQb,EAAE,SAASC,EAAE,QAAQD,EAAE,SAASe;AACxC;AAAA,IACF;AAEA,QAAIC,IAAa,KAAK,OAAO,SAAS,KAAK,OAAO,KAAK,OAAO,SAAS,CAAC,EAAG,KAAK;AAChF,eAAWC,KAAM,KAAK,OAAQ,CAAIV,KAASU,EAAG,aAAWA,EAAG;AAC5D,WAAO,EAAE,OAAAV,GAAO,IAAAS,GAAI,OAAAJ,GAAO,OAAAC,GAAO,OAAO,KAAK,IAAI,GAAGA,IAAQ,KAAK,QAAQ,EAAA;AAAA,EAC5E;AACF;AAGO,SAASK,EAAUX,GAAuB;AAC/C,QAAMY,IAAU,KAAK,OAASZ,IAAQ,IAAK,KAAK,IAAK,KAAK,EAAE;AAC5D,SAAO,GAAG,OAAO,KAAK,MAAMY,IAAU,EAAE,CAAC,EAAE,SAAS,GAAG,GAAG,CAAC,IAAI,OAAOA,IAAU,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC;AACtG;AAMO,SAASC,EAAUC,GAAwCC,GAA0BC,IAAQ,KAAa;AAC/G,SAAOD,MAAS,SAAYD,EAAI,QAAQtB,EAAOsB,EAAI,OAAOC,GAAMD,EAAI,QAAQE,CAAK;AACnF;"}

package/dist/ambient/WeatherLayer.js

@@ -0,0 +1,91 @@
+import { Sprite as y, Texture as x } from "pixi.js";
+const r = 80, f = {
+  fall: { vx: [-48, -38], vy: [250, 320] },
+  flake: { vx: [4, 12], vy: [14, 30] },
+  bank: { vx: [3, 8], vy: [0, 0] }
+};
+class c {
+  constructor(t, i) {
+    this.stage = t, this.options = i, this.depth = i.depth ?? 900001, this.bankDepth = i.bankDepth ?? 900010, this.splashDepth = i.splashDepth ?? 0, this.snap = i.snap ?? !0, this.random = i.random ?? Math.random, this.tint.visible = !1, t.screen.addChild(this.tint);
+  }
+  stage;
+  options;
+  drops = [];
+  kind = "clear";
+  look;
+  tint = new y({ texture: x.WHITE });
+  depth;
+  bankDepth;
+  splashDepth;
+  snap;
+  random;
+  /**
+   * `now` in ms, `dt` the frame's ms, `view` the camera's world view. `share` (0..1) thins the pool on top of the
+   * weather's own strength (a reduced-effects setting keeps half).
+   */
+  update(t, i, s, h, e = 1) {
+    h.kind !== this.kind && this.rebuild(h.kind, s);
+    const n = this.look, a = (n?.tintAlpha ?? 0) * h.intensity;
+    if (this.tint.visible = a > 4e-3, this.tint.visible && (this.tint.tint = n?.tint ?? 16777215, this.tint.alpha = a, this.tint.width = this.stage.width, this.tint.height = this.stage.height), !n) return;
+    const g = Math.round(this.drops.length * h.intensity * Math.max(0, Math.min(1, e))), l = i / 1e3;
+    for (let p = 0; p < this.drops.length; p++) {
+      const o = this.drops[p];
+      if (p >= g) {
+        o.img.visible && o.img.setVisible(!1);
+        continue;
+      }
+      o.img.visible || this.spawn(o, n, s, !1), n.motion === "fall" ? this.stepFall(o, n, t, l, s) : n.motion === "bank" ? this.stepBank(o, n, l, s, h.intensity) : this.stepFlake(o, n, t, l, s);
+    }
+  }
+  rebuild(t, i) {
+    for (const h of this.drops) h.img.destroy();
+    this.drops.length = 0, this.kind = t, this.look = t === "clear" ? void 0 : this.options.looks[t];
+    const s = this.look;
+    if (!(!s || !s.keys.length))
+      for (let h = 0; h < s.max; h++) {
+        const e = s.keys[h % s.keys.length], n = this.stage.add.image(0, 0, e).setOrigin(0, 0).setVisible(!1), a = { img: n, key: e, x: 0, y: 0, vx: 0, vy: 0, ground: 0, splashAt: 0 };
+        this.drops.push(a), this.spawn(a, s, i, !0), n.setVisible(!1);
+      }
+  }
+  between(t) {
+    return t[0] + (t[1] - t[0]) * this.random();
+  }
+  place(t) {
+    t.img.setPosition(this.snap ? Math.round(t.x) : t.x, this.snap ? Math.round(t.y) : t.y);
+  }
+  spawn(t, i, s, h) {
+    const e = this.random, n = f[i.motion], a = s.x - 30 + e() * (s.width + 60);
+    t.vx = this.between(i.vx ?? n.vx), t.vy = this.between(i.vy ?? n.vy), i.motion === "fall" ? (t.ground = s.y + e() * (s.height + 12), t.y = h ? s.y - 10 + e() * (t.ground - s.y + 10) : t.ground - 30 - e() * s.height, t.x = a, t.splashAt = 0, t.img.setTexture(t.key).setDepth(this.depth).setAlpha(1)) : i.motion === "bank" ? (t.x = h ? a : s.x - t.img.width, t.y = s.y + e() * s.height, t.img.setDepth(this.bankDepth)) : (t.x = a, t.y = h ? s.y + e() * s.height : s.y - 4 - e() * 20, t.ground = e() * Math.PI * 2, t.img.setDepth(this.depth)), t.img.setVisible(!0);
+  }
+  stepFall(t, i, s, h, e) {
+    if (t.splashAt) {
+      const n = s - t.splashAt;
+      n > r * 2 ? this.spawn(t, i, e, !1) : n > r && i.splash && t.img.setTexture(i.splash[1]);
+      return;
+    }
+    if (t.x += t.vx * h, t.y += t.vy * h, t.y >= t.ground) {
+      i.splash && this.random() < 0.5 ? (t.splashAt = s, t.img.setTexture(i.splash[0]).setDepth(this.splashDepth), t.x -= t.img.width / 2, t.y = t.ground - 1, this.place(t)) : this.spawn(t, i, e, !1);
+      return;
+    }
+    this.place(t);
+  }
+  stepFlake(t, i, s, h, e) {
+    if (t.x += t.vx * h, t.y += t.vy * h, t.y > e.bottom + 4 || t.x > e.right + 30 || t.x < e.x - 40) {
+      this.spawn(t, i, e, !1);
+      return;
+    }
+    const n = Math.sin(s / 900 + t.ground) * (i.sway ?? 4), a = t.x + n;
+    t.img.setPosition(this.snap ? Math.round(a) : a, this.snap ? Math.round(t.y) : t.y);
+  }
+  stepBank(t, i, s, h, e) {
+    t.x += t.vx * s, (t.x > h.right + 10 || t.y < h.y - 20 || t.y > h.bottom + 10) && this.spawn(t, i, h, t.x <= h.right + 10), t.img.setAlpha(0.35 + 0.5 * e), this.place(t);
+  }
+  destroy() {
+    for (const t of this.drops) t.img.destroy();
+    this.drops.length = 0, this.tint.destroy();
+  }
+}
+export {
+  c as WeatherLayer
+};
+//# sourceMappingURL=WeatherLayer.js.map