·
other · 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.
61items
# main
The world's starting scene: a wide checkerboard floor with a collider, lit by a
directional sun, a dim ambient light and a procedural afternoon sky. Two lamp
posts stand beside the spawn, and a red crate with dynamic physics is shared by
every player in the world.
It sets up play for whoever joins: a player prototype with a humanoid avatar
and an orbiting follow camera, and the spawn point where each player arrives.
`build.luau` states all of it as code, and `scene.json` holds the baked result,
so the scene is there the moment the world opens.
▲ 0↓ import
# WildlandsHUD
Every screen in the game: the HUD (health, stamina and hunger bars, the
nine-slot hotbar with counts and durability, the quest tracker, the boss bar,
notices, and the crosshair readout naming whatever is targeted and what to do
with it) and the panel that holds the inventory, crafting, the creature team,
the build menu, the map and the pause menu.
A screen is a pure function of game state and is only redrawn when a signature
of that state changes, so a still frame costs nothing.
Attached to its own `wl_hud_host` entity by the scene entrypoint. It reads
state from `wl_core` and drives actions through `WildlandsWorld`.
▲ 0↓ import
# WildlandsPlayer
Everything the person at the keyboard does, on top of the movement the avatar
already provides: swinging a tool at what the crosshair is on, hand-gathering
loose stone and fiber with E, throwing a Wildcore Orb and resolving the capture,
eating, and keeping the survival meters honest.
Targeting is aim-based, not proximity-based: `WildlandsWorld:aimNode` scores each
node by how directly it lies along the camera's forward, so the tree you look at
is the tree you hit.
Attached to the player's avatar body by the scene entrypoint on
`localPlayerReady`. It activates the `wildlands` input map and needs
`WildlandsWorld` to exist.
▲ 0↓ import
# WildlandsWorld
Owns the physical world: it generates the terrain mesh and its heightfield
collider, the lake, the desert flat, the ruined colonnade, the forest, the
resource nodes and every wild creature, all under one root entity so a reload
reclaims the lot.
It also keeps the live state of everything it spawned — each node's kind,
health and drops, each creature's record — and answers the questions the player
component asks: what is under the crosshair, what did that swing hit, where is
the nearest creature, and what station is close enough to use.
Attached to `wl_host` by the scene's `build.luau`. Fields: `seed` (change it for
a different landscape), `buildInEdit` (also generate while authoring),
`creatureBudget` and `tickEvery` (how many creatures are simulated and how often
far ones are updated).
▲ 0↓ import
▲ 0↓ import
# wl_character
The survival explorer's kit.
The rigged body the engine ships has no material of its own and no clothing, so
this module gives it both: a skin material on the skinned mesh, and around
twenty garment pieces seated on the skeleton with `Humanoid:attach` — jacket,
collar, scarf, crossed straps, belt and pouches, backpack with straps and
bedroll, sleeves, gloves, trousers, laced boots and hair.
Sleeves and trousers are measured, not guessed: each is built by taking the two
bones at the ends of a limb and expressing the world direction between them in
the first bone's own basis, so it lies along the real arm or leg whatever the
rig's bone frames are.
`CH.hold` seats a tool in the right hand; `CH.stow` puts one on the pack.
Called by the scene entrypoint on `localPlayerReady`.
▲ 0↓ import
# wl_core
The one piece of shared runtime state. Components run in separate VMs, so
anything they must agree on lives here: inventory, hotbar, survival meters,
quest progress, captured companions, placed structures and the save file.
The state table comes from `modules.state()`, so a hot reload of this module
keeps everything. The save is written to `/source/local/wildlands_save.json`
and read back by the scene entrypoint on load.
Callers: `WildlandsPlayer`, `WildlandsHUD`, `WildlandsWorld`, `wl_creatures`
(loot and companion records) and the scene entrypoint.
▲ 0↓ import
# wl_creatures
The twelve species: their anatomy, their rigs, their animation, their AI and
their abilities.
A creature is a small hierarchy of entities — torso, neck, head, legs, tail,
wings, fins and ornaments — so every part can be articulated. `CR.rig(key)`
builds that geometry once per species and caches it; `CR.spawn` assembles an
instance; `CR.tick` runs the state machine and `CR.animate` poses the joints.
`CR.hit` is the single damage entry point, so armour, shields, the hurt state
and defeat behave the same whoever deals the damage.
Callers: `WildlandsWorld`.
▲ 0↓ import
# wl_defs
Static game data for WILDLANDS and nothing else: tuning constants, the item
catalogue, crafting recipes, smelting rules, quest definitions and the structure
table. No engine state lives here, so it is safe to require from anywhere.
`wl_creatures` also re-exports the species table, but the creatures' own
anatomy and rules live in that module.
Callers: `wl_core` (items and recipes), `WildlandsWorld` (structures, tuning),
`WildlandsHUD` (recipes and item icons), `WildlandsPlayer` (tuning).
▲ 0↓ import
# wl_geo
Procedural geometry. Every builder returns a `Geo` — flat `positions`,
`normals`, `uvs`, `colors` and `indices` arrays in the shape
`renderer.mesh.create` takes, in local space.
Vertex colour multiplies the albedo of the `pbr` shader and is read as LINEAR
light, so a hex palette must be decoded before it goes in (`wl_creatures` does).
Builders: `sphere`, `tube`, `card`, `leaf`, `tree`, `rock`, `grassTuft`, `fern`,
`bush`, `structure`, `tool`, `wildcoreOrb`, plus `append` for merging, `box`,
`tpos`/`qAxis`/`qMul` for transforms and `recomputeNormals` for displaced
surfaces.
Callers: `WildlandsWorld`, `WildlandsPlayer`, `wl_character`, `wl_creatures`.
▲ 0↓ import
# wl_land
The landscape, as one height function. `height(x, z)` is the authority on where
the ground is: the rendered terrain mesh, the physics heightfield, every tree,
rock and creature placement and the player's spawn all read it, so what you see
and what you stand on are the same surface by construction.
Also exposes `normalAt`, `SPAWN` and `spawnY`.
Callers: `WildlandsWorld` (terrain, placement), the scene entrypoint (spawn
point), `WildlandsPlayer` (lake and terrain references).
▲ 0↓ import
▲ 0↓ import
▲ 0↓ import
▲ 0↓ import
▲ 0↓ import
▲ 0↓ import
▲ 0↓ import
▲ 0↓ import
▲ 0↓ import
▲ 0↓ import
▲ 0↓ import
▲ 0↓ import
▲ 0↓ import
▲ 0↓ import
▲ 0↓ import
▲ 0↓ import
▲ 0↓ import
▲ 0↓ import
▲ 0↓ import
▲ 0↓ import
backing path · libs/@wildlands
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.