1681-engine 0.0.0-stage → 0.5.9

package/dist/1681-engine.js

@@ -0,0 +1,471 @@
+import { Engine as r } from "./engine/Engine.js";
+import { Scene as m } from "./engine/Scene.js";
+import { SceneManager as a } from "./engine/SceneManager.js";
+import { FixedLoop as x } from "./engine/FixedLoop.js";
+import { HiddenPause as s } from "./engine/HiddenPause.js";
+import { World as l, defineComponent as c, defineFields as d, entityIndex as S, system as u } from "./ecs/World.js";
+import { EventBus as A } from "./events/EventBus.js";
+import { engineSettings as g } from "./settings.js";
+import { Stage as _ } from "./core/Stage.js";
+import { Camera as L } from "./core/Camera.js";
+import { baseZoom as y, fitScale as R, worldZoom as O, zoomResolution as F, zoomSteps as M } from "./core/pixelZoom.js";
+import { Clock as b } from "./core/Clock.js";
+import { runDue as N } from "./core/runDue.js";
+import { Tween as D, Tweener as B } from "./core/Tweener.js";
+import { Timeline as G } from "./core/Timeline.js";
+import { TimelineBuilder as K } from "./core/TimelineBuilder.js";
+import { easeByName as W } from "./core/eases.js";
+import { ObjectFactory as Y } from "./core/ObjectFactory.js";
+import { Graphics as Z } from "./core/Graphics.js";
+import { Image as j } from "./core/Image.js";
+import { clearSilhouettes as J, fillSolid as Q, solidSilhouette as $ } from "./core/silhouette.js";
+import { Group as oe } from "./core/Group.js";
+import { blendLayer as te } from "./core/blendLayer.js";
+import { Rectangle as pe } from "./core/Rectangle.js";
+import { Text as ie } from "./core/Text.js";
+import { BitmapLabel as fe, addLabelGlyphs as se, installLabelFont as ne } from "./core/BitmapLabel.js";
+import { Pointer as ce } from "./core/Pointer.js";
+import { CanvasTexture as Se, TextureRegistry as ue } from "./core/TextureRegistry.js";
+import { AtlasBuilder as Ae } from "./core/atlas.js";
+import { atlasPageLimit as ge, planAtlas as Pe } from "./core/atlasPlan.js";
+import { AssetLoader as Ee, resolveUrl as Le } from "./assets/AssetLoader.js";
+import { collectAtlasPages as ye, duplicateFrames as Re, parseAtlas as Oe } from "./assets/textureAtlas.js";
+import { Animator as Me } from "./anim/Animator.js";
+import { clipMarkers as be, frameNamed as ke, parseAseprite as Ne } from "./anim/parseAseprite.js";
+import { tagDirection as De, tagFrames as Be, tagRepeat as He } from "./anim/asepriteTags.js";
+import { sliceAt as we, sliceBorders as Ke, sliceNamed as Ue } from "./anim/asepriteSlices.js";
+import { addAsepriteTextures as Ve, loadAseprite as Ye } from "./assets/loadAseprite.js";
+import { AnimStateMachine as Ze } from "./anim/AnimStateMachine.js";
+import { AnimStateComponent as je, animStateSystem as qe } from "./anim/animStateSystem.js";
+import { AnimationComponent as Qe, SpriteComponent as $e, animationSystem as eo } from "./anim/animationSystem.js";
+import { FLIP_D as ro, FLIP_H as to, FLIP_V as mo, gidOf as po, layerByName as ao, objectsOf as io, parseTiled as xo, tileAt as fo, tileRect as so } from "./tilemap/tiled.js";
+import { collisionFromTiled as lo } from "./tilemap/collision.js";
+import { TilemapView as So } from "./tilemap/TilemapView.js";
+import { Skeleton as To } from "./rig/Skeleton.js";
+import { HUMANOID_RIG as Co } from "./rig/humanoid.js";
+import { blendPose as Po, overlay as _o, upperOver as Eo } from "./rig/poseMath.js";
+import { HUMANOID_CLIPS as ho, HUMANOID_POSES as yo } from "./rig/humanoidPoses.js";
+import { PosePlayer as Oo } from "./rig/PosePlayer.js";
+import { RIG_PARTS as Mo, RigView as Io } from "./rig/RigView.js";
+import { LightLayer as ko } from "./light/LightLayer.js";
+import { HEAVY_FLASH_GAP_MS as vo, RECOIL_MS as Do, hitStopMs as Bo, hurtFlashGapMs as Ho, hurtFlashMs as Go, recoilAt as wo, recoilPx as Ko } from "./fx/hitStop.js";
+import { FloatingText as Wo } from "./fx/FloatingText.js";
+import { inView as Yo } from "./fx/viewCull.js";
+import { Afterimages as Zo } from "./fx/Afterimages.js";
+import { SoundEngine as jo, sound as qo } from "./audio/SoundEngine.js";
+import { MusicPlayer as Qo, music as $o } from "./audio/MusicPlayer.js";
+import { MusicChannel as or } from "./audio/music/MusicChannel.js";
+import { elementVolumeLocked as tr } from "./audio/music/musicVoice.js";
+import { registerSounds as pr } from "./audio/soundTable.js";
+import { hasTakes as ir, registerTakes as xr } from "./audio/sampleBank.js";
+import { Footsteps as sr } from "./audio/Footsteps.js";
+import { SYNTH_RATE as lr, renderRecipe as cr } from "./audio/synth.js";
+import { Keyboard as Sr } from "./input/Keyboard.js";
+import { Actions as Tr, PAD_BUTTONS as Ar } from "./input/Actions.js";
+import { chordHeld as gr, parseChord as Pr } from "./input/keyChord.js";
+import { aimAxis as Er } from "./input/aimAxis.js";
+import { STICK_DEAD_ZONE as hr, stickActive as yr, stickToAxis as Rr, stickVector as Or } from "./input/stickAxis.js";
+import { LongPress as Mr } from "./input/longPress.js";
+import { AIM_CENTRE as br, AIM_EARLY_SLOP as kr, AIM_PRESS_MS as Nr, AIM_TAP_SLOP as vr, AimGesture as Dr, aimPoint as Br, dragSlop as Hr, spotReach as Gr, spotShare as wr } from "./input/AimGesture.js";
+import { LOCK_KEEP_RANGE as Ur, LOCK_PICK_CONE as Wr, LOCK_PICK_RANGE as Vr, TargetLock as Yr, keptTarget as zr, nearestTarget as Zr, pickTarget as Xr } from "./input/TargetLock.js";
+import { Keymap as qr, keyLabel as Jr, keymapStorage as Qr, mergeKeymap as $r } from "./input/Keymap.js";
+import { isTouchUi as ot, setNativeShell as rt, setTouchOverrideKey as tt } from "./platform/touch.js";
+import { onAppResume as pt } from "./platform/appResume.js";
+import { timeoutSignal as it } from "./platform/timeoutSignal.js";
+import { rumble as ft, rumblePad as st, rumbleParams as nt, stopRumble as lt } from "./input/rumble.js";
+import { enterFullscreen as dt, exitFullscreen as St, fullscreenSupported as ut, isFullscreen as Tt, onFullscreenChange as At, toggleFullscreen as Ct } from "./platform/fullscreen.js";
+import { currentOrientationKind as Pt, lockOrientation as _t, unlockOrientation as Et } from "./platform/orientation.js";
+import { followReducedMotion as ht, onReducedMotionChange as yt, prefersReducedMotion as Rt } from "./platform/reducedMotion.js";
+import { exitPointerLock as Ft, isPointerLocked as Mt, onPointerLockChange as It, requestPointerLock as bt } from "./platform/pointerLock.js";
+import { detectTouch as Nt } from "./input/touchDetect.js";
+import { DayClock as Dt, clockText as Bt, mixRgb as Ht, tintNight as Gt } from "./ambient/DayClock.js";
+import { hash01 as Kt, weatherAt as Ut } from "./ambient/weather.js";
+import { WeatherLayer as Vt } from "./ambient/WeatherLayer.js";
+import { gradeAt as zt, mixToWhite as Zt } from "./ambient/grade.js";
+import { ColorGrade as jt } from "./ambient/ColorGrade.js";
+import { Parallax as Jt } from "./parallax/Parallax.js";
+import { ParallaxLayer as $t } from "./parallax/ParallaxLayer.js";
+import { parallaxOrigin as om, placeAxis as rm, spanVisible as tm, wrap as mm } from "./parallax/parallaxMath.js";
+import { Emitter as am } from "./particles/Emitter.js";
+import { ParticleSim as xm } from "./particles/ParticleSim.js";
+import { ParticleBudget as sm, particleBudget as nm } from "./particles/ParticleBudget.js";
+import { lerpColor as cm, sampleColor as dm, sampleCurve as Sm } from "./particles/particleCurves.js";
+import { dueParticles as Tm, sampleRange as Am, scaleCount as Cm, seededRandom as gm, spreadAngle as Pm } from "./particles/particleSampling.js";
+import { PhysicsWorld as Em } from "./physics/PhysicsWorld.js";
+import { Body as hm } from "./physics/Body.js";
+import { Contact as Rm, ContactPoint as Om } from "./physics/Contact.js";
+import { MAX_POLYGON_VERTICES as Mm, polygonCentroid as Im, polygonShape as bm, regularPolygon as km } from "./physics/polygon.js";
+import { mergeTileRects as vm, tileBodies as Dm, tileBodiesFromGrid as Bm } from "./physics/tileBodies.js";
+import { physicsSystem as Gm } from "./physics/physicsSystem.js";
+import { syncToBody as Km } from "./physics/syncToBody.js";
+import { COLLIDER_COLORS as Wm, colliderColor as Vm, drawColliders as Ym } from "./physics/drawColliders.js";
+import { FACE_BOTTOM as Zm, FACE_LEFT as Xm, FACE_RIGHT as jm, FACE_TOP as qm } from "./physics/types.js";
+import { MinHeap as Qm } from "./nav/MinHeap.js";
+import { NAV_STEPS as ep, canStep as op, isOpen as rp, navGrid as tp, navGridFromCollision as mp, nearWallCost as pp } from "./nav/navGrid.js";
+import { nearestOpen as ip } from "./nav/nearestOpen.js";
+import { findPath as fp, floodFill as sp, octile as np, reachedCount as lp } from "./nav/findPath.js";
+import { simplifyPath as dp, straightenPath as Sp } from "./nav/straightenPath.js";
+import { SaveStore as Tp } from "./save/SaveStore.js";
+import { MemoryBackend as Cp } from "./save/MemoryBackend.js";
+import { WebStorageBackend as Pp } from "./save/WebStorageBackend.js";
+import { MigrationError as Ep, migrateSave as Lp } from "./save/migrateSave.js";
+import { checksum as yp } from "./save/checksum.js";
+import { Autosaver as Op } from "./save/Autosaver.js";
+import { transitionTo as Mp } from "./transitions/transitionTo.js";
+import { tweenDone as bp } from "./transitions/tweenDone.js";
+import { FadeTransition as Np } from "./transitions/FadeTransition.js";
+import { CrossfadeTransition as Dp } from "./transitions/CrossfadeTransition.js";
+import { DitherWipeTransition as Hp } from "./transitions/DitherWipeTransition.js";
+import { BAYER4 as wp, DITHER_LEVELS as Kp, ditherCovered as Up, wipeLevel as Wp } from "./transitions/ditherMask.js";
+import { Letterbox as Yp } from "./transitions/Letterbox.js";
+import { Translator as Zp } from "./i18n/Translator.js";
+import { CONTEXT_MARK as jp, formatMessage as qp, sourceText as Jp } from "./i18n/formatMessage.js";
+import { extractStrings as $p } from "./i18n/extractStrings.js";
+import { noteContextLoss as oa, rebuildDelayMs as ra, watchContextLoss as ta } from "./diagnostics/contextLoss.js";
+import { bootWatch as pa } from "./diagnostics/bootWatch.js";
+import { describeError as ia, guardRender as xa } from "./diagnostics/renderGuard.js";
+import { gpuName as sa, maxTextureSize as na } from "./diagnostics/gpuInfo.js";
+import { countHitches as ca, looksThrottled as da, percentile as Sa, summarizeFrames as ua } from "./diagnostics/frameStats.js";
+import { FrameSampler as Aa } from "./diagnostics/FrameSampler.js";
+import { ErrorDeduper as ga, trimStack as Pa } from "./diagnostics/ErrorDeduper.js";
+import { captureErrors as Ea } from "./diagnostics/captureErrors.js";
+import { DebugOverlay as ha } from "./debug/DebugOverlay.js";
+import { FrameStats as Ra } from "./debug/FrameStats.js";
+import { ErrorLog as Fa } from "./debug/ErrorLog.js";
+import { inspectWorld as Ia } from "./debug/inspectWorld.js";
+import { DrawCallCounter as ka } from "./debug/DrawCallCounter.js";
+import { BODY_HALF_HEIGHT as va, BODY_HALF_WIDTH as Da, INPUT_FLAG_DASH as Ba, INPUT_STEP_DT as Ha, INPUT_STEP_RATE as Ga, TILE_SIZE as wa } from "./net/constants.js";
+import { DIAGONAL as Ua, blocksShot as Wa, bodyCollides as Va, createCollisionGrid as Ya, createMover as za, isSolidTile as Za, moveX as Xa, moveY as ja, stepMover as qa } from "./net/movement.js";
+import { UPDATE_RECORD_BYTES as Qa, decodeSnapshotFrame as $a, decodeUpdates as ei, encodeSnapshotFrame as oi, encodeUpdates as ri, quantizeUpdates as ti } from "./net/snapshotCodec.js";
+import { CADENCE as pi, cadenceEarly as ai, cadenceNext as ii } from "./net/cadence.js";
+import { noteServerTime as fi, resetServerClock as si, serverNow as ni, serverOffset as li } from "./net/serverClock.js";
+import { PredictedMover as di } from "./net/PredictedMover.js";
+import { InterpolationBuffer as ui } from "./net/InterpolationBuffer.js";
+import { Room as Ai } from "./net/Room.js";
+import { RoomHost as gi } from "./net/RoomHost.js";
+import { CLOSE_NO_ANSWER as _i, Connection as Ei } from "./net/Connection.js";
+import { reconnectDelay as hi, shouldReconnect as yi } from "./net/reconnect.js";
+import { moverFromWire as Oi, moverToWire as Fi } from "./net/protocol.js";
+import { LobbyClient as Ii } from "./net/lobby/LobbyClient.js";
+import { LobbyHost as ki } from "./net/lobby/LobbyHost.js";
+import { LobbyRooms as vi } from "./net/lobby/LobbyRooms.js";
+import { Matchmaker as Bi, balanceTeams as Hi } from "./net/lobby/Matchmaker.js";
+export {
+  br as AIM_CENTRE,
+  kr as AIM_EARLY_SLOP,
+  Nr as AIM_PRESS_MS,
+  vr as AIM_TAP_SLOP,
+  Tr as Actions,
+  Zo as Afterimages,
+  Dr as AimGesture,
+  je as AnimStateComponent,
+  Ze as AnimStateMachine,
+  Qe as AnimationComponent,
+  Me as Animator,
+  Ee as AssetLoader,
+  Ae as AtlasBuilder,
+  Op as Autosaver,
+  wp as BAYER4,
+  va as BODY_HALF_HEIGHT,
+  Da as BODY_HALF_WIDTH,
+  fe as BitmapLabel,
+  hm as Body,
+  pi as CADENCE,
+  _i as CLOSE_NO_ANSWER,
+  Wm as COLLIDER_COLORS,
+  jp as CONTEXT_MARK,
+  L as Camera,
+  Se as CanvasTexture,
+  b as Clock,
+  jt as ColorGrade,
+  Ei as Connection,
+  Rm as Contact,
+  Om as ContactPoint,
+  Dp as CrossfadeTransition,
+  Ua as DIAGONAL,
+  Kp as DITHER_LEVELS,
+  Dt as DayClock,
+  ha as DebugOverlay,
+  Hp as DitherWipeTransition,
+  ka as DrawCallCounter,
+  am as Emitter,
+  r as Engine,
+  ga as ErrorDeduper,
+  Fa as ErrorLog,
+  A as EventBus,
+  Zm as FACE_BOTTOM,
+  Xm as FACE_LEFT,
+  jm as FACE_RIGHT,
+  qm as FACE_TOP,
+  ro as FLIP_D,
+  to as FLIP_H,
+  mo as FLIP_V,
+  Np as FadeTransition,
+  x as FixedLoop,
+  Wo as FloatingText,
+  sr as Footsteps,
+  Aa as FrameSampler,
+  Ra as FrameStats,
+  Z as Graphics,
+  oe as Group,
+  vo as HEAVY_FLASH_GAP_MS,
+  ho as HUMANOID_CLIPS,
+  yo as HUMANOID_POSES,
+  Co as HUMANOID_RIG,
+  s as HiddenPause,
+  Ba as INPUT_FLAG_DASH,
+  Ha as INPUT_STEP_DT,
+  Ga as INPUT_STEP_RATE,
+  j as Image,
+  ui as InterpolationBuffer,
+  Sr as Keyboard,
+  qr as Keymap,
+  Ur as LOCK_KEEP_RANGE,
+  Wr as LOCK_PICK_CONE,
+  Vr as LOCK_PICK_RANGE,
+  Yp as Letterbox,
+  ko as LightLayer,
+  Ii as LobbyClient,
+  ki as LobbyHost,
+  vi as LobbyRooms,
+  Mr as LongPress,
+  Mm as MAX_POLYGON_VERTICES,
+  Bi as Matchmaker,
+  Cp as MemoryBackend,
+  Ep as MigrationError,
+  Qm as MinHeap,
+  or as MusicChannel,
+  Qo as MusicPlayer,
+  ep as NAV_STEPS,
+  Y as ObjectFactory,
+  Ar as PAD_BUTTONS,
+  Jt as Parallax,
+  $t as ParallaxLayer,
+  sm as ParticleBudget,
+  xm as ParticleSim,
+  Em as PhysicsWorld,
+  ce as Pointer,
+  Oo as PosePlayer,
+  di as PredictedMover,
+  Do as RECOIL_MS,
+  Mo as RIG_PARTS,
+  pe as Rectangle,
+  Io as RigView,
+  Ai as Room,
+  gi as RoomHost,
+  hr as STICK_DEAD_ZONE,
+  lr as SYNTH_RATE,
+  Tp as SaveStore,
+  m as Scene,
+  a as SceneManager,
+  To as Skeleton,
+  jo as SoundEngine,
+  $e as SpriteComponent,
+  _ as Stage,
+  wa as TILE_SIZE,
+  Yr as TargetLock,
+  ie as Text,
+  ue as TextureRegistry,
+  So as TilemapView,
+  G as Timeline,
+  K as TimelineBuilder,
+  Zp as Translator,
+  D as Tween,
+  B as Tweener,
+  Qa as UPDATE_RECORD_BYTES,
+  Vt as WeatherLayer,
+  Pp as WebStorageBackend,
+  l as World,
+  Ve as addAsepriteTextures,
+  se as addLabelGlyphs,
+  Er as aimAxis,
+  Br as aimPoint,
+  qe as animStateSystem,
+  eo as animationSystem,
+  ge as atlasPageLimit,
+  Hi as balanceTeams,
+  y as baseZoom,
+  te as blendLayer,
+  Po as blendPose,
+  Wa as blocksShot,
+  Va as bodyCollides,
+  pa as bootWatch,
+  ai as cadenceEarly,
+  ii as cadenceNext,
+  op as canStep,
+  Ea as captureErrors,
+  yp as checksum,
+  gr as chordHeld,
+  J as clearSilhouettes,
+  be as clipMarkers,
+  Bt as clockText,
+  ye as collectAtlasPages,
+  Vm as colliderColor,
+  lo as collisionFromTiled,
+  ca as countHitches,
+  Ya as createCollisionGrid,
+  za as createMover,
+  Pt as currentOrientationKind,
+  $a as decodeSnapshotFrame,
+  ei as decodeUpdates,
+  c as defineComponent,
+  d as defineFields,
+  ia as describeError,
+  Nt as detectTouch,
+  Up as ditherCovered,
+  Hr as dragSlop,
+  Ym as drawColliders,
+  Tm as dueParticles,
+  Re as duplicateFrames,
+  W as easeByName,
+  tr as elementVolumeLocked,
+  oi as encodeSnapshotFrame,
+  ri as encodeUpdates,
+  g as engineSettings,
+  dt as enterFullscreen,
+  S as entityIndex,
+  St as exitFullscreen,
+  Ft as exitPointerLock,
+  $p as extractStrings,
+  Q as fillSolid,
+  fp as findPath,
+  R as fitScale,
+  sp as floodFill,
+  ht as followReducedMotion,
+  qp as formatMessage,
+  ke as frameNamed,
+  ut as fullscreenSupported,
+  po as gidOf,
+  sa as gpuName,
+  zt as gradeAt,
+  xa as guardRender,
+  ir as hasTakes,
+  Kt as hash01,
+  Bo as hitStopMs,
+  Ho as hurtFlashGapMs,
+  Go as hurtFlashMs,
+  Yo as inView,
+  Ia as inspectWorld,
+  ne as installLabelFont,
+  Tt as isFullscreen,
+  rp as isOpen,
+  Mt as isPointerLocked,
+  Za as isSolidTile,
+  ot as isTouchUi,
+  zr as keptTarget,
+  Jr as keyLabel,
+  Qr as keymapStorage,
+  ao as layerByName,
+  cm as lerpColor,
+  Ye as loadAseprite,
+  _t as lockOrientation,
+  da as looksThrottled,
+  na as maxTextureSize,
+  $r as mergeKeymap,
+  vm as mergeTileRects,
+  Lp as migrateSave,
+  Ht as mixRgb,
+  Zt as mixToWhite,
+  Xa as moveX,
+  ja as moveY,
+  Oi as moverFromWire,
+  Fi as moverToWire,
+  $o as music,
+  tp as navGrid,
+  mp as navGridFromCollision,
+  pp as nearWallCost,
+  ip as nearestOpen,
+  Zr as nearestTarget,
+  oa as noteContextLoss,
+  fi as noteServerTime,
+  io as objectsOf,
+  np as octile,
+  pt as onAppResume,
+  At as onFullscreenChange,
+  It as onPointerLockChange,
+  yt as onReducedMotionChange,
+  _o as overlay,
+  om as parallaxOrigin,
+  Ne as parseAseprite,
+  Oe as parseAtlas,
+  Pr as parseChord,
+  xo as parseTiled,
+  nm as particleBudget,
+  Sa as percentile,
+  Gm as physicsSystem,
+  Xr as pickTarget,
+  rm as placeAxis,
+  Pe as planAtlas,
+  Im as polygonCentroid,
+  bm as polygonShape,
+  Rt as prefersReducedMotion,
+  ti as quantizeUpdates,
+  lp as reachedCount,
+  ra as rebuildDelayMs,
+  wo as recoilAt,
+  Ko as recoilPx,
+  hi as reconnectDelay,
+  pr as registerSounds,
+  xr as registerTakes,
+  km as regularPolygon,
+  cr as renderRecipe,
+  bt as requestPointerLock,
+  si as resetServerClock,
+  Le as resolveUrl,
+  ft as rumble,
+  st as rumblePad,
+  nt as rumbleParams,
+  N as runDue,
+  dm as sampleColor,
+  Sm as sampleCurve,
+  Am as sampleRange,
+  Cm as scaleCount,
+  gm as seededRandom,
+  ni as serverNow,
+  li as serverOffset,
+  rt as setNativeShell,
+  tt as setTouchOverrideKey,
+  yi as shouldReconnect,
+  dp as simplifyPath,
+  we as sliceAt,
+  Ke as sliceBorders,
+  Ue as sliceNamed,
+  $ as solidSilhouette,
+  qo as sound,
+  Jp as sourceText,
+  tm as spanVisible,
+  Gr as spotReach,
+  wr as spotShare,
+  Pm as spreadAngle,
+  qa as stepMover,
+  yr as stickActive,
+  Rr as stickToAxis,
+  Or as stickVector,
+  lt as stopRumble,
+  Sp as straightenPath,
+  ua as summarizeFrames,
+  Km as syncToBody,
+  u as system,
+  De as tagDirection,
+  Be as tagFrames,
+  He as tagRepeat,
+  fo as tileAt,
+  Dm as tileBodies,
+  Bm as tileBodiesFromGrid,
+  so as tileRect,
+  it as timeoutSignal,
+  Gt as tintNight,
+  Ct as toggleFullscreen,
+  Mp as transitionTo,
+  Pa as trimStack,
+  bp as tweenDone,
+  Et as unlockOrientation,
+  Eo as upperOver,
+  ta as watchContextLoss,
+  Ut as weatherAt,
+  Wp as wipeLevel,
+  O as worldZoom,
+  mm as wrap,
+  F as zoomResolution,
+  M as zoomSteps
+};

package/dist/ambient/ColorGrade.js

@@ -0,0 +1,40 @@
+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
+};

package/dist/ambient/DayClock.js

@@ -0,0 +1,56 @@
+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
+};

package/dist/ambient/WeatherLayer.js

@@ -0,0 +1,90 @@
+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
+};

package/dist/ambient/grade.js

@@ -0,0 +1,12 @@
+function c(t, a, o = 0.14) {
+  const n = Math.max(0, Math.min(1, a));
+  return { color: t.color, alpha: Math.max(0, Math.min(o, t.day + (t.night - t.day) * n)) };
+}
+function i(t, a) {
+  const o = Math.max(0, Math.min(1, a)), n = (h) => Math.round(255 - (255 - (t >> h & 255)) * o) << h;
+  return n(16) | n(8) | n(0);
+}
+export {
+  c as gradeAt,
+  i as mixToWhite
+};