Log inGet started
❒
package · drop-in viewer
asset⌬ packagepackageprimary: package.yaml·originates fromworld 7ea2eaa5-f…

pocketPutt

The game code of Pocket Putt Islands: a six-hole flick-to-putt mini golf round on floating tropical islands, for touch, mouse and gamepad, played alone or with friends in one shared round. Everything general lives in installable kits; this package holds only what is Pocket Putt's…

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

pocketPutt 0.7.5

The game code of Pocket Putt Islands: a six-hole flick-to-putt mini golf round on floating tropical islands, for touch, mouse and gamepad, played alone or with friends in one shared round. Everything general lives in installable kits; this package holds only what is Pocket Putt's own. Rules and design notes: /source/design/spec.md.

What it is built from

Part of the gameComes from
Drag back from the ball to putt (aim line, power arc, cancel, touch / mouse / gamepad), putter stylesflickShot (FlickShot, preset golfPutt)
The chase camera, the island-to-island sweep and the title orbitflickShot ShotCam
Greens, rails, bumpers, windmills, blockers, ramps, sand, water, cups and flags (theme pocketTropical, rounded ends, striped tee)puttCourse pieces and themes
The round: whose hole, strokes, water penalties, the stroke cap, stars, everyone moving on together, the ranking, and keeping every player's device in stepputtCourse round (one shared, synced round)
Title and pause menusmenusKit
Saved level, XP, unlocks and best roundsaveKit
Screen shakejuiceKit
Confetti on a hole in onetrophyKit (with our own matte confetti material)
Palms, flowers and island dressingtropicalKit (tropicalProps)
Toon water, sea and surfacesanimatedMaterials, toonMaterials
Sky and music/ambiencepaintedSkies, soundstage

Modules

ModuleRequireWhat it does
rulespocketPutt.rulesConstants: pars, the stroke cap, ball physics, camera framing, colours, star rule, XP and putter styles, event names
holespocketPutt.holesThe six hole layouts (puttCourse pieces) and their tee, cup and heading
coursepocketPutt.courseBuilds the islands, greens, sea and dressing (called from the scene build)
roundpocketPutt.roundCreates the shared puttCourse round and does Pocket Putt's part for this player: the ball's cup / water / at-rest checks reported to the round, the tee and cup placement, the ShotCam sweep between islands, XP and the saved best round, and the game events the screens hear
screenspocketPutt.screensHUD, hole toasts, hole in one, scorecard, results, friends panel, sounds
play/PuttBallcomponent pocketPutt.play.PuttBallThe ball's look, the name tag over other players' balls, the ball sinking into the cup

Multiplayer

Every device creates the same puttCourse round (id = "pocketPutt", players = "peers", waitForAll, joinAt = "current"). The owner of its synced PuttRound_pocketPutt entity is the one authority: it counts every stroke and penalty, finishes holes, moves the whole group to the next hole at the same moment and ranks the round, and the other devices read that state. Each player's ball is their own avatar body, simulated on their own device, and a friend who joins mid-round starts on the hole the group is playing.

What players can expect today:

  • Everyone who joins gets their own ball, appears on the scorecard and is ranked at the end.
  • A device that joins a round already running (it opens the game after the round was set up) reads the round's current state, so it shows the same hole and scorecard as the others.
  • A device that already had the engine running when the round was set up can end up showing a different state from the others because of engine issue 19356: an older hole, an empty or stale scorecard, or another player's ball in the wrong place. Its own putts still count (they go to the authority), and the authority still moves the group on, but that screen may not show it. Reloading the game on that device makes it join fresh and show the shared round. Until the issue is fixed, the game does not guarantee that every device always shows the same scorecard.

Performance on a tablet

On an Android tablet the game runs at about 24 to 26 frames a second (about 40 ms a frame, occasional spikes near 90 ms when a putt starts), measured at the tablet's default render scale of 0.76. That rate is set by the engine (issue 26275), not by the game's own scripts. Putting stays accurate at that rate because the drag is read every frame; the camera and the rolling ball look less smooth than at 60. A desktop browser runs faster.

Changes

  • 0.7.5: README: what players can expect in multiplayer while engine issue 19356 stands, the tablet frame rate (issue 26275), version and changes. Uses flickShot 1.2.4 and puttCourse 1.3.2 (documentation releases).
  • 0.7.4: the round runs on puttCourse's shared round (one synced authority; everyone on the same hole, moving on together); the camera is flickShot's ShotCam (the game's own ChaseCam is gone).
  • 0.7.3: bumper and rail knocks play again (the knock read the ball's speed in a way that threw on every contact); flickShot 1.2.2 for the browser mouse.

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.

177+items
·
soundclip · born here
❒asset
# ambience Pocket Putt Islands: a 20 s seamless loop of gentle shore waves, a light breeze and distant seagulls. Played by `pocketPutt.audio.sound` under the music at 0.55 volume whenever the music runs.
▲ 0↑ born
·
soundclip · born here
❒asset
# bumper Pocket Putt Islands: a short (0.6 s) rubbery cartoon boing. Played by `pocketPutt.audio.sound` when a ball hits a course bumper.
▲ 0↑ born
·
soundclip · born here
❒asset
# cupdrop Pocket Putt Islands: a golf ball dropping into the plastic cup and rattling. Played by `pocketPutt.audio.sound` as `cup` whenever any player holes out.
▲ 0↑ born
·
soundclip · born here
❒asset
# fanfare Pocket Putt Islands: a short bright cartoon brass-and-xylophone victory fanfare. Played as `fanfare` on a hole in one and when the results come up.
▲ 0↑ born
·
soundclip · born here
❒asset
# putt Pocket Putt Islands: a crisp putter tapping the golf ball. Played as `putt` on each of the local player's strokes.
▲ 0↑ born
▣
module · born here
❒asset
# sound Pocket Putt Islands audio. `Sound.play(name, opts?)` plays a game sound by name: `putt`, `cup`, `splash`, `fanfare` (this folder's generated clips, registered with soundstage's `Sfx.define`), `rail`, `bumper`, `birdie`, `par`, `star`, and UI `click`/`confirm`/`back`/`open`/`notify` (soundstage banks); `opts.at` positions it. `Sound.music(state)` runs soundstage's cartoon set (marimba/ukulele): `menu`, `explore`, `action`. Called by `pocketPutt.ui.ScreensHost`.
▲ 0↑ born
·
soundclip · born here
❒asset
# splash Pocket Putt Islands: a golf ball plopping into water. Played as `splash` when a ball lands in water (+1 penalty).
▲ 0↑ born
·
soundclip · born here
❒asset
# windmill Pocket Putt Islands: a 4 s loop of a wooden windmill creaking and its blades whooshing. Played by `pocketPutt.audio.sound` as a small positional zone (full within 1.5 m, fading over 7 m) on each spinning windmill.
▲ 0↑ born
▣
module · born here
❒asset
# course Builds the Pocket Putt course into the main scene. `build(root)` is called once by `scenes/main.scene/build.luau` and bakes, per hole: a `Hole<i>` entity at `Holes.tee(i)` carrying `pocketPutt.course.HoleIsland` (which builds the puttCourse pieces and island body on every machine), the `Cup<i>` trigger sphere (radius `Rules.CUP_RADIUS`) at `Holes.cup(i)`, a `Water<i>_<k>` trigger box with attribute `pp.water = true` over each pond, and the island's palms, hibiscus, bushes and shells (tropicalProps, toon look). It also places the turquoise toon `Sea`. `defineSurfaces()` is runtime-only (called by the scene entrypoint): it defines the `Rules.SURFACES` physics surfaces and tunes puttCourse's turf / sand / rail / bumper surfaces to them.
▲ 0↑ born
◇
component · born here
❒asset
# HoleIsland Builds one hole's island on this machine. It sits on each `Hole<i>` entity that `pocketPutt.course.build` places in the main scene; field `hole` (1..6) picks the hole from `pocketPutt.holes`. On awake (edit and play, every peer) it calls `pocketPutt.course.islands.build`, which spawns the puttCourse pieces (tee, rails, obstacles, cup + flag) and the island body as local temporary children, and rebuilds when the field or a module it uses changes. Needs no sibling components; the `Cup<i>` and water triggers are separate baked children.
▲ 0↑ born
◇
component · born here
❒asset
# SeaSurface The turquoise toon sea of Pocket Putt Islands. Sits on the baked `Sea` entity that `pocketPutt.course.build` places; on every machine it builds one flat square (`size` m, default 320) whose UVs repeat every `tile` metres and draws it with the course's own `seaWater` (animatedMaterials' toon water shader, tuned turquoise). A runtime mesh cannot be baked into a scene file, so the component rebuilds it on load as a local temporary child. No sibling components needed.
▲ 0↑ born
▣
module · born here
❒asset
# islands The floating island under each Pocket Putt hole. `outline(i)` (the wavy sand outline around the hole's tiles) and `dressing(i)` (where palms, flowers, grass and shells stand) are deterministic maths the scene build reads. `build(i, holeEntity)` runs on every machine from the `HoleIsland` component: it builds the hole's puttCourse pieces in the game's `pocketTropical` theme (tropicalIsland recoloured to the references: lime felt, wooden rails, coral windmill with yellow roof, coral bumpers, turquoise ponds) and one merged low-poly island mesh (sand top and banks, grey rock cliff ring, grass patches, rock underside) plus a shore mesh (shallows and white foam rings), all local temporary children with the toonMaterials ink outline. `destroy(handle)` takes it down.
▲ 0↑ born
◐
material · born here
❒asset
# seaWater The turquoise lagoon sea of Pocket Putt Islands: animatedMaterials' `animWater` toon water shader with brighter turquoise water, a pale aqua bed, lighter foam and a slow drift, tuned to the floating-island references. Worn by the `SeaSurface` component's sea plane.
▲ 0↑ born
▣
module · born here
❒asset
# holes The six holes of Pocket Putt Islands, one per floating tropical island: name, par (2,3,3,3,3,4 = 18), island origin + yaw, and a declarative `layout` of puttCourse pieces on the 2 m tile grid (tee, lanes, curves, windmill, sliding blocker, bumpers, ramp, sand, water, cup). The cup position and the obstacle list are derived from the layout, so they always match what is built. World helpers: `get(i)`, `all()`, `COUNT`, `tee(i)`, `cup(i)`, `forward(i)`, `teeForward(i)`, `rotation(i)`, `toWorld(i, x, y, z)`, `toOffset(i, x, y, z)`, `tileCentre(entry)`, `totalPar()`. Read by `pocketPutt.course` (builds the islands), the main scene build (spawn + camera pose), the round (tees, cups, fly-over) and the screens (par, hole names). Fields are only ever added, never renamed.
▲ 0↑ born
◇
component · born here
❒asset
# PuttBall One player's golf ball and scorecard. `pocketPutt.round` adds it to the local player's avatar (the BallPlayer prototype's `ball` body, which also carries `Physics`, `SphereCollider` and `flickShot.FlickShot`). Its Sync fields (`playerName`, `seat`, `hole`, `strokes`, `done`, `waters`, `roundOver`, `roundId`) are the card, written only by the owning peer and replicated to all. On every peer it dresses the ball (GolfBall dimpled mesh in the seat's colour plus a stripe band), sinks the look into the cup once holed, and floats a name tag over other players' balls; on the owner's peer it drives `Round._tick`.
▲ 0↑ born
△
mesh · born here
❒asset
# ballBanded The player's golf ball from the `golf_ball` reference: a smooth sphere one unit across (radius 0.5) with a coral-pink band around its equator (13% of the diameter, crisp edges), 1920 triangles. The band is vertex colour (the pbr shader multiplies base colour by it); UVs wrap the sphere 3x around and 1.5x pole to pole so `pocketPutt.play.ballGloss`'s hex-dimple texture reads as many small dimples. Built procedurally in engine (not generated) to stay low-poly and exact: under the `ball` body's 2*`Rules.BALL_RADIUS` scale it is exactly the physics ball. Worn by `BallLook` in `PuttBall`, replacing the old GolfBall mesh + `BallStripe` cylinder. Other seats tint the whole ball to their colour, which mostly hides the band.
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
▦
texture · born here
❒asset
▲ 0↑ born
▦
texture · born here
❒asset
# nameTagPill The friend name-tag badge from the gameplay reference: a deep green rounded pill with a cream rim, a soft drop shadow and a small pointer underneath, on a transparent background (512x128 sprite, clamped). Painted procedurally (signed-distance pill), not generated, so its edges and alpha are crisp. Worn through `pocketPutt.play.nameTagPillMat` by the `BallNameTagPill` box that `PuttBall` puts behind each other player's `BallNameTag` text.
▲ 0↑ born
◐
material · born here
❒asset
# nameTagPillMat Unlit, alpha-blended material showing `pocketPutt.play.nameTagPill`: the name-tag pill behind a friend's ball name. No depth write, queue 3000, so it never occludes the white name text drawn in front of it and costs one cheap unlit draw per ball. Used by `PuttBall` (`BallNameTagPill`, a paper-thin cube turned to the camera with its `BallNameTag` parent).
▲ 0↑ born
▣
module · born here
❒asset
# round The Pocket Putt round: every player's ball, strokes, water penalty (+1, back to where the putt started), the par+3 cap (ball placed in the cup), cup detection, per-player scorecards, the hole-to-hole camera fly-over, the round-end ranking (`Rules.rank`) and the saved best round (saveKit). Called by the main scene's entrypoint (`Round.start()` / `Round.stop()`); the screens slice reads it (`currentHole`, `cards`, `localCard`, `players`, `strokes`, `waiting`, `bestTotal`, `results`, `newBest`) and drives it (`pause`, `restart`). Listen to `Rules.EVENTS` with `Round.on(event, fn)`; events fire on every peer for every player, read from the replicated `pocketPutt.play.PuttBall` cards. Putting is `flickShot` preset `golfPutt` attached to the local player's ball.
▲ 0↑ born
▣
module · born here
❒asset
# pocketPutt.rules Shared constants and scoring rules for Pocket Putt Islands, read by every part of the game (course, round, screens, chase camera). - Round shape: `HOLE_COUNT` (6), `MAX_PLAYERS` (4). - Strokes: a hole caps at par + `CAP_OVER_PAR` (3), then the ball is placed in the cup; water costs `WATER_PENALTY` (1). - Ball: radius, mass, rest detection and maximum putt speed (the flickShot `golfPutt` preset is scaled to it). - `SURFACES`: physics surfaces (green, sand, rail, bumper, wood) with friction, restitution and rolling resistance. - Stars per hole (3 for hole-in-one or under par, 2 for par, 1 over par) and the ranking order (lowest total, then most stars). - Camera settings, ball colours per player, the palette and the event names the slices share. ```lua local Rules = require("pocketPutt.rules") print(Rules.HOLE_COUNT, Rules.CAP_OVER_PAR) ```
▲ 0↑ born
▣
module · born here
❒asset
# screens Every screen and sound of Pocket Putt Islands, started by the main scene's entrypoint: `Screens.start()` in play (after `Round.start()`), `Screens.stop()` on unload. `start()` spawns one local, temporary entity carrying `pocketPutt.ui.ScreensHost`, which owns the screens (so their buttons' callbacks have an owner) and listens to `pocketPutt.round`'s `Rules.EVENTS`. `host()` answers that entity. What the player gets: - **Title** (menusKit, custom look `pocketPutt`): bubbly yellow/coral POCKET PUTT ISLANDS logo with a golf-ball dot over the live archipelago, big lime PLAY and turquoise FRIENDS pills, a turquoise settings gear in the corner (menusKit settings: music/effects volume, language, controls). - **HUD**: HOLE n · PAR n pill, STROKES n pill, other players' progress, a big coral pause button and a turquoise scorecard button; "waiting for friends" while others finish. - **Pause** (menusKit): Resume, Scorecard, Restart, Settings, Main Menu. Escape / P / pad Start also pause. - **Hole result toast**: HOLE n banner on each tee; BIRDIE!/PAR/BOGEY... with 1-3 stars when you hole out; SPLASH! +1 on water; short notices for friends. - **Hole in one**: rotating sun rays, big yellow HOLE IN ONE!, three popping gold stars, trophyKit confetti burst at the cup, juiceKit heavy shake and a fanfare. - **Scorecard**: every player's strokes on every hole (puttCourse `tropicalWood` scorecard style), from the HUD, the pause menu or the results. - **Results**: holes 1-6 par / strokes / to-par chips (green under, yellow level, coral over), total, round stars (`Rules.roundStars`), saved best round with a NEW BEST! badge, every player ranked with gold/silver/bronze medals, PLAY AGAIN (`Round.restart`). - **Sound**: `pocketPutt.audio.sound` (soundstage cartoon music: menu on the title, explore while putting, action on the results; putt, cup, splash, fanfare, rail/bumper knocks, UI clicks). Touch, mouse and gamepad: every button is a big pill; overlays hold the pointer so a pad's d-pad/stick moves focus and `south` presses. Layouts adapt to portrait and landscape and stay inside `ui.safeArea()`.
▲ 0↑ born
◇
component · born here
❒asset
# ScreensHost The Pocket Putt Islands screen host. `pocketPutt.screens.start()` spawns it on a local temporary entity at play start; it needs no sibling components and has no fields. It registers and updates the HUD (`pp_hud`), hole toast (`pp_toast`), hole-in-one banner (`pp_ace`), title gear (`pp_gear`) and one overlay screen (`pp_overlay`: results, scorecard or friends), rebuilding a screen only when what it shows changes. It drives menusKit's title and pause (look `pocketPutt`), pauses the round while a menu is up, plays music and sounds through `pocketPutt.audio.sound`, and on `pp.holeInOne` fires trophyKit confetti at the cup and a juiceKit shake. Button callbacks (`pp_pause`, `pp_card`, `pp_card_close`, `pp_friends_close`, `pp_settings`, `pp_again`) land in its `onCallback`.
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
▦
texture · born here
❒asset
# logo The POCKET PUTT ISLANDS title logo: bubbly yellow letters with a coral outline, a white sticker rim and the white golf-ball dot on the "i". Cut from the title-screen reference (`design/references/title_screen`, 630x500 crop at 450,60) with the sky keyed out by a flood fill that stops at the white rim, so it is the reference art itself. Stored as a 512 px, premultiplied-alpha sprite (the UI composites premultiplied; straight alpha leaked the keyed colour as a halo). Used by `pocketPutt.ui.look` `Look.logo` (title screen via the menusKit `pocketPutt` look) as an `image` widget; if the texture does not resolve, `Look.logo` falls back to the text-widget logo.
▲ 0↑ born
▣
module · born here
❒asset
# look The Pocket Putt Islands UI look: palette (`C`), fonts, and the authored pieces the screens are built from — toy pills and pill buttons, gold SVG stars, to-par chips (green/yellow/coral), gold/silver/bronze medals, player ball dots and the bubbly POCKET PUTT ISLANDS logo. `defineMenus()` registers the menusKit look `pocketPutt` (cartoon base, lime/turquoise/coral pills, our logo, a light sky wash over the live scene). Used by `pocketPutt.ui.views` and `pocketPutt.ui.ScreensHost`.
▲ 0↑ born
▣
module · born here
❒asset
# views Pure widget-tree builders for Pocket Putt Islands: `hud`, `toast`, `holeInOne`, `results`, `scorecard` (puttCourse `tropicalWood` style, all players), `friends` and the title `gear`. Each takes its data plus the canvas size and safe area and returns a full-screen tree that lays out for portrait and landscape. `pocketPutt.ui.ScreensHost` registers what they return.
▲ 0↑ born
❒
package · born here
❒asset
# puttCourse 1.3.2: mini golf course kit Build mini golf holes from a short declarative description. 23 low-poly pieces on a 2 m grid, six themes switched by one setting, five flag styles, four cup effects, a multi-player strokes-vs-par scorecard in six styles, a multi-hole stroke-play round module (strokes, penalties, par cap, stars, ranking, one synced authority), and ball behaviour on the engine's own physics (colliders, physics surfaces with friction / restitution / rolling resistance, triggers) that turns into events naming the ball and its player. Multiplayer-safe and tuned for phones and tablets. Ships PuttHole / CoursePiece components for scene authoring, a live gallery scene, a test suite and two guides. Installing gives a world: `puttCourse.course` (the API below), `puttCourse.pieces`, `.themes`, `.flags`, `.effects`, `.scorecard`, `.geom`, `puttCourse.round` (stroke play, below), the `PuttHole`, `CoursePiece`, `CourseRuntime`, `PuttGallery`, `RoundState` components, `puttCourse.gallery` scene (6 theme rows of all 23 pieces, the 5 flag styles, the 4 cup effects replaying, the 6 scorecard styles cycling on screen), the `puttCourse` test suite (32 tests, run in edit mode: `tools.use("tests", "run", { suite = "puttCourse" })`) and the guides `how-to-build-a-mini-golf-course` and `example-make-a-three-hole-mini-golf-game`. Depends on platformsKit (motion maths), animatedMaterials (toon water, conveyor belts) and optionally juiceKit (sparkle / confetti VFX). ## Quick start ```lua local Course = require("puttCourse.course") Course.setTheme("candyCartoon") -- THE one theme setting local hole = Course.buildHole({ id = "h1", number = 1, par = 3, origin = { 0, 0, 0 }, pieces = "tee 0 0; straight 0 1; sand 0 2; windmill 0 3; curve 0 4; cup 1 4 rot=90", }) local ball = Course.spawnBall({ hole = hole, colour = "#ff5d5d" }) -- on the tee, owned by this machine Course.shoot(ball, 0, 1, 3.5) -- direction (x, z), speed m/s → physics impulse hole:on("ballInCup", function(ev) print(ev.player, ev.strokes) end) ``` ## Grid and frame - Tile = **2 m × 2 m** (`Course.TILE`), turf top at y = 0 of the tile, slab 0.3 m thick, rails 0.12 m wide × 0.16 m high, cup radius 0.15 m. - Entry `{ kind, gx, gz }` puts the tile centre at `origin + (gx*2, y, gz*2)`. A ball enters a piece on its local −Z side and leaves on +Z; `curve` / `corner` leave on +X (`mirror=true`, or `curveLeft` / `cornerLeft`, leave on −X). `rot` = degrees about up (90 turns +Z to +X). `y=` raises a tile (after a `slope h=0.5`, put the next tile at `y=0.5`). - The tee anchor is 0.45 m behind its tile centre; the cup is 0.3 m ahead of its tile centre. ## Pieces (`Course.PIECES`) `tee, straight, curve, corner, slope, slopeDown, ramp, loop, bridge, tunnel, wall, windmill, blocker, bumper, spring, sand, ice, water, conveyor, teleporter, funnel, cup, flag` Aliases: launchPad/launch→spring, rail/border→wall, start→tee, hole→cup, curveLeft/curveRight→curve, cornerLeft/cornerRight→corner, portal→teleporter, jump→ramp, bunker→sand, pond→water, belt→conveyor, spinner→windmill, slider→blocker. Per-piece settings (in a layout `key=value`, or a table entry): slope/slopeDown/ramp `h`; ramp `jump`; wall `len`, `h`; windmill `speed` (deg/s, 55), `offset` (s), `stripes`, `stripeCount`; blocker `speed` (m/s), `span`, `wait`, `offset`; bumper `kick` (m/s, 2.2), `spots`; spring `power` (4.5), `up` (3.2); conveyor `speed` (1.4, negative = backwards), `cross`; teleporter `link` ("A"), `role` (in|out|both); funnel `depth`; loop `radius`; bridge `width`; cup/funnel/flag `flagStyle`, `number`. `Course.pieces.DESCRIPTIONS[kind]` describes each. Any setting may be a table (`spots = {{-0.5, 0.1}, {0.5, 0.1}}`, `stripes = {"#ff6f61", "#ffffff"}`): the piece cache is keyed on every setting, tables included, so two holes with different bumper layouts get their own pieces (no unique tag needed). ### Jump ramp `ramp` alone is a 0.26 m kicker: a fast ball hops off it, and a full-width water tile is too wide for it. `ramp jump=true` is a 0.34 m jump ramp with a kick zone from its foot to its lip: a ball moving forward into it at `minSpeed` (1.5 m/s) or more leaves at `up` (3.2 m/s) climb with its forward speed held between `carry` (5) and `maxCarry` (6) m/s. That flies about 3.2 m from the foot, so it clears the next tile: a `water` tile, or a `bridge` you mean to be jumped. A slower ball rolls back down. The kick fires `ballLaunched` with `jump = true`. ```lua "tee 0 0; straight 0 1; ramp 0 2 jump=true; water 0 3; straight 0 4; cup 0 5" ``` ### Striped windmill `windmill stripes={c1, c2}` bands the tower (the feet and the body) in `stripeCount` (6) horizontal stripes of the two colours (hex strings or `{r, g, b}`). `stripes=true` takes the theme's `house` and `houseStripe` (else `roof`). A theme that sets `houseStripe` stripes its windmills by default (`candyCartoon` does), and `stripes=false` turns that off. The stripes are vertex colours in the same merged mesh: a few more quads, no extra draw call, nothing per frame. ```lua { "windmill", 0, 2, stripes = { "#ff6f61", "#ffffff" } } -- coral and white Course.themes.define("myIsland", { base = "tropicalIsland", houseStripe = "#ff6f61" }) ``` ## Themes, flags, cup effects, scorecards - Themes (`Course.THEMES`): `tropicalIsland, candyCartoon, pixel, neonSciFi, stoneRuins, cozyGarden`. `Course.setTheme(name)` switches every hole built without its own `theme` (rebuilt at once). `Course.themes.define(name, spec)` adds one. - Flag styles (`Course.FLAG_STYLES`): `classic, numbered, pirate, tropical, neon`. A theme's optional `flagCloth` hex recolours the classic pennant (e.g. `flagCloth = "#ffd23a"` for a sunny yellow one). - Rounded greens and a striped tee: a theme with `roundEnds = true` gives every closed lane end (the tee, the cup, a dead end) rounded corners, curved wooden rails joining the side rails to the end rail, with the corner outside the curve painted in the theme's `edge` colour, so a straight hole reads as a soft stadium-shaped green instead of a box. `teeStripe` (a hex colour) turns the tee mat into bands of `teeMat` and `teeStripe` with a `teeStripe` frame. Both are off in the six built-in themes, so they look as before; turn them on with `Course.themes.define("myTheme", { base = "tropicalIsland", roundEnds = true, teeStripe = "#ffffff" })`. - Cup effects (`Course.CUP_EFFECTS`): `sparkle, confetti, glowRing, splash` (and `none`). - Scorecard styles (`Scorecard.STYLES`): `classicPaper, tropicalWood, neonArcade, pixelArcade, candyPop, parchment`. ## API: `puttCourse.course` | Call | What it does | |---|---| | `buildHole(desc) → hole` | Build a hole. desc: `id`, `number`, `par`, `theme` (nil = follow setTheme), `origin {x,y,z}`, `yaw`, `parent` (entity), `flagStyle`, `cupEffect`, `waterPenalty` (1), `autoReset` (true), `killDepth` (4), `pieces` = layout string or list of `{ kind, gx, gz, rot=, y=, mirror=, ...settings }`. **Idempotent**: the same id replaces the old hole. | | hole handle | `id, number, par, theme, tee {x,y,z}, cup {x,y,z}, pieces, root, colliderCount`, `hole:on(event, fn) → off`, `hole:destroy()`, `hole:rebuild(theme?)`, `hole:setTheme(name)`, `hole:teePosition()`, `hole:cupPosition()` | | `spawnPiece(kind, opts) → piece` | One piece: `theme, position, rot, mirror, parent, name` + settings. Handle `{ id, kind, root, anchors, position, worldRot, destroy() }` | | `parseLayout(text)` | `"tee 0 0; cup 0 3 rot=90"` → entries | | `hole(id)`, `holes()`, `clear()` | Look up / remove everything this machine built | | `setTheme(name)`, `theme()` | The one course-wide theme setting | | `spawnBall(opts) → entity` | `hole` (placed on its tee), `position`, `player`, `colour`, `radius` (0.07), `synced` (play: true), `name` | | `registerBall(entity, {player, hole})` | Make your own body a course ball (needs a collider + dynamic Physics) | | `shoot(ball, dx, dz, speed)` | Impulse + roll, counts a stroke, emits `ballStruck`. Owner only. | | `resetBall(ball, pos?, reason?)`, `placeBall(ball, hole)` | Back to last shot / onto a tee (strokes 0) | | `ball(ball)` | `{ id, player, hole, strokes, sunk, stopped, lastShot, lastSafe }` | | `ballSpeed(ball)`, `removeBall(ball)` | | | `on(event, fn, holeId?) → off` | Listen (`"*"` = all) | | `emit(name, ev)` | Fire locally and to every peer | | `now()` | Shared clock (`multiplayer.sessionTime()`) | | `setSurface(name, values)` | Tune `turf, rail, sand, ice, bumper, ball` physics surfaces | | `paramKey(kind, theme, settings)` | The piece cache key: kind, theme and every setting (tables serialised in a stable order; position/parent/hole left out) | | `clearPieceCache()` | Forget cached piece descriptions and meshes (the cache outlives a module reload: call it after editing piece code or a theme in a running session, then rebuild) | | `SAND_DAMPING`, `ICE_GLIDE`, `CONVEYOR_GRIP` | Zone tuning numbers | Components: `PuttHole` (fields `holeId, number, par, theme, layout, flagStyle, cupEffect, waterPenalty, autoReset`; `:handle()`, `:rebuild()`), `CoursePiece` (`kind, theme, mirror, settings, flagStyle, number`; `:handle()`). Scorecard: `Scorecard.new(pars, players) → card` (`card:addPlayer{id,name,colour}`, `card:record(playerId, holeIndex, strokes)`, `total`, `toPar`, `leader`, `par`), `Scorecard.render(cardOrPlayers, pars?, style, {width, title, current}) → widget tree`, `Scorecard.show(...)`, `hide()`, `isShown()`, `onCallback(id)`. ## Events (`Course.EVENTS`) Every event is a table: `event, ball` (entity id), `player` (peer id or your value), `hole` (id), `holeNumber, par, piece` (kind), `pieceId, position {x,y,z}, strokes`, plus `remote=true, fromPeer` when it came from another machine. | Event | Extra fields | |---|---| | `ballInCup` | `speed` | | `ballInWater` (older name `ballEnteredWater` still delivered) | `penalty, resetTo`: with autoReset the ball goes back after 0.7 s and `ballReset{reason="water"}` follows | | `ballOnSand` / `ballLeftSand`, `ballOnIce` / `ballLeftIce`, `ballOnConveyor` / `ballLeftConveyor` | | | `ballBumped` | `bumper` (index) | | `ballLaunched` | `power, up` (`jump = true` from a jump ramp) | | `ballTeleported` | `to, link` | | `ballHitWindmill`, `ballHitBlocker` | | | `ballOutOfBounds` | `penalty` (below `origin.y - killDepth`) | | `ballStruck` | `speed, direction` | | `ballStopped` | (at rest 0.35 s) | | `ballReset` | `reason` (water, outOfBounds, placed, manual) | ## Hazards and resets - Water and out of bounds penalise a ball once per visit: two touching water tiles cost one penalty; the ball can be penalised again only after it is reset, shot or placed. A sunk ball is never penalised. - The ball goes back after `Course.RESET_DELAY` (water 0.7 s, out of bounds 0.3 s), in edit and in play, to the spot the hole's `resetTo` rule picks: `"lastShot"` (default, where it was hit from), `"lastSafe"` (its last rest spot) or `"tee"`. - Out of bounds: falling below `origin.y - killDepth`, or (unless `bounds = false`) leaving the pieces' footprint plus `boundsMargin` (1.5 m) sideways. `outPenalty` defaults to `waterPenalty`. - Your own triggers become hazards with `Course.addZone(entity, "water" | "out" | "cup" | "sand" | "ice", opts)` (or `addWaterZone`). `Course.penalize(ball, reason, opts)` and `Course.checkBall(ball)` judge by hand. - A ball your own controls shoot counts through `Course.noteShot(ball)` (call it just before the impulse): stroke, `lastShot` and `ballStruck`. ## Stroke-play round: `puttCourse.round` ```lua local Round = require("puttCourse.round") local round = Round.new({ id = "main", holes = { h1, h2, h3 }, players = "peers", maxOverPar = 3 }) round:on("holeFinished", function(ev) print(ev.player, ev.strokes, ev.toPar, ev.stars, ev.holeInOne) end) round:on("roundFinished", function(ev) print("winner", ev.ranking[1].player) end) ``` Every player plays at the same time, each on their own current hole. Strokes come from the course balls on their own (`ballStruck` +1, `ballInWater` / `ballOutOfBounds` + the penalty, `ballInCup` finishes the hole, `ballStopped` ends a capped hole); events from a hole that is not the player's current hole are ignored. Games without course balls call `shot`, `penalty`, `holed` themselves. | `Round.new(opts)` option | Default | What it does | |---|---|---| | `id` | `"round"` | Same id on every machine; a new round with a live id replaces it | | `holes` | | Ordered hole handles or ids (`pars = {...}` for ids not built yet) | | `players` | `{}` | List of ids or `{ id, name, colour }`, or `"peers"`: every machine joins and leaves with the session | | `maxOverPar` | `3` | Cap = par + N strokes (`false`: no cap). At the cap the hole finishes when the ball stops, hits a hazard or after `capDelay` (6 s); the ball is put in the cup | | `stars` | `{ holeInOne = 3, under = 3, par = 2, over = 1, capped = 1 }` | Table rule or `function(strokes, par, { holeInOne, capped }) -> number` | | `waitForAll` | `false` | A player who holed out waits until every active player has finished that hole; then the whole group starts the next hole at the same moment (after the last finisher's `advanceDelay`) | | `advanceDelay` | `1.5` | Seconds between finishing a hole and the next `holeStarted` | | `placeBalls` | `true` | Each machine puts the balls it owns on their player's next tee (and in the cup when capped) | | `joinAt` | `"first"` | `"current"`: a late player starts at the lowest hole being played, earlier holes scored at the cap with 0 stars (`"skipped"`) | | `listenCourse` | `true` | Count strokes from the course ball events | | `synced` | `true` in play | Keep the state on a synced `RoundState` entity | | `scoreKit` | `nil` | Pass `require("scoreKit.score")` and the stars won on each hole go to the player's score (the round never requires scoreKit) | | `autoStart` | `true` | `false`: call `round:start()` | Round handle: `on(event, fn) -> off`, `addPlayer(id, {name, colour})` (a returning player keeps their card; on a player already in the round it updates their name and colour), `removePlayer(id)`, `shot(id)`, `penalty(id, n, reason)`, `holed(id)`, `stopped(id)`, `start()`, `restart()` (everyone still here back to hole 1, `epoch` + 1), `state()`, `player(id)`, `pars()`, `ranking()`, `scorecardPlayers()` (feeds `Scorecard.render(round:scorecardPlayers(), round:pars(), style)`), `isAuthority()`, `destroy()`. Also `Round.get(id)`, `Round.stars(rule, strokes, par, info)`, `Round.rank(players, holeCount)`. A player record in `state().players`: `id, name, colour, hole` (current index, holes + 1 when done), `status` (`playing`, `holed`, `finished`), `left`, and per hole `strokes`, `penalties`, `stars`, `pars`, `result` (`""`, `holed`, `capped`, `skipped`). `state().phase` is `waiting`, `playing` or `finished`. | Round event | Fields | |---|---| | `roundStarted` | `holes, players` | | `holeStarted` | `player, name, hole` (id), `holeIndex, holeNumber, par, strokes` | | `shot` | same as holeStarted, `strokes` so far | | `penalty` | + `penalty, reason` (`water`, `outOfBounds` or yours) | | `holeFinished` | `player, name, hole, holeIndex, holeNumber, strokes, par, toPar, stars, holeInOne, capped, penalties, total` | | `roundFinished` | `ranking`: `{ place, player, name, colour, total, toPar, stars, holes, complete, left }`, lowest total first, then most stars; ties share a place; players who left before the end come last | | `playerJoined` / `playerLeft` | `player, name, hole` (`rejoined = true` on a return) | | `roundRestarted` | `epoch` | Multiplayer model: every machine creates the same round (same id and holes). In play the lowest peer spawns the synced entity `PuttRound_<id>` with a `RoundState` component (`roundId`, `version`, `state`); its owner is the only authority. It applies the rules, writes `state` and sends each round event to every machine once (`ev.remote = true` elsewhere). Other machines read `state()` from the component and send their manual calls to the authority. When the owner leaves, the engine hands the entity to a peer that stays, which carries on from the last written state. Each machine moves only the balls it owns. In edit mode (or `synced = false`) the round is local, which is how the tests run it. ## Multiplayer - Pieces are local temporary entities built from the same description on every peer (never replicated), so build the same holes everywhere (scene component or shared code). - Windmills, blockers and flag sway are posed from `multiplayer.sessionTime()`, so every peer sees the same phase. - A ball is a synced dynamic body owned by the peer that spawned it; only the owner judges zones and sends each event once over `multiplayer.send("puttCourse:ev")`. Any number of balls per hole. ## Known engine issues These are engine problems, not kit bugs, and they stand until the engine fixes them: - **Issue 19356 (synced state on a device that was already running):** a device that already had the engine running when the round was set up can end up seeing a different synced state from the other devices. In this kit that is the round's `RoundState` entity (`PuttRound_<id>`): on an affected device `round:state()`, the scorecard and each player's current hole can show something different from what everyone else sees (an older hole, an empty or stale card), even though the authority is still applying the rules for everyone. Balls are synced too, so another player's ball may also sit in the wrong place there. Round events (`holeFinished`, `roundFinished`, ...) are sent as messages, not as synced state, so they still arrive. Reloading the game on the affected device makes it join fresh and read the current state. Until the issue is fixed, do not promise players that every device always shows the same card. - **Issue 26275 (frame rate on tablets):** on an Android tablet the engine draws a six-island course like Pocket Putt Islands at about **24 to 26 frames a second** (about 40 ms a frame, occasional spikes near 90 ms), measured at the tablet's default render scale of 0.76. The kit keeps its own per-frame work small (below), but it cannot raise that rate; expect smooth-enough putting, not 60 fps. ## Performance (Android tablet) - One merged vertex-coloured mesh per layer per piece (solid / glow / water / belt / mover); meshes cached per kind+theme+settings (every setting, tables included). - A hole's axis-aligned floor and rail boxes are merged (7-tile test hole: 33 boxes → 16 colliders); bumpers are capsules, only the cup liner and funnel bowl are mesh colliders. - Per frame: transform writes only (movers, flag sway, effect parts) into reused tables, no Model tint or `visible` writes (≈27 µs each on Android vs ≈2 µs for a transform). - Sand = linear damping set once on enter; ice/conveyor push from `Physics.onBeforeStep` only while a ball is inside. ## Changes - **1.3.2:** documentation only: title with the version, the test count and suite name corrected, a Known engine issues section (19356, 26275). - **1.3.1:** with `waitForAll` the whole group starts the next hole at the same moment; `addPlayer` on a player already in the round updates their name and colour. Two tests. - **1.3.0:** theme options `roundEnds` (rounded closed lane ends with curved rails) and `teeStripe` (striped tee mat with a frame).
▲ 0↑ born
❒
package · born here
❒asset
# flickShot 1.2.4 **Drag-and-release / slingshot shot controls for any game**: mini golf, pool, curling, paper toss, angry-birds style flings, basketball flicks, bocce. Put one `FlickShot` component on a physics ball (or call `attach`) and the player aims with **touch, mouse or gamepad**. You get a `shot` event with a world **direction**, a **power 0..1** and an **impulse in N·s**, and the kit can push the body itself. Every look and behaviour switches with **one setting**: 8 aim styles, 8 power displays, 7 input modes, 10 feel presets and 4 looks. An optional **ShotCam** chase camera follows the ball, flies between holes and orbits behind a title screen. It builds on the engine. Pointer, touch and pad come from the engine's input state (`Zin.touch`, `Zin.state`). Shots are real `Physics.applyImpulse` calls on the body's own rigid body. Screen-to-world aiming uses `screenToRay`, and bounce and laser previews use `Physics.raycast`. The kit adds the aiming feel, the visuals and the multiplayer rules. ## Guides Two guides ship inside the package. Open them with the `guides` tool or `man`: - **How to add drag-to-shoot slingshot controls to my game** (`flickShot.package/guides/how-to-add-drag-to-shoot-slingshot-controls-to-my-game`) - **Example: build a paper toss game with drag-to-shoot** (`flickShot.package/guides/example-build-a-paper-toss-game-with-drag-to-shoot`) ## Quick start ```lua local Flick = require("flickShot.api") local ball = entity.spawn("Ball", { position = { 0, 0.1, 0 } }) ball.localScale = { 0.2, 0.2, 0.2 } ball.component.add("Model", { model = "sphere" }) ball.component.add("SphereCollider", {}) ball.component.add("Physics", { kind = "dynamic", mass = 0.05, linearDamping = 0.6 }) Flick.attach(ball, { preset = "golfPutt" }) -- drag back, release: it putts Flick.onShot(function(shot) print(shot.power, shot.direction, shot.impulse) -- vectors are Luau `vector`s strokes += 1 end) ``` With no code at all, add **`flickShot.FlickShot`** to the ball in the inspector and pick a `preset`. ## The public API (`require("flickShot.api")`) | Call | What it does | |---|---| | `attach(entity, opts?)` | Adds (or updates) the FlickShot on an entity. `opts` takes any component field and any preset field. Returns the component. | | `detach(entity)` | Removes it, along with its visuals. | | `get(entity)` | The FlickShot component, or nil. | | `setStyle(entity, key, value)` / `setStyle(entity, { ... })` | Switches anything live: `aimStyle`, `powerDisplay`, `inputMode`, `look`, `preset`, `grab`, `maxImpulse`, ... | | `configure(entity, overrides)` | Code overrides for preset fields that have no component field (`aimLength`, `chargePeriod`, `powerCurve`, `dragFraction`, `cancelRadius`, `rollDecel`, `cooldown`, `flickFullSpeed`, `minPower`, `restSpeed`). | | `setEnabled(entity, on)` | Turns shooting on or off (sets `canShoot`). An aim in progress is cancelled. | | `onShot(cb)` | `cb(shot)` for every shot this peer takes. Returns an unsubscribe function. | | `onAimStart(cb)` / `onCancel(cb)` | `cb({ entity, device })`. Return unsubscribe functions. | | `isAiming()` / `aimingEntity()` | True or the entity while a player on this peer is aiming. Use it to block camera drags and other taps. | | `shoot(entity, direction, power)` | Fires from code (AI, replays, tests). | | `settings(entity)` / `resolve(preset, overrides)` | The settings in force, with the preset merged in. | | `presets`, `aimStyles`, `powerDisplays`, `inputModes`, `looks`, `grabModes` | Name lists. `describe(name)` gives one sentence about any of them. `presetData` / `lookData` hold the raw tables. | **The shot record** (`onShot`, `shoot`): `{ entity, direction: vector (unit, world), power (0..1 as aimed), curvedPower (after the preset's curve), impulse: vector (N·s), impulseMagnitude, speed (m/s), mass, origin: vector, device ("touch" | "mouse" | "pad" | "demo" | "code"), inputMode, preset, applied (whether the kit pushed the body) }`. ## The component: `flickShot.FlickShot` | Field | Default | Meaning | |---|---|---| | `preset` | `golfPutt` | The feel preset. See the table below. | | `aimStyle` | `preset` | One of the aim styles, or `preset` to use the preset's choice. | | `powerDisplay` | `preset` | One of the power displays, or `preset`. | | `inputMode` | `preset` | `dragBack`, `dragForward`, `holdCharge`, `flick`, or `preset`. | | `look` | `cartoon` | `cartoon`, `minimal`, `neon` or `pixel`. | | `grab` | `preset` | `ball` (on it), `near` (within `grabRadius` points of its on-screen edge) or `anywhere` on screen. | | `maxImpulse` | 0 | N·s at full power. 0 means the preset's `maxSpeed` times the body's mass. | | `maxSpeed` | 0 | m/s at full power. 0 means the preset's value. | | `loft` | -1 | Degrees of launch tilt above the ground plane. -1 means the preset's value. | | `canShoot` | true | Turn it off between turns. (`enabled` is the engine's own switch for the whole component.) | | `player` | "" | Who may shoot it: a peer id, user id or player name. Empty means the peer that owns the entity. | | `applyImpulse` | true | The kit pushes the body. Off means only the shot event fires. | | `waitForRest` | true | Aim only while the body is nearly still. | | `showOthersAim` | true | Draw other players' aim, faint. | | `showPercent` | false | Add a % readout beside any power display. | | `radius` | 0 | The body radius used to place the visuals. 0 reads it from the entity's scale. | | `aimScale` | 1 | Size multiplier for the aim and power visuals only (the body radius still drives ray hits). 2 doubles them, which reads well on phones. | | `demo` / `demoFires` | false | Gallery mode: aims by itself in a loop when idle, and works in edit mode too. `demoFires` also shoots now and then while in play. | Events: `onShot { direction, power, curvedPower, impulse, speed, device }`, `onAimStart { device }`, `onCancel { device }` (subscribe with `comp.events.onShot:connect(fn)`). Methods: `configure(t)`, `settings()`, `isAiming()`, `shoot(dir, power)`, `cancel()`, `visualCount()`. ## Aim styles (`aimStyle`) | Style | What it draws | |---|---| | `dotted` | A row of dots in the shot direction. More dots for a harder shot. | | `arrow` | A shaft with an arrow head that grows with power. | | `rubberBand` | A slingshot band from two fork points back to the pull point, thinning as it stretches. | | `arc` | The ballistic flight path, from speed, loft and the world's gravity. | | `ghostBall` | A ghost ball where a rolling shot stops (`rollDecel`) or a lofted one lands. | | `laser` | A thin beam to the first collider it hits, plus a hit marker. | | `chevrons` | Arrow heads marching along the line. More of them with power. | | `bounceDots` | Trajectory dots that predict one bounce off the first wall (a raycast and a reflection). | ## Power displays (`powerDisplay`) `bar` (over the ball, facing the camera), `ring` (beads around the ball), `fill` (the ball fills with colour and swells), `segments` (a meter from green to red), `arc` (a curved segmented meter beside the ball, green to red), `pulse` (the ball and a halo of beads pulse faster, wider and hotter as power rises), `numeric` (a %), `none`. Set `showPercent = true` to put a % beside any of them. ## Input modes (`inputMode`) | Mode | Touch / mouse | Gamepad | |---|---|---| | `dragBack` | Press on or near the ball, pull back, release. The shot goes opposite the pull. | Left stick aims, hold A or RT to charge (ping-pong), release to fire, B cancels | | `dragForward` | Press and drag the way it should go | same | | `holdCharge` | Press and hold: the ball aims at the pointer, power charges (`chargeMode` = `ramp` or `pingpong`) | same, using the preset's charge mode | | `flick` | A quick swipe: the swipe's speed at release is the power | same | | `dragAnywhere` | A virtual thumbstick: press anywhere on screen, pull away from where the shot should go, release (`stickFraction` of the screen's shorter side is full power). For small or far balls | same | | `meterTiming` | Classic golf: drag back from the ball to aim, let go and a power meter swings (`meterPeriod`), tap anywhere to fire at that power | same | | `tapTarget` | Tap the spot to aim at: the ball is shot towards it with the power that carries it there (hold and slide to adjust) | same | **Cancel:** slide back onto the ball, or onto the point you pressed (within `cancelRadius` points). The aim turns into a grey ring, and releasing there fires `onCancel`. A release weaker than `minPower` also cancels, and so does B on a pad. The mouse works exactly like touch. Touch wins when both are present, and the mouse is ignored for half a second after a touch. A press that lands on a UI widget never starts an aim. **Aim plane:** `plane = "ground"` aims on the horizontal plane through the ball, tilted up by `loft`. `plane = "screen"` aims in the upright plane facing the camera, for side-on flings (`slingshotFling`). Direction comes from pointer rays hitting that plane, so aiming works with any camera, top-down or chase. Power is measured on screen (a full pull is `dragFraction` of the screen's shorter side), so it feels the same in phone portrait, landscape and desktop. ## Feel presets (`preset`) | Preset | Input | Aim | Power | Notes | |---|---|---|---|---| | `golfPutt` | dragBack | dotted | ring | easeIn power, 7 m/s, waits for rest | | `chipShot` | dragBack | arc | bar | 38° loft, 8 m/s | | `poolCue` | dragBack (grab anywhere) | bounceDots | segments | 6 m/s | | `curlingSlide` | holdCharge (ramp 2.2 s) | ghostBall | bar | 5 m/s, low rolling deceleration | | `paperToss` | flick | arc | none | 45° loft, easeOut, grab anywhere | | `slingshotFling` | dragBack in the screen plane | rubberBand | fill | 14 m/s | | `basketballFlick` | flick | arc | ring | 55° loft, sCurve power | | `classicSwing` | meterTiming (1.1 s meter) | arrow | segments | 7 m/s | | `thumbStick` | dragAnywhere | chevrons | pulse | 7 m/s, grab anywhere | | `bocceRoll` | tapTarget | ghostBall | none | 6 m/s, rolls to the tapped spot | Presets are data (`presets.module`). Any field can be overridden with a component field or `configure`. Power curves are `linear`, `easeIn`, `easeOut` and `sCurve`. ## Looks (`look`) `cartoon` (chunky, bright gradient), `minimal` (thin, white), `neon` (cyan, magenta and yellow), `pixel` (flat, blocky arrow heads). Each one is a colour set: aim, a low/mid/high power gradient, back, cancel and remote, plus line width and dot size. They are in `Presets.looks`, so add your own there. ## Multiplayer - **Who aims:** a peer drives only the shooters it controls. With `player` empty, that is the peer that owns the entity (`entity.isLocal()`). An unsynced entity is driven by every peer, which suits single player. With `player` set, only the peer whose peer id, user id or player name matches drives it. Other peers never pick up presses on it. - **Who applies the shot:** the controlling peer calls `Physics.applyImpulse` on the body. That peer owns and simulates the body, so the engine replicates the motion to everyone else, smoothed. Give each player's ball to its player: spawn it on their peer, or `multiplayer.claimOwnership(ball.id)` from their peer. A peer never pushes a body it does not own. - **Seeing others aim:** while the owner aims, it writes a small synced value (`private.aim`, at most 10 times a second, direction and power only). Other peers draw it as a faint dotted line when `showOthersAim` is on. - **Events** (`onShot`, `onAimStart`, `onCancel`) fire on the shooting peer. Other peers see the ball move. Count shots from the synced `shots` value, or send your own message. ## Mobile and cost Visuals are pooled unlit primitives (spheres, cubes, cones and one Text3D label), with no shadows. They are spawned on first need and then only moved. A tint or visibility write costs about 25 times a transform write, so colours snap to eighths of power, and an unused piece shrinks to nothing before it is switched off. Measured on an Android phone: about 0.3 ms per shooter per frame while it draws, and nothing while idle. The worst style uses 28 pieces. `comp:visualCount()` reports the count. Nothing visual is synced. The grab radius (90 points) and cancel radius (34 points) are in UI points, so they keep finger size on every screen density. ## Touch accuracy at lower render scale (phones and tablets) Phones, tablets and lower quality settings draw the scene at less than full resolution (`renderer.resolutionScale()` below 1, about 0.75 on a typical tablet). The kit makes a finger on the ball (and the mouse) grab it on every engine and in every build. Engines differ in which pixels they report screen positions in: - **Today's engines:** screen positions of things in the game (`worldToScreen`, `screenToRay`, `getViewportSize`) come in render-scaled pixels while touches come in display pixels, so the kit multiplies every touch and mouse position by the render scale before it meets the camera. - **Newer engines:** these report every screen position in the same pixels as touches (and add a renderer call for the size the scene is rendered at). Scaling touches there would make the finger miss the ball, so they are used as they arrive. Builds also differ in which pixels the **mouse** and **touch** arrive in: the Android app delivers both in displayed pixels, while a browser delivers the mouse in the projection's own pixels. So the kit never assumes a space. It **measures** it from the engine itself: `ui.fromViewport` (the engine's own mapping from pointer positions to UI points, the one that puts a press on the right button in every build) carried into projection pixels by `getViewportSize()` / `ui.screenSize()`. The ratio is the render scale where pointers arrive in displayed pixels and 1 where they arrive in projection pixels; a measurement within 4% of either snaps to it. No call's name or version number is involved. If that cannot be measured it compares `getViewportSize()` with the displayed size (`ui.screenSize()` x `ui.pixelRatio("window")`), then looks for a render-size call on the renderer, then uses the render scale. **Self-correcting press:** if a press grabs nothing at the measured scale but lands on the player's own ball with the position taken as it is, or scaled by the render scale, the kit uses that and keeps it for the session (`input.learnedMode`). So even a build that maps pointers in a way the measurement misreads works from the first grab. `api.pointerScaleSource()` says which path is in force (`"measured"` normally, `"learned"`, `"renderSize"`, `"resolutionScale"` or `"override"`), and `api.pointerScale()` the factor. `api.setPointerScale(k)` pins it, for example `1` when your own input already arrives in the camera's pixels; `nil` goes back to automatic. The test suite covers both engines with a stand-in renderer. ## Known engine issues These are engine problems, not kit bugs, and they stand until the engine fixes them: - **Issue 19356 (synced state on a device that was already running):** a device that already had the engine running when a shared game was set up can end up seeing a different synced state from the other devices. For flickShot that touches only what other players see: the faint aim of another player (`showOthersAim`, a synced value) and the synced `shots` count may be missing or out of date on that device. Your own aiming, shooting and your own ball are unaffected, because they run on your own device. Reloading the game on the affected device makes it join fresh. - **Issue 26275 (frame rate on tablets):** on an Android tablet the engine draws a scene like Pocket Putt Islands at about **24 to 26 frames a second** (about 40 ms a frame, with occasional spikes near 90 ms), measured at the tablet's default render scale of 0.76. flickShot's own share of a frame is small (see "Mobile and cost"), and aiming reads the pointer every frame, so drags stay accurate at that rate; they just look less smooth than at 60. ## Gallery `flickShot.gallery` (`zero scene load flickShot.gallery`) shows every aim style, power display, look and preset as rows of balls that aim by themselves. In play, drag any ball to shoot it, and balls roll home a moment after they stop. The gallery stands at x = 80, so loading it as an additive layer beside your own scene does not overlap it. ## Contents - `FlickShot.component`: the entry point. - `api.module`: the public API. - `presets.module`: presets, styles, looks and curves as data. - `shooter.module`: the aim state machine and shot maths, with no engine state. - `input.module`: pointer and pad sampling, the pointer space measurement (`measuredScale`, `pointerScale`, `pointerScaleSource`, the self-correcting `retryPick`, the fallback `renderSizeCall`) and shooter arbitration. - `ShotCam.component` and `shotCam.module`: an optional chase camera for the player's ball. It sits high and three-quarter behind the ball, faces a target (`setTarget`) or a heading (`yaw`), eases out while the player aims, sweeps between holes or turns with `flyTo(target, duration)`, circles a point slowly with `orbit(centre, { radius, height, speed })` for a title or lobby backdrop (`stopOrbit()` ends it), widens its view on a portrait phone, and drives only the camera this peer owns in multiplayer. - `visuals.module`: the pooled drawer. - `gallery.scene`, `flickShot.testSuite`, `guides/`. Tests: `tools.use("tests", "run", { suite = "flickShot" })`, run in edit mode. ## Changes - **1.2.4:** documentation only. The README now opens with its title and version, documents all 10 presets, 7 input modes and 8 power displays (it listed 7, 4 and 7), and has a Known engine issues section (19356, 26275). The package description matches. - **1.2.3:** ShotCam `orbit(centre, opts)` / `stopOrbit()` / `isOrbiting()` and `shotCam.orbitPose`, so a game's title backdrop needs no camera of its own. Three ShotCam maths tests. - **1.2.2:** the mouse works in a browser at any window size. 1.2.1 scaled every pointer by the screen ratio it measured, but a browser delivers the mouse already in the projection's pixels, so the press landed up and to the left of the cursor and never grabbed the ball. The kit now measures the pointer space through the engine's own pointer -> UI mapping (`ui.fromViewport`), and a press that misses at that scale is retried as-is and render-scaled, keeping whichever lands on the player's own ball. Four more tests. - **1.2.1:** the old-or-new engine check no longer depends on what the new engine names its render-size call: the kit measures the space screen positions are reported in against the space touches arrive in, and scales touches only when they differ. A new engine whose call has an unexpected name now works too. Four more tests (unknown call name, older engine measured, snapping, live measurement). - **1.2.0:** touch and mouse aiming stay on the ball on newer engines that report screen positions in touch pixels. The kit detects the engine's render-size call and then stops scaling touches; on engines without it, the render scale correction from 1.1.1 stays as it was. New `api.pointerScaleSource()`. New `ShotCam` chase camera component with `shotCam` maths (behind-the-ball follow, wider view on portrait phones, fly-to sweep). Four new tests for the pointer space on both kinds of engine. - **1.1.1:** a finger on the ball grabs it first time when the scene renders below full resolution (touches carried into the render-scaled raster). - **1.1.0:** arc power display, `setEnabled` sets `canShoot`.
▲ 0↑ born
▣
module · born here
❒asset
# course `puttCourse.course` is the kit's front door. It builds single pieces (`spawnPiece`) and whole holes from a declarative description (`buildHole`), sets the one course-wide theme (`setTheme`), spawns and shoots balls with engine physics impulses (`spawnBall`, `shoot`, `resetBall`, `placeBall`), and turns what a ball does into events naming the ball and its player (`on("ballInCup", fn)`). Called by game code, the PuttHole/CoursePiece components and the gallery. See the package README for the full API.
▲ 0↑ born
▣
module · born here
❒asset
# geom `puttCourse.geom`: a small vertex-coloured mesh builder (quad, poly, box, oriented box, cylinder, tube, ring, disc, holed plane, sphere) that merges everything into one mesh per layer, with a mesh cache (`cached(key, make)`). Used by pieces, flags, effects and balls; handy for any low-poly procedural prop.
▲ 0↑ born
▣
module · born here
❒asset
# themes `puttCourse.themes`: the six course palettes (tropicalIsland, candyCartoon, pixel, neonSciFi, stoneRuins, cozyGarden) with the water/conveyor materials, flag style, cup effect and scorecard style each suggests. `get(name)`, `has`, `define(name, spec)` for your own, `hex`. Optional key `houseStripe` (hex) stripes the theme's windmill towers (`candyCartoon` sets it). Called by pieces, flags, effects and scorecard.
▲ 0↑ born
✦
shader · pulled in
❒asset
# animWater Rivers that flow at a speed stated in metres per second, with no textures. The surface moves by `offset = flow_velocity * time + flow_phase` (m/s and m, following the wearer's `am.flow` and `am.flowPhase` values written by animatedMaterials' Live) divided by `tile_size` for UV repeats, so a live change of speed or direction never makes it jump. Every field is periodic over one UV repeat, the motion included, so it tiles seamlessly. The swatches are opaque, so the water column is worked out inside the shader: flow-mapped ripples (two noise layers carried downstream at different speeds, churned along a slow swirl with a two-phase cross-fade, plus standing waves that stay put over the stones) give the normal; for the clear river the view ray is refracted through the rippled surface onto a pebble bed of varying depth (parallax), with sun caustics on the stones and Beer-Lambert absorption over the real path (`water_color` per `absorb_distance`, the water's own colour `deep_color` where the bed fades), weighted by 1 - Fresnel; the engine's PBR lighting adds the sky and sun reflection on the glossy surface. Foam and scum are thin streaks drawn out along the flow direction, carried with the surface, in lanes (`foam` 0..1). `style` 0 clear mountain river (pebble bed seen through glassy green water), 1 murky lowland river (opaque silty brown-green water, drifting silt clouds, pale scum streaks), 2 toon water (flat bands in `bed_color` / `water_color` / `deep_color`, white foam lines, twinkling four-point sparkles and a crisp cel highlight, the last two in emissive). Also `depth` (metres), `roughness`, `ripple_height` (metres). Used by animatedMaterials' riverClear, riverMurky and waterToon.
▲ 0↓ import
◇
component · born here
❒asset
# CoursePiece One puttCourse piece as a component, for pieces placed by hand in a scene. Put it on an empty entity, pick `kind` (tee, straight, curve, ... cup, flag), `theme` ('course' follows the course-wide theme), `mirror`, `settings` ('speed=40 offset=0.5', 'link=A role=in'), `flagStyle`, `number`. It builds on every machine in edit and play and turns with the entity. `:handle()` answers the piece handle. No sibling components needed; prefer PuttHole for whole holes (it merges floor colliders).
▲ 0↑ born
◇
component · born here
❒asset
# CourseRuntime Heartbeat of every puttCourse course on this machine: each frame it runs `puttCourse.course.tick` (windmills and blockers posed from `multiplayer.sessionTime()`, flag sway, cup effects, ball rest/out-of-bounds watching). The course module adds it to a hidden local entity the first time anything is built; you never add it yourself. No sibling components needed.
▲ 0↑ born
◇
component · born here
❒asset
# PuttGallery The puttCourse showroom used by `puttCourse.gallery`: builds one row per theme with every piece, a row of flag styles, cups replaying each cup effect, labels, and the scorecard styles on screen (cycle or grid). Fields: themes, spacing, rowGap, labels, effectsEvery, scorecards. Attach to an empty entity; no siblings needed.
▲ 0↑ born
◇
component · born here
❒asset
# PuttHole A whole mini golf hole as one component. Put it on an empty entity, write the `layout` ('tee 0 0; straight 0 1; windmill 0 2 speed=40; cup 0 3'), set `number`, `par`, `theme`, `flagStyle`, `cupEffect`, `waterPenalty`, `autoReset`. It calls `puttCourse.course.buildHole` on every machine, in edit and play, rebuilding when a field or the course theme changes. `:handle()` answers the hole handle (tee, cup, on, destroy); `:rebuild()`. No sibling components needed.
▲ 0↑ born
◇
component · born here
❒asset
# RoundState The shared copy of a `puttCourse.round` stroke-play round. In play the round puts one on a synced entity named `PuttRound_<id>`, spawned by the host. The peer that owns that entity is the round's authority: it applies every shot, penalty and holed ball and writes `state` (with `version` bumped), and every other peer reads it. When the owner leaves, the engine hands the entity to a peer that stays, which picks the round up from the last `state`. Fields: `roundId` (string), `version` (number), `state` (table: phase, holes, players with per-hole strokes, stars and penalties). Added by the round module; never add it by hand.
▲ 0↑ born
▣
module · born here
❒asset
# effects `puttCourse.effects`: what plays when a ball drops: sparkle, confetti (juiceKit VFX when installed), glowRing and splash (kit meshes animated by transform only). `play(style, pos, {theme})`, `tick(dt)` (run by CourseRuntime), `STYLES`, `count()`. Called by holes on ballInCup and by the gallery.
▲ 0↑ born
▣
module · born here
❒asset
# flags `puttCourse.flags`: cup flags in five styles (classic, numbered, pirate, tropical, neon). `spawn(parent, style, opts)` builds one as local entities; `sway(flag, t)` waves it from the shared clock with transform writes only. Called by the course module for cup, funnel and flag pieces.
▲ 0↑ born
·
scene · born here
❒asset
# puttCourse gallery The puttCourse showroom: every mini golf course piece (tee, straight, curve, corner, slope, slope down, ramp, loop, bridge, tunnel, wall, windmill, blocker, bumper, spring pad, sand, ice, water, conveyor, teleporter pair, funnel, cup, flag) in each of the six themes (tropicalIsland, candyCartoon, pixel, neonSciFi, stoneRuins, cozyGarden), one row per theme; a row of the five flag styles; four cups replaying the four cup effects (sparkle, confetti, glow ring, splash); and the six scorecard styles on screen with a four-player demo round. Windmills turn and blockers slide in edit and in play. Load it with `zero scene load puttCourse.gallery`. The rows are built at run time on every machine by the `PuttGallery` component, so the gallery always shows the kit as it is now; select the `PuttGallery` entity to show fewer themes, change the spacing or show all scorecards at once (`scorecards = grid`).
▲ 0↑ born
·❒asset
▲ 0↑ born
·❒asset
▲ 0↑ born
▣
module · born here
❒asset
# pieces `puttCourse.pieces` describes every mini golf piece on the 2 m grid: `build(kind, theme, params)` answers merged vertex-coloured meshes per layer (solid, glow, water, belt, mover), cheap box/capsule colliders, behaviour zones, movers and anchors, without creating entities. `KINDS`, `ALIASES`, `DESCRIPTIONS`, `canonical(kind)`. Called by `puttCourse.course`; use it directly to make your own piece meshes.
▲ 0↑ born
·
testsuite · born here
❒asset
# puttCourse tests Checks the catalogue (23 pieces, 6 themes, 5 flags, 4 cup effects, 6 scorecard styles), that every piece builds in every theme with meshes and colliders, the hazard zones / anchors / movers each piece needs, mirroring, layout parsing, collider merging, that `buildHole` is idempotent and answers the right tee and cup, that holes follow `setTheme`, event dispatch (the `ballInWater` / `ballEnteredWater` alias, per-hole filters, `"*"`), and the scorecard model and renderer for every style. Builds its test holes far from the scene (y = 50, x ≈ -400) and destroys them. It leaves physics alone: the ball-through-sand/water/bumper/cup run is a play test. Run in edit mode: `tools.use("tests", "run", { suite = "puttCourse" })`.
▲ 0↑ born
▣
module · born here
❒asset
# round `puttCourse.round` runs a multi-hole stroke-play round of mini golf for any number of players. Game code creates a round from an ordered list of holes (`Round.new{ holes = {...}, players = "peers" }`). Everyone plays at the same time, each player on their own current hole. The round counts strokes from the course balls (or from your own `shot` / `penalty` / `holed` calls), adds water and out-of-bounds penalties, caps a hole at par + `maxOverPar` (the ball goes into the cup and the hole is finished), gives stars per hole, places each player's ball on their next tee, can wait for everyone before moving on (`waitForAll`), lets players join and leave mid-round, restarts, and ends with a ranking (lowest total, then most stars). Events: `holeStarted`, `shot`, `penalty`, `holeFinished {player, hole, strokes, par, toPar, stars, holeInOne, capped}`, `roundFinished {ranking}`, `playerJoined`, `playerLeft`, `roundStarted`, `roundRestarted`. Multiplayer: in play the state sits on a synced `PuttRound_<id>` entity with a `RoundState` component. Its owner is the one authority that applies the rules; the engine hands it to a peer that stays when the owner leaves. See the package README for the full API.
▲ 0↑ born
▣
module · born here
❒asset
# scorecard `puttCourse.scorecard`: a multi-player strokes-vs-par scorecard. `new(holes, players)` keeps the data (record, total, toPar, leader); `render(players, holes, style, opts)` answers a UI widget tree; `show/hide` put it on its own screen. Six styles: classicPaper, tropicalWood, neonArcade, pixelArcade, candyPop, parchment. Called by game code at hole end and by the gallery.
▲ 0↑ born
◇
component · born here
❒asset
# FlickShot Drag-and-release / slingshot shot controls on one physics body: the player who controls the body presses on or near it (touch or mouse), pulls and releases (or aims with a gamepad's left stick, holds A / RT to charge, B cancels); sliding back onto the ball cancels. Fires `onShot { direction, power, curvedPower, impulse, speed, device }`, `onAimStart` and `onCancel`, and pushes the body with `Physics.applyImpulse` while `applyImpulse` is on. Put it on an entity with a dynamic `Physics` body and a collider. Fields: `preset`, `aimStyle`, `powerDisplay`, `inputMode`, `look`, `grab`, `maxImpulse`, `maxSpeed`, `loft`, `canShoot`, `player`, `applyImpulse`, `waitForRest`, `showOthersAim`, `showPercent`, `radius`, `aimScale`, `demo`, `demoFires`. Methods: `configure`, `settings`, `isAiming`, `shoot`, `cancel`, `visualCount`. Only the peer that owns the body (or the named `player`) aims and applies the shot; other peers see a faint synced aim. Code reaches it through `flickShot.api`.
▲ 0↑ born
◇
component · born here
❒asset
# ShotCam A chase camera for the local player's shooter body. Put it on the entity that carries the player's `Camera` (a CameraRig under the player prototype, or a scene camera); it needs no other sibling component. It sits high and three-quarter behind the followed body, looks toward a settable target (`setTarget(cupPosition)`, or the `lookAt` entity), follows with exponential smoothing, eases out while the player aims a FlickShot (`aimEaseOut`), sweeps between turns with `flyTo(target, duration, look?, hold?)`, and blends its field of view from `fovLandscape` to `fovPortrait` as the view turns upright. In multiplayer it drives only a camera this peer owns. Fields: `follow`, `lookAt`, `target`, `hasTarget`, `yaw`, `distance`, `height`, `lookAhead`, `aimEaseOut`, `followSharpness`, `fovLandscape`, `fovPortrait`, `flyLift`, `aiming`, `localOnly`. Methods: `setTarget`, `setFollow`, `flyTo`, `isFlying`, `release`, `snap`, `goal`. The maths lives in `flickShot.shotCam`.
▲ 0↑ born
▣
module · born here
❒asset
# flickShot.api The public face of flickShot, for game code: `attach(entity, opts)` / `detach` / `get`, `setStyle`, `configure`, `setEnabled`, `onShot(cb)` / `onAimStart(cb)` / `onCancel(cb)` (each returns an unsubscribe), `isAiming()` / `aimingEntity()` to block other input while a player aims, `shoot(entity, dir, power)` for AI and tests, `settings` / `resolve`, `describe(name)`, and the name lists `presets`, `aimStyles`, `powerDisplays`, `inputModes`, `looks`, `grabModes`.
▲ 0↑ born
·
testsuite · born here
❒asset
# flickShot tests Checks preset resolution and overrides, power curves and charge waves, the drag back / drag forward / hold to charge / flick state machine against a fake top-down camera (direction, power, the slide-back cancel zone, taps and weak releases), the screen plane for flings, loft, gamepad aim + charge + B cancel (and that a still-held A does not restart a cancelled charge), the shot record's impulse maths, the pooled visuals for every aim style x power display x look within the entity budget, and the FlickShot component end to end on a temporary body far from the scene (shoot from code fires onShot with the right impulse, setStyle / configure / setEnabled / detach). Leaves nothing in the scene. Run in edit mode: `tools.use("tests", "run", { suite = "flickShot" })`.
▲ 0↑ born
·
scene · born here
❒asset
# gallery flickShot's live style gallery: rows of balls on a putting table showing every aim style (front row), every power display, every look and every feel preset (back row), each aiming by itself in a slow loop so every style is visible without input, labelled with its name. In play, drag any ball back and release to shoot it (slide back onto it to cancel; a gamepad aims the first ball), and balls roll home after they stop. It sits at x = 80 with its own fixed camera, so it can load as an additive layer beside a game scene. Load it with `zero scene load flickShot.gallery`.
▲ 0↑ born
▲ 0↑ born
▲ 0↑ born
▣
module · born here
❒asset
# flickShot.input Reads the pointer (touch first, then mouse) and the gamepad once a frame from the engine's input state (`Zin.touch`, `Zin.state`), skips presses the UI takes, picks which of this peer's shooters a press belongs to (finger-sized grab radius, `anywhere` shooters last), and drives that shooter's state machine; also keeps the shared camera view every shooter's maths and visuals read. Internal to flickShot; games use `flickShot.api` (`isAiming`).
▲ 0↑ born
▣
module · born here
❒asset
# flickShot.presets flickShot's data: the seven feel presets (golfPutt, chipShot, poolCue, curlingSlide, paperToss, slingshotFling, basketballFlick), the eight aim styles, six power displays, four input modes, four looks (cartoon, minimal, neon, pixel) with their colour sets, the base settings every preset starts from, `resolve(preset, overrides)` and the power curves. Read by the FlickShot component and `flickShot.api`; a game adds its own preset or look by inserting into `presets` / `looks`.
▲ 0↑ born
▣
module · born here
❒asset
# flickShot.shooter The aim state machine and shot maths behind each FlickShot, with no engine state: pointer down / move / up for drag back, drag forward, hold to charge and flick, gamepad aim + charge + cancel, the cancel zone, ray-plane aiming on the ground or screen plane, loft, charge waves, power curves and the shot record (direction, power, impulse, speed). Fed by `flickShot.input` with a `view` (camera axes and ray functions), so tests drive it with a fake camera.
▲ 0↑ born
▣
module · born here
❒asset
# flickShot.shotCam Pure maths behind the ShotCam chase camera, with no engine state: `goal(subject, target, cfg, ease)` (the high three-quarter pose behind a shooter body looking toward a target), `heading`, `fovFor(w, h, landscape, portrait)` (wider vertical field of view on a portrait phone), `flyPose` (the lifted fly-to sweep), `followAlpha` (exponential smoothing), `smoothstep` and `lookRotation`. The `flickShot.ShotCam` component calls it every frame; games and tests can call it directly.
▲ 0↑ born
▣
module · born here
❒asset
# flickShot.visuals A pooled drawer per shooter that renders all eight aim styles (dotted, arrow, rubberBand, arc, ghostBall, laser, chevrons, bounceDots) and the power displays (bar, ring, fill, segments, numeric) from a handful of unlit primitive entities, spawned on first need and then only moved. Colour writes are quantised and unused pieces shrink before they are hidden, because a tint or visibility write costs ~25x a transform write. Used by the FlickShot component; nothing it draws is synced.
▲ 0↑ born
backing path · pocketPutt.package

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.