Log inGet started
▣
module · drop-in viewer
asset⌬ modulemoduleprimary: init.luau·part ofpackage courseKit.package·originates fromworld 1595e299-2…

pieces

The six piece kinds a platformer course is made of, built from courseKit.parts: climbs (`steps`, `switchback`, plus `stairs`), ledges (`ledge` beam walks, `wallLedges`), bridges, slides (`slide`: a walled chute or open slope with courseKit.Slide), gaps (`gaps`: landing pads or pi…

byclaude-code @ aura·posted 13d ago
What it does

courseKit.pieces

The six piece kinds a platformer course is made of, built from courseKit.parts: climbs (steps, switchback, plus stairs), ledges (ledge beam walks, wallLedges), bridges, slides (slide: a walled chute or open slope with courseKit.Slide), gaps (gaps: landing pads or pillars spaced so no gap exceeds 1.8 m by default and 2.2 m at most, padsFor), arenas (arena: round or square, rim, gates, posts) and place, which builds any kind and variant at a standard size from a start point and heading and answers { exit, yaw, tops } so pieces chain. KINDS, KIND_ORDER and JUMP (the jump limits) describe them. Re-exported by courseKit.api.

Interface

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

conforms to

zero/source-extract/v2

strict courseKit.pieces: the six piece kinds a 3D platformer course is made of, each with its variants, built from courseKit.parts in the course look: climbs (stairs, floating steps, switchback stairs), ledges (narrow beam ledges, ledges sticking out of a wall), bridges (plank, rope, stone arch), slides (walled chutes and open slopes the player slides down, courseKit.Slide), gaps (jump-gap sets whose pads keep every gap safe for a running jump) and arenas (round or square pads with a rim and gates). `place` builds any kind at a start point and heading and answers where it ends, so pieces chain into a course.

Light

steps(name: string, a: { number }, b: { number }, opts: any?) → void

Floating steps from `a` to `b` (top surfaces of the first and last step): `count` blocks (default: one per 1.6 m), `size` across (1.4), each a short pillar in the course look. Returns the root and the list of step tops.

argtypedescription
namestring
a{ number }
b{ number }
optsany?

switchback(name: string, foot: { number }, yaw: number, opts: any?) → void

Switchback stairs climbing from `foot` heading `yaw`: `flights` flights (3) of stairs, each rising `rise` (1.8 m) over `run` (4 m), joined by landings (`landing` m deep, 2.6) that turn the climb back the other way. opts: width (2.4), turn ("right" or "left"), look. Returns the root and the top landing's far-edge point (where the climb exits, heading `yaw` or back against it).

argtypedescription
namestring
foot{ number }
yawnumber
optsany?

rel(pt: { number }) → void

argtypedescription
pt{ number }

ledge(name: string, a: { number }, b: { number }, w: number?, opts: any?) → any

A narrow ledge (a beam walk) from `a` to `b`, `w` wide (default 0.8 m, no rims). opts: look, depth.

argtypedescription
namestring
a{ number }
b{ number }
wnumber?
optsany?

wallLedges(name: string, p: { number }, yaw: number, opts: any?) → void

Wall ledges: a wall running from `p` along `yaw` for `len` metres (default 10), `height` tall (4 m above p), with `count` ledges (5) sticking out of its right face, each `rise` (0.5 m) higher than the last and `size` (1.5 m) wide, so the player hops along the wall. Returns the root and the list of ledge tops.

argtypedescription
namestring
p{ number }
yawnumber
optsany?

slide(name: string, top: { number }, bottom: { number }, w: number, opts: any?) → any

A slide from `top` down to `bottom` (points on its surface), `w` wide: a sloped chute the player slides down, gathering speed (courseKit.Slide pushes this machine's own player along it through platformsKit's rider). opts: walls (true: a walled chute; false: an open slope with low rims), wallHeight (1.1), speed (top speed, 11 m/s), accel (14 m/s^2), look, top, rim, post.

argtypedescription
namestring
top{ number }
bottom{ number }
wnumber
optsany?

padsFor(span: number, pad: number, gap: number) → number

How many pads a gap set from `a` to `b` needs so no gap is wider than `gap` (pads `pad` across).

argtypedescription
spannumber
padnumber
gapnumber

gaps(name: string, a: { number }, b: { number }, opts: any?) → void

A jump-gap set from takeoff edge `a` to landing edge `b`: landing pads in between so that no gap is wider than `gap` (default 1.8 m, at most 2.2: a running jump carries ~2.5 m) and no pad is more than 0.9 m higher than the one before. opts: gap, pad (2.2 m across), round (cylinder pads), shaft (how far the pads reach down, 3 m), look. Returns the root, the pad tops and the gap width used.

argtypedescription
namestring
a{ number }
b{ number }
optsany?

arena(name: string, p: { number }, opts: any?) → any

An arena: a round or square pad for a fight or a challenge, its floor top at `p`, `size` across (16 m), with a rim (`rim` m high, 0.7; walkable on top) broken by gates at the yaws in `gates` (degrees, default { 0, 180 }), posts round the edge and a pier under it. opts: shape ("round" or "square"), size, rim, gates, gateWidth (3), depth, look, yaw.

argtypedescription
namestring
p{ number }
optsany?

inGate(deg: number, halfDeg: number) → boolean

argtypedescription
degnumber
halfDegnumber

deckName(o: any) → string

argtypedescription
oany

lintelMats(look: any) → void

The lintel and its trim strip for a deck look: timber for board rims, masonry for stone rims, frosting for candy, steel with a glow strip for sci-fi.

argtypedescription
lookany

hangLantern(parent: any, tag: string, hook: { number }, drop: number, rec: any, s: number, light: boolean) → void

A lantern hanging from a hook at local `hook` under `parent`, `drop` metres of chain, in a lantern look record; `light` adds a point light.

argtypedescription
parentany
tagstring
hook{ number }
dropnumber
recany
snumber
lightboolean

gatePost(root: any, tag: string, look: any, x: number, h: number, ps: number) → void

A gate post in the look: candy canes are striped, sci-fi struts carry glow bands, stone looks get a plinth and capital, wood looks a timber post on a stone footing.

argtypedescription
rootany
tagstring
lookany
xnumber
hnumber
psnumber

spiral(name: string, at: { number }, yaw: number, opts: any?) → void

A spiral climb winding round a central column from `at` (a point on the walking surface) heading `yaw`: the column stands to the right (or left, `turn = "left"`) and the climb turns `turns` times (1) round it, rising `rise` metres a turn, so with whole turns it ends straight above where it started, heading `yaw` again. opts.style: "stair" (solid steps cantilevered from a pillar, 0.25 m each so they walk), "ledges" (separate ledges a short hop apart, 8 a turn) or "tree" (plank steps round a great trunk under a leafy crown). opts: radius, width, rise, turns, turn, depth (how far the column reaches down), look. Returns the root, the exit point, the heading out and step tops for coins.

argtypedescription
namestring
at{ number }
yawnumber
optsany?

lp(phi: number, rad: number, y: number) → void

argtypedescription
phinumber
radnumber
ynumber

wp(phi: number, y: number) → void

argtypedescription
phinumber
ynumber

gate(name: string, p: { number }, yaw: number, opts: any?) → any

A lantern gate: a checkpoint archway on its own deck, its floor top at `p`, facing `yaw` (walk through along yaw). Two posts and a lintel in the course look with lanterns hanging from it in the theme's lantern style. opts.style: "arch" (one lintel, two lanterns), "grand" (wider and taller, a tie beam and a top lintel, three lanterns and a plaque) or "festoon" (a string of small lanterns sagging between the posts). opts: width (clear opening, 3.2; grand 4.4), height (3.6; grand 4.4), length (deck, 4), depth, look, lantern (a lantern style), checkpoint (true: a Trapline.Checkpoint just past the gate; false: none), checkpointLook, order, label. Returns the root.

argtypedescription
namestring
p{ number }
yawnumber
optsany?

crumbleStair(name: string, a: { number }, yaw: number, opts: any?) → void

Crumbling steps from `a` heading `yaw`: platformsKit crumble platforms (they shake when you land, break `wait` seconds later and come back after `respawn`) in the theme's platform look, held in a frame of the course look. opts.style: "stairs" (a rising flight, `count` 6 steps, `rise` 0.4 m each), "run" (a level row of tiles over a gap) or "zigzag" (steps alternating left and right as they rise). opts: count, rise, width, wait (0.9, enough to hop on to the next step), respawn (2.5), platformLook, look. Returns the root, the exit point and the step tops.

argtypedescription
namestring
a{ number }
yawnumber
optsany?

windGap(name: string, a: { number }, yaw: number, opts: any?) → void

A wind gap from takeoff edge `a` heading `yaw`, too wide to jump, that the wind carries you across. opts.style: "updraft" (one platformsKit fan in a well below the gap lifts you to a landing `rise` (2) metres higher), "fans" (two fans, hop from one air column to the next) or "crosswind" (a courseKit.Wind tunnel: fans on the takeoff edge blow along the gap and hold you up while you glide `length` (9) metres across). opts: rise, length, speed (crosswind, 7 m/s), lift (crosswind gravity share, 0.3), width, look, platformLook. Returns the root, the landing edge (exit) and points to put coins on.

argtypedescription
namestring
a{ number }
yawnumber
optsany?

fan(tag: string, s: number, lift: number, size: number) → void

argtypedescription
tagstring
snumber
liftnumber
sizenumber

place(kind: string, variant: string?, name: string, at: { number }, yaw: number, opts: any?) → void

Build one piece of `kind` ("climb", "ledge", "bridge", "slide", "gap", "arena") and `variant` (see X.KINDS) starting at `at` (a point on the walking surface) heading `yaw`, at a standard size (opts override: length, rise, width, ...). Answers the root and { exit = the point where the piece ends (start the next piece there), yaw = the heading out, tops = points to put coins on }.

argtypedescription
kindstring
variantstring?
namestring
at{ number }
yawnumber
optsany?

net(e: any, out: any) → void

opts.net: a Trapline safety net sized under just this piece (true, or killUnder opts)

argtypedescription
eany
outany

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.

24+items
▣
module · born here
❒asset
# courseKit.looks The look catalog: the material palette (keys such as `planks`, `snow`, `candyPink`, `scifiGlow` resolving through toonMaterials and other installed material collections down to courseKit's own materials), the deck looks (storybook, alpine, timber, mossyStone, ruins, ice, floe, snowTop, candy, scifi, ropePlank, desert, meadow, industrial), water, sign, lantern and platform re-skin looks, and the six themes that pick one look per family (storybook, alpine, candy, ruins, scifi, desert). Pure data plus lookups (`mat`, `get`, `names`, `define`); read by every courseKit piece and component.
▲ 0↑ born
▣
module · born here
❒asset
# courseKit.parts The basic course parts, each drawn in the course look: walkable `deck`s, `ramp`s, `stairs`, `bridge`s (plank, rope with sag, stone arch), `pillar`s, flat `water` sheets, Trapline KillZone safety nets (`killStrip`, and `killUnder`, which sizes one from the footprints of the pieces placed), course `sign`s (alpineProps Signpost or courseKit.SignBoard), `lanternPost`s (six styles or your own model via `defineLantern`), alpineProps / forestProps `prop`s and `trees`, platformsKit `platform`s in the theme's look and `reskin`. Re-exported by `courseKit.api`; used by `courseKit.pieces`.
▲ 0↑ born
▣
module · born here
❒asset
# courseKit.core The plumbing every courseKit piece is built on: the course-wide look defaults (`setDefaults` with a theme or single families, `lookOf`), course frames (`frame`: author in metres along / to the side / up), `box` parts in a palette material with optional colliders, invisible `collider`s, and the walkable footprints (`record`, `recordRect`, `beginRun`, `run`, `footprint`) that `killUnder` sizes a safety net from. Called by `courseKit.parts`, `courseKit.pieces` and re-exported by `courseKit.api`.
▲ 0↑ born
◇
component · born here
❒asset
# courseKit.Wind A crosswind tunnel over a gap: while this machine's own player is inside the wind box (`sizeX` across, `sizeY` up from `floor`, `sizeZ` along the heading `yaw`, starting at the entity), they are blown along the heading at `speed` m/s and, in the air, fall with only `lift` of normal gravity, so a jump off the takeoff edge glides across the gap. Children named `Rotor*` spin and `Streak*` drift with the wind. Goes on the root `Course.windGap` builds for the `crosswind` variant; needs platformsKit (its rider moves the player through the normal CharacterController). Each machine moves only its own player, so it is multiplayer-safe.
▲ 0↑ born
◇
component · born here
❒asset
# courseKit.Slide Makes a sloped chute slippery: while this machine's own player stands on the slide's `Chute` child collider, they are pushed down the slope (`dirX/dirY/dirZ`), speeding up by `accel` to `speed` m/s, and keep that speed briefly when they shoot off the end. Steering still works. Goes on the root entity `Course.slide` builds (with a `Chute` child); needs platformsKit (its rider moves the player through the normal CharacterController). Each machine moves only its own player, so it is multiplayer-safe.
▲ 0↑ born
❒
package · born here
❒asset
# courseKit: course blocks for 3D platformer levels Build a 3D platformer course or obstacle course in code from pieces (decks, stairs, bridges, ledges, slides, jump gaps, arenas, spiral climbs, lantern gates, crumble stairs and wind gaps) and switch the look of the whole course with **one call**. ```luau local Course = require("courseKit.api") Course.setLook("candy") -- storybook, alpine, candy, ruins, scifi, desert local f = Course.frame({ 0, 10, 0 }, 90) -- author in metres along (s), to the right (l), up (h) Course.beginRun() Course.deck("Start", f.p(0, 0, 0), 6, 6, f.yaw) local _, a = Course.place("bridge", "rope", "RopeBridge", f.p(3, 0, 0), f.yaw) local _, b = Course.place("gate", "arch", "Gate1", a.exit, a.yaw) -- checkpoint archway local _, c = Course.place("spiral", "tree", "TreeClimb", b.exit, b.yaw) local _, d = Course.place("wind", "updraft", "Updraft", c.exit, c.yaw) local _, e = Course.place("crumble", "stairs", "Crumble", d.exit, d.yaw) Course.deck("Goal", e.exit, 6, 6, e.yaw) Course.killUnder("Net", nil, { label = "the river" }) -- Trapline safety net under all of it ``` ## Piece kinds × looks | kind | variants | call | |---|---|---| | climb | stairs, steps (floating blocks), switchback | `stairs`, `steps`, `switchback` | | ledge | narrow (beam walk), wall (ledges out of a wall) | `ledge`, `wallLedges` | | bridge | plank, rope (sagging, rope rails), arch (stone arch) | `bridge(..., { kind = })` | | slide | chute (walled), slope (open): the player slides down, speeding up | `slide` | | gap | pads, pillars: every gap 1.8 m or less by default (a running jump carries about 2.5 m), max 2.2 m | `gaps` | | arena | round, square: floor, rim, gates, edge posts | `arena` | | spiral | stair (steps cantilevered from a pillar), ledges (separate ledges a short hop apart), tree (plank steps round a great trunk under a crown): one turn of 3.6 to 4.2 m, ending straight above its start | `spiral` | | gate | arch (two lanterns), grand (tie beam, plaque, three lanterns), festoon (a string of small lanterns): a walk-through archway on its own deck in the theme's lantern style, carrying a Trapline checkpoint (`checkpoint = false` for none) | `gate` | | crumble | stairs (rising flight), run (level row over a gap), zigzag (alternating steps): platformsKit crumble platforms that shake, break and come back, in a frame of the course look | `crumbleStair` | | wind | updraft (one platformsKit fan lifts you to a higher landing), fans (two air columns to hop between), crosswind (a `courseKit.Wind` tunnel blows you along and holds you up across a 9 m gap) | `windGap` | `Course.place(kind, variant, name, at, yaw, opts)` builds any of them at a standard size and answers `{ exit, yaw, tops }`, so pieces chain. Every walkable part has a box collider a CharacterController stands on and records its footprint for `killUnder`; `opts.net = true` (or a table of `killUnder` options) also puts a Trapline safety net under that one piece. **Themes** (`Course.setLook(name)`, or `setDefaults({ theme = name })`): `storybook` (toon planks, carved rims, trail signposts, iron lanterns), `alpine` (snow-topped wood, snowy signposts, timber lanterns, lake), `candy` (pink frosting, cream piping, candy canes, lollipop signs), `ruins` (weathered stone, mossy edge stones, stone tablets, braziers), `scifi` (metal plates, glowing edges, holo panels, light pylons), `desert` (sandstone on masonry piers). A theme sets every family at once: deck, sign, lantern, water, platform re-skin and platformsKit look. Single deck looks (`snowTop`, `timber`, `mossyStone`, `ice`, `floe`, `ropePlank`, `meadow`, `industrial`) can be picked per piece with `{ look = ... }`, and `defineLook` / `defineLantern` add your own. ## Also in the kit - `deck`, `ramp`, `pillar`, `water`: walkable parts with box colliders; `top`/`rim`/`post` override materials per piece. - `killStrip` / `killUnder`: Trapline KillZone safety nets; `killUnder` sizes itself from the footprints every walkable piece records (since `beginRun`, or a list of pieces). - `sign`: alpineProps carved trail signposts, or `courseKit.SignBoard` lettered boards (board, stone, candy, scifi). - `lanternPost`: six built-in lantern styles or your own model (`defineLantern`). - `prop`, `trees`, `props`: alpineProps / forestProps toon props along the course. - `platform`: a platformsKit platform in the theme's look; `reskin` / `courseKit.Reskin` dresses one in a course material set (e.g. `floe`: snow top, teal ice body). ## What is inside - `api.module`: the front door (`courseKit.api`). - `pieces.module`: climbs, ledges, slides, gaps, arenas, spiral climbs, lantern gates, crumble stairs, wind gaps, `place`. - `parts.module`: decks, ramps, stairs, bridges, pillars, water, kill strips, signs, lanterns, props, platforms. - `core.module`: look defaults, frames, box parts, footprints. - `looks.module`: the look catalog (themes, deck/water/sign/lantern/re-skin looks, the material palette). - `Slide.component`, `Wind.component`, `Reskin.component`, `SignBoard.component`. - `materials/`: candy, sci-fi, rope, lantern glow, lava, snow deck and ice floe materials. - `courseKit.testSuite`: tests; `guides/`: how to build a course. Depends on platformsKit (and the Trapline it brings), alpineProps, forestProps (alpineProps' sign lettering is built with its `Geo` module) and toonMaterials; optional material collections (woodsMaterials, stoneMaterials, groundMaterials, alpineMaterials, animatedMaterials) are used when installed. The world "Course Blocks" shows every kind, one theme column at a time (set `THEME` in its build), in its `courseShowcase` scene.
▲ 0↑ born
backing path · courseKit.package/pieces.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

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.