Log inGet started
◇
component · drop-in viewer
asset⌬ componentcomponentprimary: init.luau·originates fromworld 5164eb76-1…

Items

Every lap of every circuit has rows of floating **?** crates on the racing line. Drive through one and the kart is armed with a **Mushroom** or a **Feather**; L** uses it. Crates go dark for 8 seconds and come back.

by◐Cxrn·posted 19d ago
What it does

items — the ? crates and the two things they hold

Every lap of every circuit has rows of floating ? crates on the racing line. Drive through one and the kart is armed with a Mushroom or a Feather; L uses it. Crates go dark for 8 seconds and come back.

FileWhat it is
game/items.module (game.items)The slice's read-back surface.
Items.componentOne instance, spawned by the module. Owns arming the crates, the roll, and both items.
ItemCrate.componentOne per crate: spins, bobs, watches for the local kart, and respawns.

Where the crates are

tracks.crates(id) gives the positions — rows of four along the racing line, 5 rows on a loop and 8 on the ribbon — and the slice re-arms them whenever the circuit changes.

The rules

  • A kart already holding something does not take a second crate.
  • Mushroom — Core.BOOST.mushroom (2 s) of boost, source "mushroom".
  • Feather — Core.FEATHER_LIFT of lift, then, the moment the kart is back on the ground, 2 s of boost with source "feather".
  • Both are boosts other than the drift one, so they cancel the off-track speed penalty while they run.

API

local I = Core.system("items")
I.arm("cheep")   -- arm this circuit's crate rows
I.use()          -- use what the local kart is holding
I.held()         -- what that is: "", "mushroom" or "feather"
I.count()        -- how many crates are armed

Interface

What this asset declares: the schema it conforms to, what it exposes, and the rendered structured payload.

conforms to

zero/source-extract/v2

Items — the logic of the ? crates and of the two things they hold. It arms the crate rows for whichever circuit is up (from the positions tracks gives it), rolls what a crate hands out, and runs the mushroom and the feather when the kart uses one. The crates themselves are ItemCrate components; this is the one instance of the slice's own mind.

ItemCrate

clearCrates( ) → void

M_arm(id: string) → void

Arm the crate rows for the active circuit.

argtypedescription
idstringCircuit id (the crates come from tracks, which knows the line).

rollItem( ) → string

watchLanding(kartComp: any) → void

argtypedescription
kartCompany

stepFeather( ) → void

M_take(crateId: string) → void

Take the crate at an entity: hand its rolled item to the local kart.

argtypedescription
crateIdstringThe crate entity's id.

M_use( ) → void

Use what the local kart is holding.

M_held( ) → string

The item string the local kart is holding.

awake( ) → void

start( ) → void

count( ) → void

update(dt: number) → void

argtypedescription
dtnumber

onDestroy( ) → void

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.

11+items
Assets2Files9
▣
core
module · born here
❒asset
# core The shared contract of **Mario Kart OrigoZ**. Every slice reads its rules here, so no slice hard-codes a number that belongs to the game. `require("game.core")` from anywhere in this world. ## What it holds | Field | What it is | |---|---| | `TITLE`, `PROMPT`, `ART` | The game's name, the *pulsa J para jugar* prompt, and the art-direction sentence — word for word from the reference pass, reused by every prompt. | | `CIRCUITS` | The three circuits: id, name, laps, layout (`ring` / `square` / `ribbon`), racing surface, what lies beyond the edges, and half-width. | | `KART` | How a kart feels: max speed, acceleration, braking, turn rates, hop and gravity, drift multipliers, trick spin. | | `SURFACE` | What each surface does to you: `road` 100%, `water` 75%, `grass` 50%, `space` falls. | | `SPARK` | The drift charge table: blue at 1.0s (0.5s boost), orange at 2.5s (1.25s), rainbow at 4.0s (2.5s). | | `BOOST` | Trick 0.75s, mushroom 2.0s, feather 2.0s. | | `ITEMS` | Crate respawn (8s) and the mushroom / feather odds. | | `RESCUE` | How Lakitu puts you back: drop height, lift speed, lift duration. | | `PHASE`, `flow`, `race` | The flow state machine and the live race clock. | | `records` | The best time on each circuit, kept in `runtime_data.world` — shared and durable. | ## API - `M.circuits()`, `M.circuit(id)`, `M.circuitIndex(id)` - `M.register(name, api)` / `M.system(name)` — how slices reach each other - `M.on(name, fn)` / `M.emit(name, payload)` — the slices' event bus (`phase`, `circuit`, `lap`, `crate`, `boost`, `rescue`, `finish`) - `M.setPhase(p)`, `M.selectCircuit(id)`, `M.openControls()`, `M.beginRace()`, `M.startRace()`, `M.tick(dt)`, `M.reachPoint(total)`, `M.finishRace()` - `M.records.get(id)` / `M.records.set(id, ms)` / `M.records.all()` - `M.formatTime(ms)` → `"00:45.678"`, `M.countdownLabel(seconds)` - `M.clamp`, `M.lerp`, `M.approach` ## Who reads what - **kart** — `KART`, `SURFACE`, `SPARK`, `BOOST`, `RESCUE`, `race`. - **tracks** — `CIRCUITS`, `SURFACE`, `reachPoint`, `PHASE`. - **items** — `ITEMS`, `BOOST`, `FEATHER_LIFT`, `emit("crate")`. - **screens** — `flow`, `race`, `records`, `formatTime`, `PHASE`. - **audio** — `on("phase")`, `on("boost")`, `on("crate")`, `on("finish")`.
▲ 0↑ born
◇
ItemCrate
component · born here
❒asset
# ItemCrate One-paragraph description of what this component does and what it attaches to. Mention any required sibling components (e.g. Model, Transform). ## Public fields - `exampleNumber: number` — what it controls, units, valid range. - `exampleString: string` — what it controls. - `exampleBool: boolean` — what it controls. ## Methods - `:methodName(arg)` — what it does and when to call it. ## Lifecycle - `awake()` — same-frame attach hook. What initial state this component sets up. - `start()` — first-frame-after-awake hook. Cross-component setup that needs the other components on the entity to have finished `awake`. - `update(dt)` — per-frame while the gameplay clock runs. What this component does each tick. - `onDestroy()` — cleanup performed on detach / entity despawn. See `man components` for the full hook list (`onEnable`, `fixedUpdate`, `onPropertyChanged`, etc.) and the timing details. ## Usage ```luau entity(id).component.add("ItemCrate", { exampleNumber = 1.0 }) entity(id).component.get("ItemCrate"):methodName("foo") ```
▲ 0↑ born
backing path · game/items/Items.component

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

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.