@adatechnology/game-fluids 0.1.8 → 0.2.1

package/README.md

@@ -8,8 +8,8 @@ Engine-agnostic liquids for games, with no renderer. It knows nothing about any
 - **Streams**: the jet leaving a lip or a hole. Ballistic, it ends on the first surface it hits (planes with half extents) or on the ground.
 - **Stains**: grow from a flow front (16 radial samples, never a perfect disc), run downhill, soak into porous surfaces, dry from the edge in and
   either vanish or leave a permanent mark (coffee, blood, oil).
-- **19 built-in liquids** (`LIQUIDS`): water, coffee, tea, milk, soda, juice, beer, wine, spirits, fuel, diesel, motor_oil, cooking_oil, blood,
-  sap, acid, paint, bleach, honey. Each one has its own colour, viscosity, drying time, gloss and drink effects (`caffeine`, `alcohol`, `poison`,
+- **21 built-in liquids** (`LIQUIDS`): water, coffee, tea, milk, soda, juice, beer, wine, spirits, fuel, diesel, motor_oil, cooking_oil, blood,
+  old_blood, bile, sap, acid, paint, bleach, honey. Each one has its own colour, viscosity, drying time, gloss and drink effects (`caffeine`, `alcohol`, `poison`,
   `disgust`).
 - **Item uses** (`ITEM_USES`): scripted `sip`, `drink`, `chug`, `pour`, `pour_out`, `open` and `close`, as pure keyframe data plus a player.
 - Deterministic from a seed (no `Math.random`), so a LAN host can run it and send events. `serialize()` / `load()` round trip the whole world.
@@ -88,15 +88,23 @@ While on it is a `tap` stream (`streams()` lists it with `tap: <id>`): it fills
 into a cup) and otherwise makes a stain where it lands. Switching emits `{ type: 'tap', tap, on }`. `taps()` returns the state of every tap, and
 taps are part of `serialize` / `load`.
 
+### The team's values as defaults
+
+Blood dries in 600 s and leaves a `0x3B1D14` mark, `old_blood` (`0x6C1C16` drying to `0x2A160E`, 360 s) and `bile` (`0x8A9A2A` to `0x3E4220`, 900 s)
+come from the Padrão de Fluidos, fuel evaporates in 60 s without a mark and water takes 180 s (the Oficina de VFX rule table). A game that wants other
+values replaces a liquid by id: `createFluids({ liquids: [{ ...LIQUIDS.find((l) => l.id === 'blood')!, dryTime: 1200, stainColor: 0x4a0506 }] })`.
+`splash(liquid, point, liters, velocity, { tint: { fresh, dry } })` colours one splash (and the stain it makes or joins; the latest tint wins) without
+touching the liquid: the age of an infection is the characters' data, not fluids'.
+
 ### Using it with `@adatechnology/game-destruction`
 
 The damage model reports `leak` events for parts that hold a fluid. Map them one to one onto `puncture`; the container then loses liquid by
 Torricelli and the stream and stains follow:
 
 ```ts
-import type { DamageEvent } from '@adatechnology/game-destruction'
+import type { DestructionEvent } from '@adatechnology/game-contracts'
 
-destruction.on('leak', (e) => {
+destruction.on('leak', (e: Extract<DestructionEvent, { type: 'leak' }>) => {
   // e.part is the damaged part, e.point the world hit point of the hole, e.direction where the fluid leaves
   const id = containerOfPart(e.part)
   if (!id) return
@@ -133,14 +141,38 @@ While the current key has `action: 'drink'` the player calls `world.drink(rate
 hand ∘ pose; otherwise the host animates its own viewmodel from `pose()`. `def.liquids` restricts the use to some liquids. Write your own
 `ItemUseDef` to add `eat`, `wipe` and so on.
 
+### Running film (the Fluid Standard)
+
+The stain above is an outline. The film is the other model, a literal port of the Fluid Standard's film (F60-114): a grid of 1.25 cm cells
+that holds a thickness in mm and a dryness per cell. A drop lands as an impact stretched by `1 / sin(angle)` with spikes, satellites and
+tails; a 180 Hz thin-film step (at most 6 per frame, limited to the wet box) makes rivulets with a bulb at the tip, runs down the slope and
+over the curb; it dries from the thin edge in. Drips, continuous sources and drag smears are included. It never calls `Math.random`: give it
+the stream, so a LAN client with the same seed draws the same film.
+
+```ts
+import { PADRAO_LAYOUT, createFilm, createFilmLcg, filmProfileOf } from '@adatechnology/game-fluids'
+
+const film = createFilm({ layout: PADRAO_LAYOUT, profile: filmProfileOf('blood')!, random: createFilmLcg(1) })
+film.launch([-0.25, 1.3, 0.75], [0.5, 0.2, -6], 2) // position, velocity (m/s), radius in mm
+film.sources.push({ row: 250, column: 120, rate: 240, elapsed: 0, duration: 20, radius: 3 })
+// every frame; dryingSeconds is the simulation clock (a game scales it)
+film.update({ dt, dryingSeconds: dt })
+film.setWeather({ rain: 1 }) // drying stops, spread x1.5 (a no-op until game-weather drives it)
+```
+
+- **Layouts:** `PADRAO_LAYOUT` (256 x 396, wall, sidewalk, curb, road), `WORKSHOP_LAYOUT` (160 x 448), `createFoldedLayout` for your own, and `layoutFromSurfaces({ floor, wall?, curb?, center })`, which builds the fold from your `SurfaceSpec`s (a 160 x 160 patch of 2 x 2 m by default).
+- **Profiles** (`data/film-profiles.json`, `FILM_PROFILES`, `filmProfileOf(id, overrides)`): `blood`, `old_blood`, `bile`, `motor_oil`, `fuel`. `spikes` (bile 0.3: short spikes, thick blobs; 1 = the Standard's), `landsAsBlob` (oil and fuel land as one blob) and `maxAmount` are the Workshop's variants and the defaults.
+- **Simulator:** `FilmSimulator` is the interface of the flow and drying step. The CPU version (`createCpuSimulator`) is the reference the goldens are recorded from; pass `options.simulator` to swap in a GPU one.
+
 ## API
 
 | Export | What it is |
 |---|---|
 | `createFluids(options?)` | Creates a `FluidWorld`. Options: `liquids`, `locale`, `seed`, `ambientC`, `gravity`, `groundAt(x, z)`, `mergeDistance`, `maxStains`, `onEvent` |
-| `LIQUIDS` | The 19 built-in `LiquidDef`s (`id`, `color`, `opacity`, `stainColor`, `viscosity`, `density`, `dryTime`, `leavesMark`, `gloss`, `drink`...) |
+| `LIQUIDS` | The 21 built-in `LiquidDef`s (`id`, `color`, `opacity`, `stainColor`, `viscosity`, `density`, `dryTime`, `leavesMark`, `gloss`, `drink`...) |
 | `ITEM_USES` | The built-in `ItemUseDef`s |
 | `createItemUse(world, containerId, def, getHandTransform?)` | Returns an `ItemUsePlayer` (`pose()`, `update(dt)`, `cancel()`, `time`, `done`) |
+| `createFilm(options)`, `createFilmLcg(seed)`, `PADRAO_LAYOUT`, `WORKSHOP_LAYOUT`, `layoutFromSurfaces`, `createFoldedLayout`, `FILM_PROFILES`, `filmProfileOf` | The running film (see above) |
 | `sampleStream(stream, gravity, t)` | Point of a stream's path at time `t` (0 to `flightTime`) |
 | `stainDirection(stain, i)`, `STAIN_SAMPLES` | World direction of the front sample `i` of a stain (16 samples) |
 | `describeEvent(strings, event)`, `resolveStrings(locale)`, `locales` | Localised event text and liquid names |
@@ -156,6 +188,8 @@ integers; density is in kg/m³ and viscosity is relative to water. The surface i
 
 ## Português
 
+> Filme que escorre (Padrão de Fluidos): `createFilm({ layout, profile, random })` simula uma película com espessura em células de 1,25 cm (respingo por ângulo, escorrer, pingar, fontes, arrasto, secar pela borda), com `PADRAO_LAYOUT`, `WORKSHOP_LAYOUT` e `layoutFromSurfaces`. Veja a seção "Running film" acima; `film.setWeather({ rain })` é o gancho do clima.
+
 Líquidos sem renderizador, para qualquer engine: copos, garrafas, galões e tanques com nível calculado pelo formato e pela inclinação,
 temperatura (esfria e solta vapor), beber, despejar, derramar ao inclinar e vazar por furos (ligue os eventos `leak` do
 `@adatechnology/game-destruction` em `fluids.puncture`). O líquido que cai vira mancha: cresce a partir de uma frente de fluxo (nunca um disco

package/dist/index.d.ts

@@ -40,6 +40,15 @@ interface LiquidDef {
     };
     tags?: string[];
 }
+/** Colours of one splash: the wet film (`fresh`) and what it dries to (`dry`). A game uses it for what the liquid depends on (the age of an infection) while the liquid stays generic. */
+interface StainTint {
+    fresh: number;
+    dry: number;
+}
+interface SplashOptions {
+    /** Overrides the colours the liquid's definition gives the stain this splash makes (or joins; the latest tint wins). */
+    tint?: StainTint;
+}
 interface ContainerState {
     id: string;
     liquid: LiquidId | null;
@@ -149,6 +158,8 @@ interface StainState {
     mark?: boolean;
     /** Seconds since the stain was created. */
     age?: number;
+    /** The colours of the splash that made it, when it was given a `tint`. */
+    tint?: StainTint;
 }
 type FluidEvent = {
     type: 'fill';
@@ -276,8 +287,8 @@ interface FluidWorld {
     /** Remove a tap (and end its stream). */
     removeTap(id: string): void;
     taps(): TapState[];
-    /** Pour liquid straight onto a point (a broken bottle, a blood splash). */
-    splash(liquid: LiquidId, point: Vec3, liters: number, velocity?: Vec3): void;
+    /** Pour liquid straight onto a point (a broken bottle, a blood splash). `options.tint` colours the stain for this splash only. */
+    splash(liquid: LiquidId, point: Vec3, liters: number, velocity?: Vec3, options?: SplashOptions): void;
     /** Wipe or burn stains in a radius (fire dries water and burns fuel stains). */
     clearStains(point: Vec3, radius: number): void;
     update(dt: number): FluidEvent[];
@@ -350,4 +361,339 @@ declare const ballistic: (origin: Vec3, velocity: Vec3, gravity: number, t: numb
 /** Point of a stream's path `t` seconds after its origin (use with `StreamState.flightTime` and the world's `gravity`). */
 declare const sampleStream: (stream: Pick<StreamState, "origin" | "velocity">, gravity: number, t: number) => Vec3;
 
-export { type ContainerState, type FluidEvent, type FluidLocale, type FluidOptions, type FluidStrings, type FluidWorld, type HandTransform, ITEM_USES, type ItemUsePlayer, LIQUIDS, type LiquidDef, SAMPLES as STAIN_SAMPLES, type StainState, type StreamCause, type StreamState, type SurfaceSpec, type TapSpec, type TapState, ballistic, createFluids, createItemUse, describeEvent, locales, resolveStrings, sampleStream, stainDirection };
+/** A seeded source of numbers in [0, 1). The film never calls `Math.random`: the host owns the stream, so a replay gets the same film. */
+type FilmRandom = () => number;
+/** Which shader branch draws the liquid (the pages' `uFl`: blood 0, bile 2, oil 3, fuel 4). */
+type FilmLook = 'blood' | 'bile' | 'oil' | 'fuel';
+/** Colours are `0xRRGGBB` integers, thickness is in millimetres (one cell holds that much film). */
+interface FilmProfile {
+    id: LiquidId;
+    look: FilmLook;
+    /** Flow rate of the thin-film step. */
+    flow: number;
+    /** Thickness that stays behind when the film runs (scaled per cell by the layout's pinning noise). */
+    pin: number;
+    /** Thickness a dry cell needs to be wetted: it makes the bulb at the tip of a rivulet. */
+    front: number;
+    referenceThickness: number;
+    /** Largest bed height difference the flow sees across one edge. */
+    slopeCap: number;
+    /** Seconds a thin film takes to dry (0 = never). */
+    dryTime: number;
+    /** Thickness lost per second at the edge (fuel). */
+    evaporation: number;
+    opacityRate: number;
+    reflectance: number;
+    normalScale: number;
+    thin: number;
+    thick: number;
+    dry: number;
+    dryThin: number;
+    dropColor: number;
+    dropOpacity: number;
+    /** Volume factor of a landing drop. */
+    volume: number;
+    /** 1 = the Fluid Standard's long spikes and satellites; below 1 = short spikes and thicker blobs (bile in the Workshop). */
+    spikes: number;
+    /** A drop of this liquid lands as one rounded blob instead of an impact splash (oil and fuel in the Workshop). */
+    landsAsBlob: boolean;
+    /** Cap of the thickness a landing drop deposits at its centre. */
+    maxAmount: number;
+    sources?: Record<string, string>;
+}
+/** The plane of one folded strip of the grid: cell `(row, column)` sits at `origin + column * columnAxis * cell + (row - firstRow) * rowAxis * cell`. */
+interface FilmRegion {
+    id: string;
+    firstRow: number;
+    rowCount: number;
+    origin: Vec3;
+    columnAxis: Vec3;
+    rowAxis: Vec3;
+    /** Unit normal pointing out of the surface (towards the air). */
+    normal: Vec3;
+    /** True for walls and curb faces: the film runs sideways more slowly and keeps less behind. */
+    isVertical: boolean;
+}
+/** Where a drop hit a region, in grid terms. `along` is the travel direction on the surface in (column, row) axes; `normalSpeed` is the speed into the surface. */
+interface FilmImpact {
+    row: number;
+    column: number;
+    along: [number, number];
+    normalSpeed: number;
+}
+/** The rules that differ between the Fluid Standard and the Workshop (and between host scenes). */
+interface FilmRules {
+    /** Drops in flight at once (the ring is reused, oldest overwritten). */
+    dropCapacity: number;
+    /** A drop falling past the curb edge lands on the curb face. */
+    curbCatch: boolean;
+    /** A drop below the sidewalk height only counts as on the sidewalk when it is in front of the wall. */
+    guardBehindWall: boolean;
+    /** Drops landing beyond the end of the road strip are ignored. */
+    clipRoadEnd: boolean;
+    /** Drops that leave this box are dropped (x and z limits). */
+    escapeBox?: {
+        minX: number;
+        maxX: number;
+        maxZ: number;
+    };
+    /** How the drip draws its bead and jitter: the Standard's formulas or the Workshop's. */
+    dripStyle: 'padrao' | 'workshop';
+}
+interface FilmLayout {
+    id: string;
+    width: number;
+    height: number;
+    /** Metres per cell. */
+    cellSize: number;
+    /** Bed height of each cell in mm (what the film runs down), pinning factor and 1/0.95 vertical flag. */
+    bed: Float32Array;
+    pin: Float32Array;
+    vertical: Float32Array;
+    regions: readonly FilmRegion[];
+    rules: FilmRules;
+    /** World position of a (possibly fractional) cell centre-corner. */
+    cellToWorld(row: number, column: number): Vec3;
+    /** Which region a drop that moved from `previous` to `position` hit (`-1` = none). May snap `position` onto the surface. */
+    collide(previous: Vec3, position: Vec3): number;
+    impact(region: number, position: Vec3, velocity: Vec3): FilmImpact;
+    /** Whether a landing point is on the strip (inside its width and, for the Standard, before the end of the road). */
+    contains(position: Vec3): boolean;
+    /** Whether a drop that hit nothing has left the area for good. */
+    escaped(position: Vec3): boolean;
+}
+/** The grids a film simulates. Flat arrays, `row * width + column`. */
+interface FilmField {
+    readonly width: number;
+    readonly height: number;
+    /** Thickness in mm. */
+    readonly thickness: Float32Array;
+    /** Dryness 0..1. */
+    readonly dryness: Float32Array;
+    /** Wet-ground mark 0..1 (gasoline darkens the ground while its film evaporates). */
+    readonly dampness: Float32Array;
+}
+interface FilmBounds {
+    firstRow: number;
+    lastRow: number;
+    firstColumn: number;
+    lastColumn: number;
+}
+interface FilmAdvanceInput {
+    /** Seconds of real time since the last call. */
+    dt: number;
+    /** Seconds of drying clock that pass in `dt` (simulation time, scaled by the host). */
+    dryingSeconds: number;
+}
+/** Steps and dries the film. The CPU version is the reference golden; a GPU version can replace it behind the same interface. */
+interface FilmSimulator {
+    /** Wet bounding box used by the last advance (`lastRow < 0` = nothing wet). */
+    readonly bounds: FilmBounds;
+    /** Recompute the wet bounding box. Call it after anything wrote to the field outside `advance`. */
+    refreshBounds(): void;
+    /** Runs the flow steps the elapsed time owes (at most `maxSteps`) and the drying. Returns the steps run. */
+    advance(input: FilmAdvanceInput): number;
+    /** Drops the leftover step time (a new scene). */
+    resetClock(): void;
+}
+interface FilmDrip {
+    /** World point of the dripping fingertip, moved by the host each frame. */
+    position: Vec3;
+    /** Seconds to the next drop: `every` is the current wait and `base` the average. */
+    every: number;
+    base: number;
+    elapsed: number;
+    /** Drop radius in mm. */
+    radius: number;
+}
+interface FilmBead {
+    visible: boolean;
+    position: Vec3;
+    /** Radius in mm of the swelling bead. */
+    radius: number;
+    /** 0..1 of the way to detaching. */
+    swell: number;
+}
+interface FilmSource {
+    row: number;
+    column: number;
+    /** Thickness added per second. */
+    rate: number;
+    /** Seconds since the start (may start negative to delay it). */
+    elapsed: number;
+    duration: number;
+    /** Radius in cells the deposit scatters over. */
+    radius: number;
+}
+interface FilmDrag {
+    elapsed: number;
+    duration: number;
+    /** Half width in cells. */
+    width: number;
+    amount: number;
+    /** One load factor per half-cell across the width (`width * 4 + 1` of them). */
+    stripes: number[];
+    path(progress: number): {
+        row: number;
+        column: number;
+    };
+    /** Throws drops from the moving hand: `height` is the world y they start at, `speed` the travel speed. */
+    hand?: {
+        height: number;
+        speed: number;
+    };
+    done: boolean;
+}
+interface FilmDropState {
+    /** Number of slots (the ring). */
+    readonly capacity: number;
+    /** Drops launched since the pool was made. */
+    readonly launched: number;
+    readonly active: Uint8Array;
+    /** x, y, z per slot. */
+    readonly position: Float64Array;
+    readonly velocity: Float64Array;
+    /** Radius in mm. */
+    readonly radius: Float64Array;
+}
+interface FilmWeather {
+    /** 0..1. While it rains drying stops and the film spreads 1.5 times faster. */
+    rain: number;
+}
+interface FilmOptions {
+    layout: FilmLayout;
+    profile: FilmProfile;
+    random: FilmRandom;
+    /** Flow steps per second of real time (default 180). */
+    stepRate?: number;
+    /** Most steps in one advance (default 6). */
+    maxSteps?: number;
+    /** Replace the CPU simulator, for a GPU version. */
+    simulator?: (field: FilmField, layout: FilmLayout, profile: () => FilmProfile, options: {
+        stepRate: number;
+        maxSteps: number;
+        weather: () => FilmWeather;
+    }) => FilmSimulator;
+}
+interface Film {
+    readonly layout: FilmLayout;
+    readonly field: FilmField;
+    readonly drops: FilmDropState;
+    readonly bead: FilmBead;
+    readonly simulator: FilmSimulator;
+    profile: FilmProfile;
+    drip: FilmDrip | undefined;
+    readonly sources: FilmSource[];
+    readonly drags: FilmDrag[];
+    /** Throw a drop of `radius` mm from `position` with `velocity`. */
+    launch(position: Vec3, velocity: Vec3, radius: number): void;
+    /** The impact splash: a body stretched by `1 / sin(angle)`, spikes, satellites and tails. `row`/`column` and `size` are in cells. */
+    splat(row: number, column: number, size: number, directionColumn: number, directionRow: number, sinAngle: number, amount: number): void;
+    /** A filled ellipse with a noisy outline. */
+    blob(row: number, column: number, along: number, across: number, directionColumn: number, directionRow: number, amount: number, roughness: number): void;
+    /** A tapered stroke between two cells. */
+    stroke(fromRow: number, fromColumn: number, toRow: number, toColumn: number, startWidth: number, endWidth: number, amount: number): void;
+    deposit(row: number, column: number, amount: number): void;
+    /** One frame: drops, drip, sources, drags, then the flow steps and the drying. */
+    update(input: FilmAdvanceInput): void;
+    setWeather(weather: Partial<FilmWeather>): void;
+    weather(): FilmWeather;
+    /** Empties the film, drops, drip, sources and drags. The ring cursor and the leftover step time stay, as in the pages. */
+    clear(): void;
+    /** Number of cells above the visible thickness (0.035 mm). */
+    wetCells(): number;
+}
+
+/**
+ * A running film of one liquid over one layout: drops land as impacts, a drip, sources and drag smears add to it, and a 180 Hz
+ * thin-film step spreads it limited to the wet box, at most `maxSteps` per frame. It never calls `Math.random`: the host gives the random stream.
+ */
+declare function createFilm(options: FilmOptions): Film;
+
+type FilmLcg = FilmRandom & {
+    seed: number;
+};
+/** The Fluid Standard's generator (LCG 1664525 / 1013904223). `seed` can be read and set, so a scene can be restarted from a number. */
+declare function createFilmLcg(seed: number): FilmLcg;
+
+interface FoldedLayoutParams {
+    id: string;
+    columns: number;
+    /** Metres per cell. */
+    cellSize: number;
+    /** World x of the left edge. */
+    originX: number;
+    wallRows: number;
+    sidewalkRows: number;
+    curbRows: number;
+    roadRows: number;
+    /** World y of the top of the wall strip and of the sidewalk and road planes. */
+    wallTopY: number;
+    sidewalkY: number;
+    roadY: number;
+    /** World z of the wall plane (the sidewalk starts here and runs towards +z). */
+    wallZ: number;
+    /** Metres the curb face drops per row. Default `(sidewalkY - roadY) / curbRows`. */
+    curbStep?: number;
+    /** x that the road's cross slope is measured from (the road falls `5 mm / m` towards +x from here). */
+    roadSlopeAnchorX: number;
+    rules: FilmRules;
+}
+/**
+ * One strip folded over a wall, the sidewalk in front of it, the curb face and the road: the Fluid Standard's grid (F12-42) and the
+ * Workshop's (W562-582) are two settings of it. Bed height (mm), pinning noise and the vertical flag are filled per cell.
+ */
+declare function createFoldedLayout(params: FoldedLayoutParams): FilmLayout;
+/** The Fluid Standard's grid: 256 x 396 cells of 1.25 cm over a 1.95 m wall, a 1.6 m sidewalk, a 15 cm curb and a 1.4 m road. */
+declare const PADRAO_LAYOUT: FilmLayout;
+/** The Workshop's grid: 160 x 448 cells (wall 160, sidewalk 128, curb 9, road 151) at the foot of the workshop's wall. */
+declare const WORKSHOP_LAYOUT: FilmLayout;
+
+interface SurfaceLayoutOptions {
+    /** The surface the film lies on (a floor, a table, a ramp). */
+    floor: SurfaceSpec;
+    /** A wall that meets the floor: the film folds up it, so a splash on the wall runs down onto the floor. */
+    wall?: SurfaceSpec;
+    /** The lower surface beyond the floor's far edge: the film folds down a curb face to it. Needs the wall or the floor's tangent to say where the edge is. */
+    curb?: SurfaceSpec;
+    /** World point the grid is centred on (sideways; and along the floor when there is no wall). */
+    center: Vec3;
+    /** Cells across (default 160: 2 m of 1.25 cm cells, the grid of the near-player manager). */
+    columns?: number;
+    /** Cells along all strips together (default 160). */
+    rows?: number;
+    /** Metres per cell (default 0.0125). */
+    cellSize?: number;
+    /** Rows of the wall strip (default 48 with a wall, else 0) and cap of the curb face rows (default 12). */
+    wallRows?: number;
+    curbRows?: number;
+}
+/**
+ * Builds the folded grid from the host's surfaces: `wall` (optional) hangs above the fold line, `floor` runs away from the wall, and
+ * `curb` (optional) is the lower surface the floor drops to over a curb face. Without a wall the grid is a flat patch of the floor around `center`.
+ * Bed heights come from world y, so a tilted floor makes the film run downhill.
+ */
+declare function layoutFromSurfaces(options: SurfaceLayoutOptions): FilmLayout;
+
+/** Film profiles of the liquids that run as a film (F46-55, plus the Workshop's `spikes` and `landsAsBlob`). Data in `data/film-profiles.json`. */
+declare const FILM_PROFILES: FilmProfile[];
+/** The profile of a liquid with the given overrides, or undefined when the liquid has no film. */
+declare function filmProfileOf(id: LiquidId, overrides?: Partial<FilmProfile>): FilmProfile | undefined;
+
+interface CpuSimulatorOptions {
+    /** Flow steps per second of real time (the pages use 180). */
+    stepRate: number;
+    /** Most flow steps in one advance (6 in the Fluid Standard, 9 in the Workshop). */
+    maxSteps: number;
+    weather: () => FilmWeather;
+}
+/**
+ * The thin-film step of the Fluid Standard (F94-114), literal: only film above the pin moves, a dry cell needs the front thickness,
+ * walls run sideways at 0.22 and the flow is limited to the wet bounding box. Drying starts from the thin edge.
+ */
+declare function createCpuSimulator(field: FilmField, layout: FilmLayout, profileOf: () => FilmProfile, options: CpuSimulatorOptions): FilmSimulator;
+
+declare function hashCell(x: number, y: number): number;
+declare function valueNoise(x: number, y: number): number;
+
+export { type ContainerState, FILM_PROFILES, type Film, type FilmAdvanceInput, type FilmBead, type FilmBounds, type FilmDrag, type FilmDrip, type FilmDropState, type FilmField, type FilmImpact, type FilmLayout, type FilmLcg, type FilmLook, type FilmOptions, type FilmProfile, type FilmRandom, type FilmRegion, type FilmRules, type FilmSimulator, type FilmSource, type FilmWeather, type FluidEvent, type FluidLocale, type FluidOptions, type FluidStrings, type FluidWorld, type FoldedLayoutParams, type HandTransform, ITEM_USES, type ItemUsePlayer, LIQUIDS, type LiquidDef, PADRAO_LAYOUT, SAMPLES as STAIN_SAMPLES, type SplashOptions, type StainState, type StainTint, type StreamCause, type StreamState, type SurfaceLayoutOptions, type SurfaceSpec, type TapSpec, type TapState, WORKSHOP_LAYOUT, ballistic, createCpuSimulator, createFilm, createFilmLcg, createFluids, createFoldedLayout, createItemUse, describeEvent, filmProfileOf, hashCell, layoutFromSurfaces, locales, resolveStrings, sampleStream, stainDirection, valueNoise };