▣
module · 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.
Showing up to 3 levels deep. Open a part to see what it holds further down.
8+items
▲ 0↑ born
# sengokuTownKit
Drop a whole walkable, climbable **late-16th-century Japanese castle town** into any world with one component. It gives you a keep of three to five tiers on a curved dry-stone base, walls with a main gate, a rear gate and corner watchtowers, and a moat. Streets of wooden machiya townhouses run below it, for merchants, artisans, wealthy families and a weathered poor quarter, with tile roofs, white and earthen plaster, lattice fronts and sliding paper screens. There is a market street lined with stalls and noren curtains, a tea house and a castle hall you can walk into, and a temple with a five-storey pagoda, a bronze bell and stone lanterns. Out past the river are a granary, a thatched farmhouse, terraced rice paddies with irrigation channels and a turning water wheel, bamboo groves, and an arched wooden bridge over the river.
Size, districts, density and seed are each one setting. **The same seed is the same town for every player, on desktop and in the browser.** It has no game rules: it is a place, ready for a stealth game, a festival, a story or a walk.
## Drop a castle town into your world
Install **sengokuTownKit** from ZeroMind (it brings sengokuProps, sengokuMaterials, worldClockKit with soundstage, the Cloudburst weather kit, navKit and the styleKit blocks). Then paste this into an empty world, either in the editor's run box or inside `content()` of a scene's `build.luau`:
```luau
entity.spawn("CastleTown").component.add("sengokuTownKit.CastleTown", {
size = 360, districts = 4, density = "normal", seed = 7, look = "realistic",
})
entity.spawnSynced("TownAtmosphere").component.add("sengokuTownKit.TownAtmosphere", {
time = "dawn", weather = "clear",
})
```
The town stands within a few seconds. Nothing is baked or saved: the ground, the props and their colliders are computed from the settings on every machine. Press play and the scene's player spawns stand in front of the castle gate (turn that off with `spawnAtGate = false`).
To let players climb onto roofs and up the keep's stone base, add climbKit's mover to your player's body. climbKit is a separate install from the Ledgework world, which keeps this kit free of movement rules:
```luau
body.component.add("climbKit.ClimbMover", {})
```
## What you set
| Setting | Values | What it does |
|---|---|---|
| `size` | 200 to 720 (m) | the side of the square the castle, town, river and paddies stand in |
| `districts` | 1 to 5 | 1 merchants only; 2 adds artisans; 3 a wealthy quarter by the castle; 4 a weathered poor quarter at the edge; 5 more artisans mixed in |
| `density` | sparse, light, normal, dense, packed | how closely houses stand, and how many stalls, carts, bales, barrels and rice plants there are |
| `seed` | any whole number | each seed is a different town; the same seed is always the same town |
| `keepTiers` | 3 to 5 | tiers of the castle keep |
| `look` | realistic, weathered, festival, toon, ink | how the whole town is drawn (see Looks) |
| `spawnAtGate` | true / false | stand the scene's player spawns in front of the castle gate, in play |
| `quality` | 0.3 to 2 | how far detail draws (the browser caps it at 0.6); nothing you touch moves or goes away |
Changing size, districts, density, seed or keepTiers rebuilds the town; changing look or quality restyles it in place.
## How the parts fit
- **CastleTown** (component) → **TownBuilder** (module): builds, restyles and tears down a town. `TownBuilder.build(opts)` from code; `TownBuilder.planFor(opts)` gives the plan alone.
- **TownLayout**: the plan as pure functions of the settings. It places the castle bailey, moat, gates and towers, the streets the houses front onto, back lanes between plot rows (2.5 to 3 m between facing eaves, so rooftop runners can jump them), one plot per house with its district and kind, the market street, the temple precinct, the river, the bridges, the paddy terraces, the farm, the groves and the named stops of a walk.
- **TownGround**: heights, drawn surfaces, footstep surfaces, water and zones at any point, plus the chunked ground meshes with exact colliders and the water planes (moat, river, every flooded paddy).
- **TownScatter**: the scatter rules (below), turning the plan into placements.
- **TownRender**: hardware-instanced drawing, one draw per prop part per level of detail, with instances re-sorted into near, mid and far by distance from the camera, a few groups per frame.
- **TownColliders**: each placement's colliders from the prop catalog, so what you stand on is what you see, sloped roofs included. Colliders carry `sengokuSurface` (footsteps), `climbable` (climbKit) and `noNav` (roofs, kept out of NPC routes).
- **TownAtmosphere** (component) → **Atmos**: time of day, weather, ambience and night light. **Footsteps**: footsteps by the ground under every walker. **TownNav**: navigation for characters. **Look**: the whole-town look.
- **TownMaterials**: the kit's single route to sengokuMaterials, with a plain stand-in while that package loads.
## Scatter rules
- Every plot gets a house facing its street. Merchants and the market get noren over the door and a chochin beside it; some get a standing signboard.
- **Climb-ups**: one-storey and narrow houses (artisan workshops, row tenements, two-ken shops) get, with a chance set by density, something to climb against the low front eave: a stack of rice bales, a hand cart, a small stall or a stack of barrels. Market stalls line both kerbs, and their roofs are low enough to climb from the street and lead on to the eaves behind them.
- The market street has lantern strings across it every 8 m; the main street has them every 12 m.
- Back lanes have wells and firewood piles.
- **Castle**: walls round the bailey with gaps for the main (south) and rear (east) gates, dry-stone revetments on both banks of the moat, earth bridges, three corner towers, the keep near the north side, the hall, black pines in the bailey and along the outer bank, and banners and stone lanterns before the gate.
- **Temple**: a gate facing the town, the main hall, the pagoda, the bell tower with its bell, two rows of stone lanterns along a paved path, low walls and a bamboo fence, a small shrine with a torii, pines, maples, cherries and garden rocks.
- **Paddies**: rice planted in rows in every flooded field, a stone slab bridge over the channel, and the farm with its thatched farmhouse, raised granary with a ladder, the water wheel on the channel, bales, a well and firewood.
- **River**: the arched bridge to the castle's rear gate, a plank bridge by the temple, reeds along both banks and cherries on the west bank.
- **Bamboo groves** in the corners and behind the temple.
## Time of day, weather, sound
```luau
local Atmos = require("sengokuTownKit.Atmos")
Atmos.setTime("festivalNight") -- dawn | day | festivalNight, for every player
Atmos.setWeather("rain") -- clear | mist | rain | storm
Atmos.ringBell() -- the temple bell, once
```
Or set the TownAtmosphere's `time` and `weather` fields. The time runs on worldClockKit's shared clock and the weather on the Cloudburst weather kit, so everyone sees the same sky and the same rain, and a player who joins later gets it too. TownAtmosphere uses the scene's WorldClock and Cloudburst weather, and creates each only when the scene has none. The clock's own rain, lightning and weather sound are turned off, so nothing is drawn or heard twice.
- **dawn**: a low gold sun, with clear weather turned to a light mist over the roofs. Roosters, birds and a far bell.
- **day**: a bright high sun and the murmur of the town (voices, geta, carts, sparrows).
- **festivalNight**: moonlight; paper lanterns, lantern strings and shoji screens glow, warm point lights stand at the nearest lanterns, and the festival plays (taiko, flutes, crowd).
- **mist**: Cloudburst's misty dawn, valley fog lying low over the town.
- **rain**: Cloudburst's steady rain: lit, see-through drops that stop on the tile roofs (dry under the eaves and indoors), splashes on the street and roofs, drips at every eave, wet darker wood, glossy stone and puddles, and the sound of rain that muffles when you step inside. The rain follows the look: cartoon rain in `toon`, woodblock rain in `ink`.
- **storm**: Cloudburst's night storm in a town: a heavy cinematic downpour, photosensitivity-safe lightning and thunder that arrives later the further away the strike.
- **By place**: frogs, trickling water and the water wheel at the paddies; pines and a wind chime in the temple.
- **Footsteps** sound like what you stand on: wood (verandas, bridges, stall roofs), tatami (tea house, castle hall), stone, packed earth (streets), paddy water (wading the rice), gravel and grass. Tatami, packed earth and paddy water are this kit's own recordings, added to soundstage as new surfaces.
## Looks
```luau
require("sengokuTownKit.Look").set("toon") -- or set the CastleTown's look field
```
| Look | What you get |
|---|---|
| `realistic` | the default: aged timber, shikkui plaster, grey kawara |
| `weathered` | a poor quarter: sun-bleached grey wood, stained and cracked plaster, patched roofs, moss |
| `festival` | dressed for a festival: bunting, extra lanterns, bright cloth |
| `toon` | the toon prop set with toonBlocks' comic-ink cel finish over the frame |
| `ink` | the realistic set under inkBlocks' brush-and-wash ink painting (sumi-e) |
The frame finish lives on the scene's synced style stack, so every player sees the same look.
## Characters that find their way
```luau
local TownNav = require("sengokuTownKit.TownNav")
TownNav.bake() -- once the town stands (yields: call it from a task)
local path = TownNav.findPath("gate", "temple") -- { status, points, ... }
TownNav.walk(npc, { "gate", "market", "temple" }, { loop = true })
```
The map is a navKit grid over the town's ground floor. Roofs are left out of it, and the moat and river are blocked below bridge level, so walkers cross by the bridges. The stops are `gate`, `street`, `market`, `teaHouse`, `temple`, `paddies`, `bridge` and `hall`.
## Ask the town
```luau
local c = entity.find("CastleTown").component.get("sengokuTownKit.CastleTown")
c:stop("temple") -- world position of a stop
c:stats().fingerprint -- a short code over every placement: equal codes, equal towns
local town = c:town()
town.ground:surfaceAt(x, z) -- packedEarth, rakedGravel, paddyMud, cutStone, ...
town.ground:footstepAt(x, z)
town.ground:zoneAt(x, z) -- castle, moat, street, market, town, temple, river, paddies, grove, field
town.placed.climbs -- every deliberate climb-up (bales, carts, stalls)
```
## Every player, the same town
The plan, the ground and every placement come from integer-hash noise and plain arithmetic: no `math.noise`, and street-aligned turns are exact quarter turns. IEEE doubles compute these identically everywhere, so the desktop engine and the browser stand the same houses, roofs and colliders. Time is worldClockKit's shared state and weather is Cloudburst's (a few synced fields and a seeded lightning schedule on the shared clock). Footsteps are soundstage's, heard from every walker.
## In the browser
The browser builds exactly the same town and draws it lighter: `quality` is capped at 0.6, which pulls in the distances where houses and props drop to their cheaper versions or stop drawing. Houses, castle and temple each draw as a few instanced draws however many there are.
## Guides
- **How to use the castle town kit** (`guides/how-to-make-a-japanese-castle-town`): what it is, how the parts fit and what to do first.
- **Example: a small village from an empty world** (`guides/example-a-small-japanese-village-with-a-temple-townhouses-and-rice-paddies`): a temple, a few townhouses and some paddies, with no castle, built step by step from the parts.
## Tests
`tests/sengokuTownKit.testSuite` checks determinism (the same settings give the same plan and fingerprint), that each setting changes the town, that every stop lies on walkable ground, the scatter rules (climb-ups in front of low eaves, stalls on the market street), ground surfaces and water, footstep mapping, atmosphere presets, looks and a built town's colliders and attributes.
## Known limits
- **Frame rate (desktop).** On a busy desktop editor session, standing on the main street of the showcase town: 24 fps on average with a 33 ms median frame, up from 17 fps and 50 ms before this release. It is limited by the GPU, and most of that is shadows. The town is drawn as instanced populations fed from GPU buffers, and the engine's shadow cache cannot tell that those never move, so every shadow page under the town redraws (an engine limit, reported to the platform). The kit redraws them every third frame (`renderer.setShadowConfig({ updateRate = 3 })` in `TownRender`), which took about 8 ms of GPU work off each frame. worldClockKit 1.6.7 also stopped re-pushing the whole environment every frame.
- **Frame rate (browser): not measured.** The desktop editor these packages were built in cannot open a browser session, and ZeroMind records no browser sessions of this world yet, so there is no browser number to give, and no check that the earlier browser restarts and mesh leak are gone. In the browser the kit drops its draw distances to 0.6 of the desktop's (`Town.setQuality`). Please treat the browser as untested until someone has run it.
- **Memory.** On the editor session above the whole process used about 5.3 GB (peak 6.0 GB) and the GPU about 1.6 GB. Most of the process is the editor and engine rather than the town: about 2.25 GB of allocator pages kept for reuse, about 1 GB of script heaps across every running script, and about 0.25 GB of loaded sources and asset index. Putting the prop gallery out and clearing it no longer grows memory: `SengokuProp` made a new bridge-deck mesh every time a prop was built and never freed it, and it now shares one mesh per deck shape.
- **Engine shader errors.** On engine build 53e4f17 every shader logs `redefinition of zero_projection_is_orthographic`, the engine's own included, and some surfaces may draw a placeholder until the engine is fixed. Nothing in these packages defines that function. It is reported to the platform.
- `TownNav.bake` runs navKit's time-budgeted spread bake, which finishes over many frames rather than in one call, so on a loaded machine the walk map can take a while to be ready; the showcase's `Townsfolk` component starts it again if it has not finished after 240 seconds.
- The street scatter's climb-up boost props (barrel stacks, carts, bale stacks) are placed only near four house kinds' low eaves (`machiyaArtisan2`, `machiyaArtisan3`, `nagaya`, `machiyaMerchant2`). Other kinds with a similarly low pent eave (`machiyaMerchant3`, `machiyaMerchant4`, `machiyaCorner`) and the two-storey wealthy houses get no boost prop scattered near them. Every roji alley (the rooftop run's gaps) has a rice-bale climb-up of its own.
## What changed in 1.1.1
- The Cloudburst move (1.1.0, pull request #1) is now merged into this world's main branch and released from there; 1.1.0 had been published from the pull request's own branch.
- Weather by Cloudburst 1.4.5: daytime and windy rain read clearly, picking a weather always brings it, two lightning strikes never start less than 2.6 seconds apart, and Cloudburst no longer brings the arctic and alpine kits with it when installed.
## Depends on
Versions are the ones this package's `package.yaml` names, which are the releases installed in this world.
- **sengokuProps 1.0.1**: every house, castle and temple building and every small prop. `TownBuilder.props()` reads its `Props` catalog for footprints (`Props.info`), meshes and colliders (`Props.colliders`), and `SmallGen.lanternString` makes the festival lantern strings.
- **sengokuMaterials 1.0.1**: the ground, paths and water surfaces, through `TownMaterials.get`, and the lantern and screen glow at night (`SengokuMaterials.setGlow`, from Atmos).
- **worldClockKit 1.6.7** (Skyclock): the shared clock and sky. Atmos sets the time with `Clock.setTime`, `Clock.pause` and `Clock.resume` and reads `timeofday.darkness()`; it turns the clock's own `precipitation`, `lightning` and `sound` off and holds its weather at clear, since Cloudburst does the weather. TownAtmosphere uses the scene's `WorldClock` component or creates one.
- **cloudburst 1.4.5** (Cloudburst): the weather. Atmos sets it with `cloudburst.weather` (`host`, `now`) and the Cloudburst component's `setWeather`: clear is `clear_day`, mist `misty_dawn`, rain `steady_rain`, storm `night_storm_town`, with the rain look swapped to `cartoon` (toon look) or `woodblock` (ink look). Cloudburst draws the rain, splashes and lightning, drives the engine's surface wetness (which sengokuMaterials' puddles and paddy ripples follow) and plays the rain and thunder. TownAtmosphere uses the scene's Cloudburst weather or creates one.
- **soundstage 2.1.3**: ambience and footsteps. Atmos defines the kit's beds and plays them through `soundstage.ambience` (`define`, `setBase`, `zone`, `play`, `stop`). Footsteps adds three surfaces to `soundstage.footsteps` with clips defined through `soundstage.sfx`, and sets its surface resolver.
- **navKit 1.4.6** (Pathwise): TownNav bakes the `sengokuTown` grid map and moves walkers with `navKit.api` (`findPath`, `addAgent`, `setTarget`, the `arrived` event). The installed copy is navKit 1.4.6 exactly as released in Pathwise, with no local changes: the time-budgeted spread bake this town needed was merged upstream and released there.
- **styleKit 1.8.2** (Style Cookbook): Look puts the frame finish on the scene's synced style stack with `StyleKit.applyLook` and `StyleKit.clear`.
- **toonBlocks 1.4.5** and **inkBlocks 1.2.13** (Style Cookbook): the blocks behind the `toon` look (the `comicInkCel` finish) and the `ink` look (the `brushAndWash` finish), applied through styleKit.
climbKit 1.1.10 (from the Ledgework world) is installed in this world but is not a dependency: colliders carry the `climbable` attribute it reads, and a world adds `climbKit.ClimbMover` to its player when it wants climbing.
▲ 0↑ born
backing path · sengokuTownKit.package/Look.module
Problems
Everything affecting this asset right now: its own problems, anything wrong inside it, and problems on its direct dependencies.
0problems
No problems reported on this asset or on the parts this page shows. Parts it leaves out are not counted here.
⌬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.