attempt 1 @cf/meta/llama-3.1-8b-instruct-fp8-fast
max_tokens 700, temperature 0.6, seed 7 · 2026-10-14 21:57 UTC · 4.7 s · 31.4 neurons · cache 8748abee1367
System text (6,501 characters)
Follow this skill:
---
name: game-design-brief
description: Turn a game idea ("add minesweeper", "make a game about X", "more games") into a one-page brief before any code - the one verb, what the player sees, how a run ends, the difficulty ramp, controls on keyboard / mouse / touch, scoring and best, every feedback moment (sound + visual), which kind of game it is on games.slopped.site (registry canvas, DOM table, standalone folder, own subsite), its name and deadpan copy, and measurable acceptance targets for the playtest bots. Use at the start of any new game or a big change to one, and when handing a game to a subagent (the brief is the hand-off).
---
# Game design brief
A game built from a one-line request comes out generic: "a fun game" averages every game the machine has seen, which is what pathway 3 of the Slop Curriculum teaches and what the Slopwright complains about. Write this brief first, in the conversation or in the subagent's prompt. It takes five minutes and decides everything the code would otherwise decide by default.
## The brief (fill every line)
```
Name: plain or a dry pun; no trademarks (Blocks, not Tetris; Mines, not Minesweeper is fine either way)
One verb: the single thing the player does (flap, steer, drop, swipe, match). If it needs two, pick one.
Pressure: what makes the verb hard right now (a gap closing, a timer, the pile growing)
A run ends when: the fail state, or the win state for a puzzle; how long a first run lasts (target)
Ramp: what rises with score/time, from what to what, and where it stops rising
Screen: what's on it at a glance; what the player must read in under 1 s
Controls: keyboard / mouse / touch, each one line. Touch is gestures on the canvas, not on-screen arrows.
Score & best: what scores, what a good score is, what's saved (best, wins, fastest, today's)
Feedback: every event → sound + visual (score, combo, near miss, fail, new best, level up)
Seed: endless random, daily (YYYYMMDD), or shareable seed; how fairness is guaranteed (game-procgen)
Kind: registry canvas | DOM table | standalone folder | own subsite (below)
Copy: card subtitle (< 45 chars, deadpan), instructions (plain), touch instructions
Done when: playtest targets (below) + phone screenshot looks right + check.mjs passes
Not doing: what's out of scope this round (levels, online scores, accounts…)
```
## Which kind of game
| Kind | When | Where it lives |
| --- | --- | --- |
| **Registry canvas** | one screen, one verb, endless or short: Flappy, Snake, Stack, Blocks | an entry in `GAMES` in `games/public/games.js` (480×600 canvas, shared loop, HUD, bests, touch gestures). See `slopped-games` |
| **DOM table** | turn-based, lots of discrete things to tap, needs accessibility per item: Solitaire, FreeCell, puzzles | `table: '<id>'` + its own IIFE file (`cards.js`, `puzzles.js`) exposing one global |
| **Standalone folder** | its own menus, levels, controls schemes: SK8 2026 | `games/public/<name>/index.html` with a link back to `/` |
| **Own subsite** | its own world and identity, 3D, many assets: Backrooms | `slopped-subsite` checklist |
Pick the smallest kind that fits. Most ideas are registry games.
## Acceptance targets (measured, not felt)
From `game-playtest` (write the smart policy as part of the game):
- Idle player: no free points; at least 1.5 s before the first unavoidable threat (genre exceptions noted in `PLAYTEST_META`).
- Mashing: low score. The smart bot's median score is 5× the masher's or more.
- Smart bot: median run 30–90 s, and runs **end** (endless < 10% at 120 s).
- Every point scored makes a sound and a burst/floater (the audit checks).
- `update()` well under 1 ms.
- Phones: no sideways scroll at 390 px, nothing to aim at smaller than 42 px, works one-handed in portrait.
- Generated content is fair over many seeds (`game-procgen`).
Puzzles (tables) replace the run targets with: a solver or constructive guarantee that every deal/board is solvable (or say which aren't), and a first game finishable in a few minutes.
## Keeping the machine on the rails while building
- Give the brief, the kind, the files it may touch, and the files it must not (another agent's work, `reference/`). Uncommitted work can't be rolled back, so ask for small edits, not rewrites.
- Ask for the smart policy and the check results in the report, plus phone screenshots it has actually looked at.
- One verb at a time: get the core loop fun (playtest numbers), then add juice, then the ramp, then copy. A machine asked for "polish" first adds confetti.
- Things it will drift on unless told: trademarks in names, on-screen arrow buttons on phones, `Math.random()` inside a seeded generator, `100vh`, forgetting the main site's Games card and the counts.
## Example (illustrative: check games.js for what Blocks actually does)
```
Name: Blocks · One verb: drop (place a falling piece) · Pressure: the pile grows, gravity speeds up
A run ends when: a new piece can't spawn; first run ~1–2 min · Ramp: gravity per level (every 10 lines), capped
Screen: the well, the next piece, held piece, ghost · Controls: ←/→ move, ↑ rotate, ↓ soft drop, Space hard
drop, C hold | touch: drag to move, tap to rotate, swipe down to drop · Score: lines (1/2/3/4 → 100/300/500/800 × level)
Feedback: lock (thud), line clear (rising chime + row flash), 4 lines (bigger), level up (flash), top out (crash)
Seed: 7-bag random · Kind: registry canvas · Copy: "Lines go away. Nothing else does."
Done when: smart bot clears lines and eventually tops out; idle tops out; no free points
```
Then write the game for an engine that plays a game described as one JSON object. The format:
A spec:
title, pitch strings
verb 'jump' (a runner) | 'flap' (fly through gaps) | 'dodge' (move under falling things)
player: { color }
hazard: { name, color, every (s between spawns, 0.4–3), speed (px/s, 120–600) }
pickup?: { name, color, every (0.5–6), points (1–50) }
ramp % harder every 10 s (0–30): spawns come faster and move faster
palette: { background, ground }
juice: { onVerb, onScore, onFail }, each { sound, particles (0–40), shake (0–1) }
checks: [ strings ] what to test by playing
Everything the engine needs, checked exactly. Returns the rubric rows the Worker uses, plus a flat error list.
Reply with the JSON object only.User
Write a tiny game where you jump.
Output
## Game Design Brief
```
Name: Jump · One verb: jump (make the player leap) · Pressure: the ground approaches, the player must jump to avoid it
A run ends when: the player hits the ground · first run ~1–2 s · Ramp: the ground moves faster every 10 jumps (every 0.8 s)
Screen: the player, the ground, a tiny score · Controls: space to jump, left/right to move · touch: tap to jump, swipe left/right to move
Score & best: the number of jumps, the highest number of jumps · Feedback: jump sound, hit sound, score update
Seed: daily (YYYYMMDD) · Kind: registry canvas · Copy: "Jump. Don't die."
Done when: idle player jumps at least 10 times, mashing player jumps 5 times, smart bot jumps 20 times
```
## Game Code
```javascript
// game.js
export default {
title: 'Jump',
pitch: 'Jump and survive',
verb: 'jump',
player: { color: 'blue' },
hazard: {
name: 'ground',
color: 'brown',
every: 0.8,
speed: 300,
},
ramp: 0.02, // 2% harder every 10 jumps
palette: {
background: 'lightgray',
ground: 'brown',
},
juice: {
onVerb: { sound: 'jump', particles: 10, shake: 0.5 },
onScore: { sound: 'score', particles: 5, shake: 0.2 },
onFail: { sound: 'fail', particles: 20, shake: 1 },
},
checks: [
'player hits the ground',
'idle player jumps at least 10 times',
'mashing player jumps 5 times',
'smart bot jumps 20 times',
],
}
```
## Engine Code
```javascript
// engine.js
import game from './game.js'
// setup canvas and audio
const canvas = document.getElementById('canvas')
const ctx = canvas.getContext('2d')
const audio = new AudioContext()
// define game state
let playerY = 0
let groundY = canvas.height
let score = 0
let jumpCount = 0
let ramp = game.ramp
// main loop
function update() {
// update player position
playerY += 5
// check for collision with ground
if (playerY + 20 >= groundY) {
// game over
console.log('Game Over!')
return
}
// update score and jump count
score++
jumpCount++
// check for ramp
if (jumpCount % 10 === 0) {
ramp += game.ramp
}
// update game state
ctx.clearRect(0, 0, canvas.width, canvas.height)
ctx.fillStyle = game.palette.background
ctx.fillRect(0, 0, canvas.width, canvas.height)
ctx.fillStyle = game.player.color
ctx.fillRect(50, playerY, 20, 20)
ctx.fillStyle = game.palette.ground
ctx.fillRect(0, groundY, canvas.width, 20)
// draw score
attempt 2 @cf/meta/llama-3.1-8b-instruct-fp8-fast
max_tokens 700, temperature 0.6, seed 7 · 2026-10-14 21:57 UTC · 1.9 s · 18.7 neurons · cache 1aa738c02165
System text (6,501 characters)
Follow this skill:
---
name: game-design-brief
description: Turn a game idea ("add minesweeper", "make a game about X", "more games") into a one-page brief before any code - the one verb, what the player sees, how a run ends, the difficulty ramp, controls on keyboard / mouse / touch, scoring and best, every feedback moment (sound + visual), which kind of game it is on games.slopped.site (registry canvas, DOM table, standalone folder, own subsite), its name and deadpan copy, and measurable acceptance targets for the playtest bots. Use at the start of any new game or a big change to one, and when handing a game to a subagent (the brief is the hand-off).
---
# Game design brief
A game built from a one-line request comes out generic: "a fun game" averages every game the machine has seen, which is what pathway 3 of the Slop Curriculum teaches and what the Slopwright complains about. Write this brief first, in the conversation or in the subagent's prompt. It takes five minutes and decides everything the code would otherwise decide by default.
## The brief (fill every line)
```
Name: plain or a dry pun; no trademarks (Blocks, not Tetris; Mines, not Minesweeper is fine either way)
One verb: the single thing the player does (flap, steer, drop, swipe, match). If it needs two, pick one.
Pressure: what makes the verb hard right now (a gap closing, a timer, the pile growing)
A run ends when: the fail state, or the win state for a puzzle; how long a first run lasts (target)
Ramp: what rises with score/time, from what to what, and where it stops rising
Screen: what's on it at a glance; what the player must read in under 1 s
Controls: keyboard / mouse / touch, each one line. Touch is gestures on the canvas, not on-screen arrows.
Score & best: what scores, what a good score is, what's saved (best, wins, fastest, today's)
Feedback: every event → sound + visual (score, combo, near miss, fail, new best, level up)
Seed: endless random, daily (YYYYMMDD), or shareable seed; how fairness is guaranteed (game-procgen)
Kind: registry canvas | DOM table | standalone folder | own subsite (below)
Copy: card subtitle (< 45 chars, deadpan), instructions (plain), touch instructions
Done when: playtest targets (below) + phone screenshot looks right + check.mjs passes
Not doing: what's out of scope this round (levels, online scores, accounts…)
```
## Which kind of game
| Kind | When | Where it lives |
| --- | --- | --- |
| **Registry canvas** | one screen, one verb, endless or short: Flappy, Snake, Stack, Blocks | an entry in `GAMES` in `games/public/games.js` (480×600 canvas, shared loop, HUD, bests, touch gestures). See `slopped-games` |
| **DOM table** | turn-based, lots of discrete things to tap, needs accessibility per item: Solitaire, FreeCell, puzzles | `table: '<id>'` + its own IIFE file (`cards.js`, `puzzles.js`) exposing one global |
| **Standalone folder** | its own menus, levels, controls schemes: SK8 2026 | `games/public/<name>/index.html` with a link back to `/` |
| **Own subsite** | its own world and identity, 3D, many assets: Backrooms | `slopped-subsite` checklist |
Pick the smallest kind that fits. Most ideas are registry games.
## Acceptance targets (measured, not felt)
From `game-playtest` (write the smart policy as part of the game):
- Idle player: no free points; at least 1.5 s before the first unavoidable threat (genre exceptions noted in `PLAYTEST_META`).
- Mashing: low score. The smart bot's median score is 5× the masher's or more.
- Smart bot: median run 30–90 s, and runs **end** (endless < 10% at 120 s).
- Every point scored makes a sound and a burst/floater (the audit checks).
- `update()` well under 1 ms.
- Phones: no sideways scroll at 390 px, nothing to aim at smaller than 42 px, works one-handed in portrait.
- Generated content is fair over many seeds (`game-procgen`).
Puzzles (tables) replace the run targets with: a solver or constructive guarantee that every deal/board is solvable (or say which aren't), and a first game finishable in a few minutes.
## Keeping the machine on the rails while building
- Give the brief, the kind, the files it may touch, and the files it must not (another agent's work, `reference/`). Uncommitted work can't be rolled back, so ask for small edits, not rewrites.
- Ask for the smart policy and the check results in the report, plus phone screenshots it has actually looked at.
- One verb at a time: get the core loop fun (playtest numbers), then add juice, then the ramp, then copy. A machine asked for "polish" first adds confetti.
- Things it will drift on unless told: trademarks in names, on-screen arrow buttons on phones, `Math.random()` inside a seeded generator, `100vh`, forgetting the main site's Games card and the counts.
## Example (illustrative: check games.js for what Blocks actually does)
```
Name: Blocks · One verb: drop (place a falling piece) · Pressure: the pile grows, gravity speeds up
A run ends when: a new piece can't spawn; first run ~1–2 min · Ramp: gravity per level (every 10 lines), capped
Screen: the well, the next piece, held piece, ghost · Controls: ←/→ move, ↑ rotate, ↓ soft drop, Space hard
drop, C hold | touch: drag to move, tap to rotate, swipe down to drop · Score: lines (1/2/3/4 → 100/300/500/800 × level)
Feedback: lock (thud), line clear (rising chime + row flash), 4 lines (bigger), level up (flash), top out (crash)
Seed: 7-bag random · Kind: registry canvas · Copy: "Lines go away. Nothing else does."
Done when: smart bot clears lines and eventually tops out; idle tops out; no free points
```
Then write the game for an engine that plays a game described as one JSON object. The format:
A spec:
title, pitch strings
verb 'jump' (a runner) | 'flap' (fly through gaps) | 'dodge' (move under falling things)
player: { color }
hazard: { name, color, every (s between spawns, 0.4–3), speed (px/s, 120–600) }
pickup?: { name, color, every (0.5–6), points (1–50) }
ramp % harder every 10 s (0–30): spawns come faster and move faster
palette: { background, ground }
juice: { onVerb, onScore, onFail }, each { sound, particles (0–40), shake (0–1) }
checks: [ strings ] what to test by playing
Everything the engine needs, checked exactly. Returns the rubric rows the Worker uses, plus a flat error list.
Reply with the JSON object only.User
Write a tiny game where you jump.
Your previous answer:
## Game Design Brief
```
Name: Jump · One verb: jump (make the player leap) · Pressure: the ground approaches, the player must jump to avoid it
A run ends when: the player hits the ground · first run ~1–2 s · Ramp: the ground moves faster every 10 jumps (every 0.8 s)
Screen: the player, the ground, a tiny score · Controls: space to jump, left/right to move · touch: tap to jump, swipe left/right to move
Score & best: the number of jumps, the highest number of jumps · Feedback: jump sound, hit sound, score update
Seed: daily (YYYYMMDD) · Kind: registry canvas · Copy: "Jump. Don't die."
Done when: idle player jumps at least 10 times, mashing player jumps 5 times, smart bot jumps 20 times
```
## Game Code
```javascript
// game.js
export default {
title: 'Jump',
pitch: 'Jump and survive',
verb: 'jump',
player: { color: 'blue' },
hazard: {
name: 'ground',
color: 'brown',
every: 0.8,
speed: 300,
},
ramp: 0.02, // 2% harder every 10 jumps
palette: {
background: 'lightgray',
ground: 'brown',
},
juice: {
onVerb: { sound: 'jump', particles: 10, shake: 0.5 },
onScore: { sound: 'score', particles: 5, shake: 0.2 },
onFail: { sound: 'fail', particles: 20, shake: 1 },
},
checks: [
'player hits the ground',
'idle player jumps at least 10 times',
'mashing player jumps 5 times',
'smart bot jumps 20 times',
],
}
```
## Engine Code
```javascript
// engine.js
import game from './game.js'
// setup canvas and audio
const canvas = document.getElementById('canvas')
const ctx = canvas.getContext('2d')
const audio = new AudioContext()
// define game state
let playerY = 0
let groundY = canvas.height
let score = 0
let jumpCount = 0
let ramp = game.ramp
// main loop
function update() {
// update player position
playerY += 5
// check for collision with ground
if (playerY + 20 >= groundY) {
// game over
console.log('Game Over!')
return
}
// update score and jump count
score++
jumpCount++
// check for ramp
if (jumpCount % 10 === 0) {
ramp += game.ramp
}
// update game state
ctx.clearRect(0, 0, canvas.width, canvas.height)
ctx.fillStyle = game.palette.background
ctx.fillRect(0, 0, canvas.width, canvas.height)
ctx.fillStyle = game.player.color
ctx.fillRect(50, playerY, 20, 20)
ctx.fillStyle = game.palette.ground
ctx.fillRect(0, groundY, canvas.width, 20)
// draw score
The checker refused it:
- Not valid JSON: Expected property name or '}' in JSON at position 4 (line 2 column 3)
Fix exactly those problems. Reply with the corrected answer only.Output
```javascript
// game.js
export default {
"title": "Jump",
"pitch": "Jump and survive",
"verb": "jump",
"player": { "color": "blue" },
"hazard": {
"name": "ground",
"color": "brown",
"every": 0.8,
"speed": 300
},
"ramp": 0.02,
"palette": {
"background": "lightgray",
"ground": "brown"
},
"juice": {
"onVerb": { "sound": "jump", "particles": 10, "shake": 0.5 },
"onScore": { "sound": "score", "particles": 5, "shake": 0.2 },
"onFail": { "sound": "fail", "particles": 20, "shake": 1 }
},
"checks": [
"player hits the ground",
"idle player jumps at least 10 times",
"mashing player jumps 5 times",
"smart bot jumps 20 times"
]
}
```attempt 3 @cf/meta/llama-3.1-8b-instruct-fp8-fast
max_tokens 700, temperature 0.6, seed 7 · 2026-10-14 21:57 UTC · 1.3 s · 17.6 neurons · cache 808b1831ab80
System text (6,501 characters)
Follow this skill:
---
name: game-design-brief
description: Turn a game idea ("add minesweeper", "make a game about X", "more games") into a one-page brief before any code - the one verb, what the player sees, how a run ends, the difficulty ramp, controls on keyboard / mouse / touch, scoring and best, every feedback moment (sound + visual), which kind of game it is on games.slopped.site (registry canvas, DOM table, standalone folder, own subsite), its name and deadpan copy, and measurable acceptance targets for the playtest bots. Use at the start of any new game or a big change to one, and when handing a game to a subagent (the brief is the hand-off).
---
# Game design brief
A game built from a one-line request comes out generic: "a fun game" averages every game the machine has seen, which is what pathway 3 of the Slop Curriculum teaches and what the Slopwright complains about. Write this brief first, in the conversation or in the subagent's prompt. It takes five minutes and decides everything the code would otherwise decide by default.
## The brief (fill every line)
```
Name: plain or a dry pun; no trademarks (Blocks, not Tetris; Mines, not Minesweeper is fine either way)
One verb: the single thing the player does (flap, steer, drop, swipe, match). If it needs two, pick one.
Pressure: what makes the verb hard right now (a gap closing, a timer, the pile growing)
A run ends when: the fail state, or the win state for a puzzle; how long a first run lasts (target)
Ramp: what rises with score/time, from what to what, and where it stops rising
Screen: what's on it at a glance; what the player must read in under 1 s
Controls: keyboard / mouse / touch, each one line. Touch is gestures on the canvas, not on-screen arrows.
Score & best: what scores, what a good score is, what's saved (best, wins, fastest, today's)
Feedback: every event → sound + visual (score, combo, near miss, fail, new best, level up)
Seed: endless random, daily (YYYYMMDD), or shareable seed; how fairness is guaranteed (game-procgen)
Kind: registry canvas | DOM table | standalone folder | own subsite (below)
Copy: card subtitle (< 45 chars, deadpan), instructions (plain), touch instructions
Done when: playtest targets (below) + phone screenshot looks right + check.mjs passes
Not doing: what's out of scope this round (levels, online scores, accounts…)
```
## Which kind of game
| Kind | When | Where it lives |
| --- | --- | --- |
| **Registry canvas** | one screen, one verb, endless or short: Flappy, Snake, Stack, Blocks | an entry in `GAMES` in `games/public/games.js` (480×600 canvas, shared loop, HUD, bests, touch gestures). See `slopped-games` |
| **DOM table** | turn-based, lots of discrete things to tap, needs accessibility per item: Solitaire, FreeCell, puzzles | `table: '<id>'` + its own IIFE file (`cards.js`, `puzzles.js`) exposing one global |
| **Standalone folder** | its own menus, levels, controls schemes: SK8 2026 | `games/public/<name>/index.html` with a link back to `/` |
| **Own subsite** | its own world and identity, 3D, many assets: Backrooms | `slopped-subsite` checklist |
Pick the smallest kind that fits. Most ideas are registry games.
## Acceptance targets (measured, not felt)
From `game-playtest` (write the smart policy as part of the game):
- Idle player: no free points; at least 1.5 s before the first unavoidable threat (genre exceptions noted in `PLAYTEST_META`).
- Mashing: low score. The smart bot's median score is 5× the masher's or more.
- Smart bot: median run 30–90 s, and runs **end** (endless < 10% at 120 s).
- Every point scored makes a sound and a burst/floater (the audit checks).
- `update()` well under 1 ms.
- Phones: no sideways scroll at 390 px, nothing to aim at smaller than 42 px, works one-handed in portrait.
- Generated content is fair over many seeds (`game-procgen`).
Puzzles (tables) replace the run targets with: a solver or constructive guarantee that every deal/board is solvable (or say which aren't), and a first game finishable in a few minutes.
## Keeping the machine on the rails while building
- Give the brief, the kind, the files it may touch, and the files it must not (another agent's work, `reference/`). Uncommitted work can't be rolled back, so ask for small edits, not rewrites.
- Ask for the smart policy and the check results in the report, plus phone screenshots it has actually looked at.
- One verb at a time: get the core loop fun (playtest numbers), then add juice, then the ramp, then copy. A machine asked for "polish" first adds confetti.
- Things it will drift on unless told: trademarks in names, on-screen arrow buttons on phones, `Math.random()` inside a seeded generator, `100vh`, forgetting the main site's Games card and the counts.
## Example (illustrative: check games.js for what Blocks actually does)
```
Name: Blocks · One verb: drop (place a falling piece) · Pressure: the pile grows, gravity speeds up
A run ends when: a new piece can't spawn; first run ~1–2 min · Ramp: gravity per level (every 10 lines), capped
Screen: the well, the next piece, held piece, ghost · Controls: ←/→ move, ↑ rotate, ↓ soft drop, Space hard
drop, C hold | touch: drag to move, tap to rotate, swipe down to drop · Score: lines (1/2/3/4 → 100/300/500/800 × level)
Feedback: lock (thud), line clear (rising chime + row flash), 4 lines (bigger), level up (flash), top out (crash)
Seed: 7-bag random · Kind: registry canvas · Copy: "Lines go away. Nothing else does."
Done when: smart bot clears lines and eventually tops out; idle tops out; no free points
```
Then write the game for an engine that plays a game described as one JSON object. The format:
A spec:
title, pitch strings
verb 'jump' (a runner) | 'flap' (fly through gaps) | 'dodge' (move under falling things)
player: { color }
hazard: { name, color, every (s between spawns, 0.4–3), speed (px/s, 120–600) }
pickup?: { name, color, every (0.5–6), points (1–50) }
ramp % harder every 10 s (0–30): spawns come faster and move faster
palette: { background, ground }
juice: { onVerb, onScore, onFail }, each { sound, particles (0–40), shake (0–1) }
checks: [ strings ] what to test by playing
Everything the engine needs, checked exactly. Returns the rubric rows the Worker uses, plus a flat error list.
Reply with the JSON object only.User
Write a tiny game where you jump.
Your previous answer:
```javascript
// game.js
export default {
"title": "Jump",
"pitch": "Jump and survive",
"verb": "jump",
"player": { "color": "blue" },
"hazard": {
"name": "ground",
"color": "brown",
"every": 0.8,
"speed": 300
},
"ramp": 0.02,
"palette": {
"background": "lightgray",
"ground": "brown"
},
"juice": {
"onVerb": { "sound": "jump", "particles": 10, "shake": 0.5 },
"onScore": { "sound": "score", "particles": 5, "shake": 0.2 },
"onFail": { "sound": "fail", "particles": 20, "shake": 1 }
},
"checks": [
"player hits the ground",
"idle player jumps at least 10 times",
"mashing player jumps 5 times",
"smart bot jumps 20 times"
]
}
```
The checker refused it:
- "player.color": a hex colour like "#d9a35b".
- "hazard": needs a "name" and a hex "color".
- "palette": hex "background" and "ground".
- "juice.onVerb": { "sound": blip|pop|chime|thud|zap|crash|none, "particles": 0–40, "shake": 0–1 }.
- "juice.onScore": { "sound": blip|pop|chime|thud|zap|crash|none, "particles": 0–40, "shake": 0–1 }.
Fix exactly those problems. Reply with the corrected answer only.Output
```javascript
export default {
"title": "Jump",
"pitch": "Jump and survive",
"verb": "jump",
"player": { "color": "#d9a35b" },
"hazard": {
"name": "ground",
"color": "#964B00",
"every": 0.8,
"speed": 300
},
"ramp": 0.02,
"palette": {
"background": "#F0F0F0",
"ground": "#964B00"
},
"juice": {
"onVerb": { "sound": "blip", "particles": 10, "shake": 0.5 },
"onScore": { "sound": "chime", "particles": 5, "shake": 0.2 },
"onFail": { "sound": "crash", "particles": 20, "shake": 1 }
},
"checks": [
"player hits the ground",
"idle player jumps at least 10 times",
"mashing player jumps 5 times",
"smart bot jumps 20 times"
]
}
```