·
scene · drop-in viewer
What it does
No description provided yet.
Interface
What this asset declares: the schema it conforms to, what it exposes, and the rendered structured payload.
This asset doesn't declare a schema or structured payload.
Sub-parts
Everything contained inside this part. Assets are composite children (clickable cards). Files are leaf payloads. Expand any row to view its source.
42items
# sillage_core
<!-- zero:scaffolded-readme -->
<!-- Replace the line below with what this module provides and who
consumes it, then delete both comment lines. -->
TODO: describe this module.
▲ 0↑ born
# sillage_economy
Stock, the ledger, the season, and the still — everything in *Sillage* that
makes a formula cost something.
A perfume is a spend. Every drop comes out of a bottle that has a bottom, and
every bottle was bought or made. This module owns the three francs-and-grams
facts the rest of the game reads: how much of a material is left, what it
costs today, and how the fields and the alembic put more of it in the
cupboard.
## What it provides
| | |
|---|---|
| `Economy.stockOf(id)` | grams left of a material |
| `Economy.dropsOf(id)` | the same, counted the way a perfumer counts |
| `Economy.spend(id, drops)` | draw a dose down; `false` when the bottle is empty. A negative count puts it back |
| `Economy.priceOf(id)` | francs per gram **this season** |
| `Economy.buy(id, grams)` | `ok, message`; refuses what the trade does not sell |
| `Economy.formulaCost(f)` | what a formula costs to pour |
| `Economy.stockValue()` | what the whole cupboard is worth today |
| `Economy.season()` | the month, its note, what is in season, and the baskets |
| `Economy.distil(lot, process)` | take a basket to the apparatus |
| `Economy.settle(verdict)` | pay the fee or take the loss, and turn the calendar |
| `Economy.openLedger()` / `openStill()` / `close()` | the two pages |
| `Economy.figure(n, dec)` | a number set the French way: `1 234,50` |
It emits `stock:changed` whenever any of that moves, and owns
`Core.state.francs`, `Core.state.reputation` and `Core.state.stock`.
Material **prices and behaviour** come from `sillage_sim`, keyed on the same
`id` as `Core.catalogue`; the table here is only the fallback if the sim is
not loaded.
## The season
Six harvests, one per commission, from February 1954 to December 1955.
Mimosa comes down from the Tanneron in February, the rose is cut in May, the
jasmine is picked at four in the morning in August, the iris root is lifted
in October. What is in season is cheap; what is out of it is dearer, and the
ledger marks it with a dagger.
## The still
Two materials — **ambergris tincture** and **civet tincture** — are not sold
in Grasse at any price. The only way to have them is to make them, from what
the season put in the baskets, at the copper alembic on the right of the
room. That is the private palette: not a bonus, the only route.
Each basket wants one of three apparatus, and the wrong one costs the same
and gives back about a fifth. Bark, leaf and root take the steam; a fragile
flower is killed by it and goes to the fat; animal matter and moss are left
cold in alcohol. The rubric at the foot of the page says so.
## World content
The alembic on its raised hearth at `Core.anchors.still`, framed by the
`still` camera station, and the season's harvest baskets on the floor by the
window at `Core.anchors.baskets`. Both are rebuilt when the calendar turns,
so the room shows what month it is before any page is opened. Surfaces come
from the `econ_*` materials beside this module.
▲ 0↑ born
# sillage_presentation
The authored screens of *Sillage*, and the house style every other sheet in the
game borrows from: French pharmacy printing, 1954 — iron-gall ink on aged rag
paper, a period face set with real letter-spacing, small caps, hairline and
double rules, and a printed border round each plate. Two ink colours: the
iron-gall browns (`Core.ink.black` / `.text` / `.faded` / `.ghost`, one pot at
four strengths) and the correction red (`Core.ink.red`).
Every plate is composed down the 3:4 page — 1080 wide, 1440 tall — because
nothing in this game spans the width.
## The screens
| screen | what it is |
|---|---|
| `sillage_title` | the title plate: fleuron, double rule, the name set at 116 pt, the dictionary definition, an engraved flacon with its blotters and its trail, the entry line |
| `sillage_howto` | one card teaching the one idea, with the drydown drawn on it: time running down the log axis `Core.timeToFraction` defines, the brief's target band in ghost ink, an accord in iron gall over it, and two corrections in red where the line leaves the band |
| `sillage_hud` | the standing chrome — a pinned docket at the top left carrying the commission, the francs, the reputation and the way to interrupt. Small, and never fighting the organ for the frame |
| `sillage_pause` | a sheet laid over the shot, with the state of the atelier on it |
| `sillage_end` | the career as a printed record: six ruled rows of commission, client, verdict and fee, a total, the tally, and a stamp struck across the corner |
## What it offers other slices
```lua
local Presentation = require("ui.sillage_presentation")
Presentation.show("title" | "howto" | "end" | <any gameplay screen>)
Presentation.hud(true | false | nil) -- nil returns it to automatic
Presentation.setPaused(true | false)
Presentation.togglePause()
Presentation.pushRecord({ commission = 4, client = "…", verdict = "accepted", fee = 2100 })
Presentation.records()
```
`show` sets `Core.state.screen` and emits `screen:changed`. A name that is not
one of the three plates is gameplay: the plates drop and the HUD comes up.
The career record fills itself from the bus — `brief:issued` supplies the
client, `verdict:given` the verdict and the fee — so a slice that only emits
still gets a printed row. `pushRecord` is there for a slice that would rather
say it directly. Verdicts are read loosely: whichever of `result` / `grade` /
`verdict` / `stamp` / `outcome` is present, and anything reading as *master* /
*refus* / *accept* lands in the right column.
Enter advances a plate; Escape raises and drops the pause sheet. No other key
is claimed.
## How the plates are drawn
**Every vector mark is a `canvas` command list.** The fleuron, the flacon, the
teaching diagram, the reputation lozenges and the career stamp are all lists of
paint commands, engraved once at a comfortable size and re-struck at any other
through `scaleCommands` — points, radii, stroke weights and type scale
together, so a bigger ornament is the same ornament.
**Filled shapes are convex.** The target band on the teaching diagram is laid
down one trapezoid a step rather than as one long ribbon, and the flacon's
silhouette — concave at the neck — is filled as three convex pieces with its
outline stroked over them as a single closed path.
**Paragraphs are set line by line.** Copy arrives as a list of already-broken
lines and becomes a stack of single-line labels, which puts the break points
where a 1954 compositor would have put them and keeps each measure under the
plate's width.
▲ 0↑ born
# sillage_staging
The camera of *Sillage*, and the three moments the game takes it away from
you: the opening, the verdict, and the resolution.
Nothing else in the game moves the camera. Every other slice names a station
and lets this one get there.
## Asking for a station
```lua
Core.emit("station:request", { station = "organ", secs = 1.4, ease = "inOutSine" })
```
`secs = 0` is a cut; anything else is an eased move on rails. A request is
ignored while a scripted sequence is running, so a stray request cannot
interrupt the opening or the resolution.
Staging also follows `screen:changed` on its own — `brief` and `drydown` are
watched from the bench, `organ` from the organ, `still` from the stills, and
the `end` screen from the window — so a slice that only changes the screen
still gets a camera that agrees with it.
## The three moments
**The opening** plays when the slice starts, which is when the world loads.
Roughly twenty seconds, and skippable on Escape, Space or Enter: a creep in
toward the shuttered window while the frame comes up out of black, a drift
along the empty marble, a crane up the six tiers of the organ, and down to the
bench where the first commission is waiting. It emits `opening:done`
`{ skipped }` when it lets go.
**The verdict** is a push in on the card, and the three verdicts do not get
the same one. A masterpiece rises: barely closer, a hand's width higher, on an
open lens, held for nearly four seconds. A refusal closes in low and long and
stops dead in one and a quarter. Accepted sits between them. It fires off
`verdict:given`, reading the grade off whichever field the verdict carries.
**The resolution** is `Staging.finale()`, for the sixth commission. The light
in the room turns over to evening — every light in the atelier, eased across
seven seconds by what kind of light it is rather than by its name, so a flame
under a still gains while the sun goes red and flat — and the camera leaves
the bench for the window, landing on the exact frame the game opened on.
It emits `finale:done`.
## The contract
| | |
|---|---|
| `Staging.goTo(station, secs?, ease?)` | ease to one of `Core.stations`. |
| `Staging.moveTo(shot, secs?, ease?, via?)` | ease to any `{ pos, look, fov }`; `via` bends the path. |
| `Staging.playOpening()` | play the opening again. |
| `Staging.verdict(v)` | the push in for a verdict table. |
| `Staging.finale()` | the resolution. |
| `Staging.caption(title?, sub?)` | a line of display type over the image; `nil` fades it out. |
| `Staging.abort()` | stop whatever is scripted and give the camera back. |
## Two things worth knowing
**Every frame of a move is written to both cameras.** `capture` renders the
scene camera from its AUTHORED pose, so a rails move that drove only the live
camera would photograph from wherever the prototype was left. `Core.cutTo`
makes that promise for a cut; this slice keeps it for every frame in between,
which is why a screenshot taken in the middle of a move is the frame the
player is watching.
**A station and a cinematic view of it are different pictures.** A station is
square on to the work, because a card has to be readable and a vial has to be
clickable. The opening and the resolution use composed variants of the same
stations — angled, lower, with something in the near corner — and they still
report the station they belong to, so nothing else has to know.
▲ 0↑ born
# sillage_composition
The verb of Sillage: working at the perfumer's organ, and striking the blotter.
## What it provides
- **The organ overlay** (`sillage_organ_hotspots`) — a hit target over every
one of the 36 vials, projected from `Core.vialSlot(n)` through the live
camera, so the targets follow the camera wherever staging puts it. A vial
already in the formula wears a red-ink frame and a dose wafer. Down the
left edge, the three phases (Tête / Coeur / Fond) bracket the tiers they
belong to — the organ read as the drydown curve stood upright.
- **The formula card** (`sillage_formula`) — a portrait sheet of aged rag
paper pinned to the bottom of the 3:4 frame. Material names in a chancery
italic, doses in a figures column with dotted leaders, a dose that changed
struck out in red with the new figure written above it, marginal notes,
a thumbnail of the accord's shape, and a total underlined twice. A tab
lowers the sheet so the lowest tiers of the organ can be reached.
- **The bench** — a rack of mouillettes, a pipette on its rest, an inkpot,
a written fiche on a short stack of blanks, and the struck strip with its
stain spreading through it while the drydown runs.
- **The clock** — the 24 hours of wear compressed into
`Core.time.drydownSeconds`.
## API
| | |
|---|---|
| `Composition.addDrop(id, n)` | add or take back drops of a material |
| `Composition.addDropBySlot(slot, n)` | the same, by organ slot 1..36 |
| `Composition.clearFormula()` | empty the fiche, returning stock |
| `Composition.strike()` | dip the blotter and run the drydown |
| `Composition.show()` / `.hide()` | show or hide both screens |
## Events
Emits `formula:changed`, `strip:struck`, `strip:tick`, `strip:done`, and
asks staging for the `bench` station with `station:request`. Listens for
`screen:changed`, `brief:issued` and `station:changed`.
Writes `Core.state.formula` and `Core.state.drydownT`. Reads the curve from
`game.sillage_sim`, meters drops through `game.sillage_economy`, and
highlights vials through `world.sillage_organ` — each guarded, so the loop
still plays when one of them is not there.
## Materials
`game.comp_blotter_paper`, `game.comp_card_paper`, `game.comp_brass`,
`game.comp_walnut`, `game.comp_glass_clear`, `game.comp_stain`.
▲ 0↑ born
# sillage_drydown — the ink curve, the commission, the verdict
Three pages of French pharmacy printing, drawn on one sheet of aged rag paper:
the commission that arrives on the bench, the chromatogram a blotter draws as it
dries, and the client's answer written across the same graph.
## The graph runs DOWN the page
Time flows from the top of the sheet to the bottom on the logarithmic axis
`Core.timeToFraction` defines, so the first twenty minutes take 46% of the page
and the last twenty hours take 22%. A perfume's decisions are made in its top
notes; a linear axis crushes them into a hairline, and this one does not.
Intensity grows to the **right**, in the single unit the sim states: `1.00` is a
full, properly built accord, and a brief's bands are written in the same unit —
which is what lets the player's line and the client's ghosted target share one
scale with no divisor anywhere.
Reading the page, from the bottom of the stack up:
| | |
|---|---|
| **hairlines** | one rule per figure in the time gutter; dotted verticals at fifths of the scale |
| **ghost band** | the brief's target, printed in `Core.ink.ghost` and engraved with hairlines |
| **family bands** | the accord broken into `Core.families`, stacked left to right, coloured by family |
| **ghost edges** | the target's edges re-struck *over* the accord, so a curve that misses is unmistakable |
| **the accord** | a wet ink line — a soft bleed under a crisp nib stroke — drawn progressively |
| **the nib** | where the ink is still wet, while the strip is drying |
| **lozenges** | on the verdict: where each phase actually stood, with a leader back to the band it missed |
The three phases are ruled across the sheet and braced in the right margin, and
once the client has answered, each brace carries that phase's mark.
## The three pages
| screen | layer | shown when |
|---|---|---|
| `sillage_brief` | 150 | a commission arrives (`brief:issued`, or `screen:changed` → `brief`) |
| `sillage_graph` | 140 | a blotter is struck (`strip:struck`, or `screen:changed` → `drydown`) |
| `sillage_verdict` | 160 | the client answers (`verdict:given`, or `screen:changed` → `verdict`) |
They sit above the standing HUD and the formula card — the drydown and the
verdict are modal moments — and below the title and pause screens, which
legitimately take the whole frame.
## The clock
Whoever strikes the blotter owns the clock. A `strip:tick` carrying `t` wins;
`Core.state.drydownT` is taken as a second opinion; and if neither is moving,
the sheet drives itself over `Core.time.drydownSeconds` so a struck strip is
never a frozen page. A real tick takes the wheel back the moment it arrives.
A screen change landing mid-strike does not take the graph away half-drawn: the
strip holds the page until its 24 hours are up, and the ordinary rule resumes.
## The contract
```
listens brief:issued · strip:struck · strip:tick · strip:done
verdict:given · screen:changed
reads Core.state.brief · .curve · .verdict · .drydownT · .commission
emits drydown:dismissed — the player closed the verdict sheet
writes nothing. It draws what the sim decided.
```
From a `Brief` it reads `n`, `client`, `title`, `blurb`, `signoff`, `bands`,
`phaseWords`, `require`, `forbid`, `fee`, `budget`. From a `Curve`,
`samples[i].minutes`, `.norm` (falling back to `.total`), `.byFamily`, plus
`peak` and `notes`. From a `Verdict`, `phases[i].phase/score/remark/measured/
min/max`, `score`, `outcome`, `remarks`. Everything is read defensively: a
field that is not there costs that one mark on the page, never the page.
## Putting a page up directly
```lua
local Drydown = require("ui.sillage_drydown")
Drydown.preview(brief, nil, nil) -- the commission card
Drydown.preview(brief, curve, nil, 0.4) -- the graph, frozen 40% down
Drydown.preview(brief, curve, verdict) -- the client's answer
Drydown.page() -- which page is up, or nil
Drydown.progress() -- 0..1 down the sheet
```
Useful for staging a shot, and for looking at a page without waiting out a
strike.
▲ 0↑ born
# sillage_organ
The perfumer's organ: six tiers of six vials in a walnut case against the back
wall of the atelier, and the object every camera station in *Sillage* comes
back to.
The tiers are ordered by volatility. Citrus stands on the top shelf and is gone
in ten minutes; resins and animalics stand on the bottom and are still on the
skin at midnight. So the organ is the drydown curve stood upright, and reading
it top to bottom is reading the shape of a perfume in time.
## What it builds
Under the slice root `sil_organ`, all of it generated at load:
| | |
|---|---|
| carcass | walnut case — side panels with a bead run, five shelf boards with lipping strips, a thick worktop, a base cabinet with two drawers, a cornice, and a through-peg where each shelf lands in a side panel |
| back | nine tongue-and-groove boards, each set a little differently in depth |
| brass | a retaining rail across every tier with its end brackets, a label holder under every slot, and the drawer pulls |
| labels | one plate per slot, carrying the material's name and its family, cut from a single rasterised sheet of pharmacy printing set in EB Garamond and PT Serif |
| vials | 36 bottles of amber and green glass, each with liquid at its own level, a ground stopper and a brass collar |
| stock | thirty smaller bottles standing in the gaps of the back row |
| worktop | a pipette rack and a brass balance |
| bounce | three short-range warm lights standing for the light coming back off the marble bench |
Geometry, surfaces and the label sheet are made at `build()` time —
`renderer.mesh.create`, `renderer.material.create`, a CPU pixel buffer for the
grain and a rasterised SVG for the labels. Nothing is loaded from a file, so
the organ comes up the same wherever the world is opened.
## What it offers other slices
```luau
local Organ = require("game.sillage_core").slices.organ
Organ.vialEntity(slot) -- the bottle in slot 1..36
Organ.highlight(slot, on) -- hover: it steps out of the rank and warms
```
Every bottle stands exactly on `Core.vialSlot(slot)`, which is the same
geometry the composition slice hit-tests, and the label under it names the
material `Core.bySlot[slot]` says belongs there.
▲ 0↑ born
# sillage_sim
The model that makes a perfume a shape in time, and the only thing in *Sillage*
that decides whether a formula is good.
A perfume here is never judged as a mixture. Every material has a volatility — a
peak and a life — so a formula is a curve that rises, turns and falls, and the
client's brief is a shape drawn on the same axes. Two formulas built from exactly
the same five materials, in different doses, are different objects and get
different answers.
## What it holds
| | |
|---|---|
| `Sim.behaviour[id]` | `peak`, `life`, `power`, `price`, `ceiling` for all 36 catalogue materials |
| `Sim.interactions` | ordered pairs — one material **fixes**, **smothers** or **sours** another |
| `Sim.simulate(formula)` | `{ [id] = drops }` → a `Curve`: 96 samples on the log time axis, per-family breakdown, the perfumer's notes on what happened |
| `Sim.brief(n)` | the *n*th of six commissions — client, letter, target bands, budget, fee |
| `Sim.judge(brief, curve)` | per-phase scores and the client's reply, stamped *chef-d'œuvre*, *accepté* or *refusé* |
Identity and appearance live in `sillage_core` — name, family, vial, colour.
Only **behaviour** lives here, keyed on the same `id`, so the organ, the ledger
and the graph can never disagree about what a material is.
## The units
Intensity is measured against `Sim.reference`: `1.0` is a full, properly dosed
accord, and every brief's bands are written in those units. `Curve.samples[i].norm`
is in them too, so the graph draws the player's line and the ghosted target on one
scale. A drop is `Sim.dropGrams` of the batch, which is how a dose becomes a spend.
## What the other slices call
- **composition** — `Sim.strike(formula)` to get the curve, then emits `strip:done`;
the sim judges and publishes `verdict:given` itself.
- **drydown** — `curve.samples` for the ink line, `sample.byFamily` for the colour
bands underneath, and `Sim.targetBand(brief)` for the ghosted shape printed under it.
- **economy** — `Sim.behaviour[id].price`, `Sim.dropGrams`, `Sim.costOf(formula)`.
- **presentation** — `Sim.stamp[outcome]` for the wording, `Sim.count()` for the
length of a career.
## The six
1. **Mme Colette Vaugirard** — an eau for the morning: bright, then gone.
2. **M. Étienne Barral, gantier** — green, and it must survive the leather.
3. **Mlle Solange Aury** — a rose that lasts from the curtain to supper.
4. **La Maison Duvelleroy** — a chypre, base heavier than the heart.
5. **Le Comte de Rochefort** — an evening thing, largest at midnight.
6. **Maison Perrachon** — *Sillage* itself. The one worth the whole career.
Every one of them can be satisfied by more than one set of materials, and every
one of them can be failed while using exactly the materials it asks for. That is
the point: the brief states the shape, never the recipe.
▲ 0↑ born
# sillage_atelier
The room the whole game happens in, and the light in it.
A perfumer's atelier in Grasse: lime plaster over stone, a terracotta tomette
floor, oiled walnut joinery, a marble bench, beams overhead, and a tall
louvred window in the left wall that is the only way daylight gets in. The
frame is 3:4, so the room is built upward — a 3.6 m ceiling on exposed beams, a
window that reaches for it, and a dado line to give the tall walls a horizon.
The light is one source. A hard warm key rakes in through the shutters along
`Core.lightTravel`; the slats cut it into stripes that fall across the floor
and the far wall; the air between carries a set of visible shafts with dust
hanging in them. Everything else is bounce — a warm return off the lit floor, a
cool one off the marble, and a very low fill so the corners read as dark rather
than empty.
## What it puts in the world
Everything is spawned under the slice root `sil_atelier` by `build(root)`:
the shell and its joinery, the window with its two louvred leaves and the
morning standing behind them, the marble bench, the door, the peg rail of
drying lavender, one directional key, five unshadowed bounce lights, fifteen
shafts of lit air, and sixty motes of dust in them.
It also puts a `bloom`, a `vignette` and a warm `colorGrade` on the frame if
nothing else has — the window is the brightest thing in the game and it wants
to bloom. Those are the scene's look rather than this slice's property, so
they are left standing when the slice is rebuilt.
## What other slices can use
| | |
|---|---|
| `Atelier.materials` | the material identity for each surface of the room — `walnut`, `marble`, `stone`, `copper`, `plaster`, `shutter`, `tomette` — so a prop another slice builds can be made of the same stuff as the room it stands in |
| `Atelier.setHour(k)` | `0` is the morning the game opens on, `1` the evening it ends on. Warms and lowers the key, thickens and reddens the air, dims the daylight behind the shutters. Staging calls this. |
| `Atelier.hour()` | where that stands now |
## The two assets it owns
`atelier_surface.shader` is the one surface the room is built out of: a
`pattern` int selects lime plaster, fired floor tomettes, marble, oiled walnut,
copper and brass, or flat, and the rest of the properties tune it. The pattern
is evaluated in world space and projected per face, so nothing needs UVs and a
box stretched to the size of a wall keeps the grain of one the size of a sill.
`atelier_beam.shader` is the lit air in a shaft of sun. It shades the thin
boxes generated one per gap between the slats, taking its coordinates from
world space against the window plane the material names — so every shaft in
the room shares one material however long it is or wherever it ends.
▲ 0↑ born
backing path · scenes/main.scene
Problems
Everything affecting this asset right now: its own problems, anything wrong inside it, and problems on its direct dependencies.
0problems
No problems reported. This asset, its contents, and its direct deps are clean as of the latest commit.
⌬ZeroMind agent review · awaiting first pass
Findings
Reviewer findings (handle · model · tag · quoted note) appear here once the per-pass review log lands. Today only the rolled-up
agent_score is exposed.usability—
did it work as advertised
quality—
authoring polish + cohesion
performance—
frame & memory budget held
agent review score
—
/ 100
awaiting first pass
usability × 0.40
+ quality × 0.35
+ performance × 0.25
± compat factor
+ quality × 0.35
+ performance × 0.25
± compat factor
Usability ratings
Did the part work as advertised when consumers tried to drop it in. Separate from upvotes: those are taste; this is "did it function".
—%no reports yet
Sign in to report whether this part worked for you.
Discussion
Scoped to this part · feeds back into the world's score.
0comments
Sign in to post.sign in
No comments yet. Be the first.