Build a Dangerous Dave-style tile platformer as a single index.html. Canvas, procedural graphics, tiles: ground, fire, water, trophy, exit door, enemies, jumping, key… maybe. Write it completely.

Design:
- Tile map grid, player physics (gravity, jumping), left/right arrow movement.
- Grab the trophy to unlock the exit door; touching the exit after grabbing the trophy = victory.
- Fire and water tiles are instant death. Spike tiles too?
- Enemy: a patrolling blob.
- Multiple levels? One nice level is enough; maybe 3 small levels for polish. Keep it within a manageable scope, but make it feel polished.
- Procedural drawing: brick tiles, animated flames, animated water, trophy, door, player (little human figure), enemies.

Implementation details:
- Tile size 32px, level wider than screen (e.g., 60 tiles) with a camera.
- Collision: AABB with tiles, solid tiles.
- Hazards: fire (touching the tile) and water (touching the tile) = instant death, respawn at start point, with a lives system.
- Enemy: walks back and forth on platforms, turns around at walls/edges. Touching = death.
- HUD: lives, trophy status, level.
- Game states: title, playing, dead (briefly), victory, game over.

Write compact but complete code. Levels as string arrays. Legend:
- `#` brick solid
- `.` empty space
- `F` fire
- `W` water (top surface, maybe swimmable? In DD, water is instant death; make it instant death)
- `T` trophy
- `E` exit door
- `P` player spawn
- `M` monster spawn
- `=` platform (one-way? Make it solid, or a semi-solid platform). Simpler: solid with a different appearance.

Physics: standard. Jump when grounded, variable jump height (release cuts velocity). Coyote time optional.

Camera follows player, clamped.

Draw everything per frame. Flame animation with time-based flickering, water with sine waves.

3 levels. Victory screen after the final level.

Alright, let's write it.

Code sketch:

```js
const TS=32;
const levels = [arrays of strings];
Parse level: solid grid, hazard grid, entity list.
Player: x,y,vx,vy,w=20,h=28.
Input: arrow keys + WASD + space.
Update: acceleration, friction, gravity, jump.
X movement, resolve; Y movement, resolve.
Hazard check: tiles overlapped by shrunken player bbox.
Enemies: update patrol, flip on wall or cliff.
Enemy collision: AABB → death.
Trophy: AABB → collect.
Exit: if hasTrophy && overlap → next level.
Death: lives--, respawn or game over.
```

Procedural draw functions: drawBrick, drawFire(t), drawWater(t), drawTrophy(t), drawDoor(locked), drawPlayer(dir, frame), drawEnemy(t).

Also collectible gems for score — DD has loot collection. Add gems `G` for score. Nice bonus.

Now let's write the complete HTML file. Reasonably concise but polished. Include title screen and instructions overlay.

Water: in DD water is instant death. Draw an animated water surface. Make water lethal when player's center enters.

Level design: 3 levels, width ~50-60, height 15 rows.

Level 1 (easy intro):
```
..................................................
..................................................
..................................................
..................................................
..................................................
..........G.G...................G................
.........#####......G.G.......#####.....E........
.....P..............#####...............#........
...######....###.............M....T.....#........
....................F....############...#........
.####........#######F#..................#........
...........W.................G..........#........
##########################################....WWWW#
```
Hmm, need to be careful with rows having equal width. Let me design carefully in the file, making each level a rectangular grid (pad with dots).

Design levels in code with consistent widths. Let me try:

Level 1 (width 50, height 15):
```
row0: 50 dots
...
```
I'll carefully design each row in the file. Plan for level 1 layout:

- Ground on the bottom row, with some gaps filled with water.
- A fire pit somewhere.
- Trophy on a platform.
- Exit in the far right, on a pedestal.
- 1-2 enemies.
- Some gems.

Do it by hand, making sure rows are equal width. In code, I can normalize with padEnd.

Now let's write the file. Aim for good visuals: gradient sky background per level, parallax hills optional (simple). Keep it clean.

Jump feel: gravity 0.5, jump velocity -10.5, move speed 3.2. TS=32.

Enemy-player collision: check overlap → death, but if player lands on top, stomp? DD doesn't have stomping. Keep it simple: contact = death. Actually stomping is fun; but keep DD style: contact death.

Death animation: brief flash, then respawn. Use a state timer.

Let's write it all out.

Solid collision resolution: move x, check overlapping tiles, clamp; move y, similarly; determine grounded.

Fire hazard: draw flames on top of the tile; is the hazard tile itself non-solid? In DD, fire is on the ground; if you touch the flames you die. Make fire tiles non-solid and lethal (falling into a fire pit). Place fire on top of solid ground tiles: F is drawn on top of the ground below. Simpler: F occupies a tile, non-solid, lethal.

Water: non-solid, lethal.

Exit door: drawn 1 tile wide, 2 tiles tall, maybe; make E the tile at the base of the door, draw the door occupying that tile plus the one above. Overlap check on that tile.

Trophy: floating, bobbing up and down.

Gems: small diamonds, collectible, +100 points.

HUD: score, lives, level, trophy icon.

Alright, writing the file now. Careful with code correctness (no testing, so keep logic straightforward).

Main function:

```js
function solidAt(px,py) // tile coords
```

Collision:
```js
function moveAndCollide(o){
  o.x+=o.vx;
  // horizontal
  if(o.vx>0){ check right-edge tiles } ...
}
```
Standard approach: after x movement, iterate over overlapping tiles, if solid then push back.

Writing it like this:

```js
function collideX(e){
  const top=Math.floor(e.y/TS), bot=Math.floor((e.y+e.h-0.01)/TS);
  if(e.vx>0){
    const tx=Math.floor((e.x+e.w)/TS);
    for(let ty=top;ty<=bot;ty++) if(isSolid(tx,ty)){e.x=tx*TS-e.w;e.vx=0;return true;}
  } else if(e.vx<0){
    const tx=Math.floor(e.x/TS);
    for(let ty=top;ty<=bot;ty++) if(isSolid(tx,ty)){e.x=(tx+1)*TS;e.vx=0;return true;}
  }
  return false;
}
```

Same for vertical, setting grounded when landing.

Enemy cliff check: check if there's a solid tile ahead and below; if not, flip.

Camera: camX = clamp(player.cx - canvas.w/2, 0, levelW*TS - canvas.w).

Canvas 960x480 (15 rows * 32 = 480).

Levels: height 15 rows.

Now design 3 levels. Write rows as strings, pad to max width in code.

Level 1 — "The Cavern" (width 52):

```
....................................................
....................................................
....................................................
....................................................
........G.G......................G.G..............
.......#####..........G.........#####.............
....................######..................E.....
..P..........###..............T.....###....###....
.####.....................#########...............
..........###.....###..........................###
.................F...........G.......M............
######..######..#####....#########......##########
WWWWWW..WWWWWW..WWWWW....WWWWWWWWWW.....WWWWWWWWWW  <- hmm
```

Getting messy. Alternative: make ground continuous along the bottom, dig holes for water/fire. Let me write it carefully, row by row.

Let's do width 54, height 15.

Level 1:
```
r0 : ......................................................
r1 : ......................................................
r2 : ......................................................
r3 : ......................................................
r4 : ......................................................
r5 : ..........G.G...........................G..............
r6 : .........#####............G.G..........###.............
r7 : .......................#######.................E.......
r8 : ..P...........###...................T........#####.....
r9 : .####....###.........M...........########..............
r10: ...............############..............M........#....
r11: ..........F........................###......#######....
r12: #########F#############...###########...##.............
r13: #########F#############...###########...##.............
r14: #########F#############WWW###########WWW##WWWWWWWWWWWWWW
```

Hmm, need to put trophy T in an accessible spot. Also exit E requires a floor below. Let me simplify; exact design isn't super critical as long as it's playable: verify each platform is reachable with jump height. Jump velocity -10.5, gravity 0.5 → max height ≈ 10.5²/(2*0.5) = 110px ≈ 3.4 tiles. So a 3-tile jump up is OK.

Actually, to avoid bugs, let me design the levels more carefully. Simpler design philosophy: mostly stair-stepped floors.

Level 1 (width 54):
```
0: 54 dots
1: 54 dots
2: 54 dots
3: 54 dots
4: 54 dots
5: 54 dots
6: 54 dots
7: 54 dots
8: ..P...........................................E.....
9: .###......###.....###.......###.....###....###.###...
```
This is too plain. Let me mix it up.

OK, take a pragmatic approach: write levels as strings, and mentally verify jump distances (max 3 tiles up, ~4-5 tile horizontal gap during jump). Build them carefully with moderate complexity. In code, normalize widths.

Now to write it:

Level 1:
```
"......................................................",
"......................................................",
"......................................................",
"......................................................",
".........G.G...........................G.G............",
"........#####...........G.G...........#####...........",
".......................#####....................E.....",
"..P..........###..................T........##########.",
".###....M..............###.....#########..............",
".....#########....F..........................M........",
"..............#######F#####......###....###########...",
"...........W..........................W...............",
"###########WW######...####...##########WWW############",
```

Width check: count the chars… error-prone. In code, I can pad rows with '.' to the max length and not worry about it. But placement depends on column alignment; I'll trust manual writing. Actually, as a safety measure, write it in a column-consistent way: build each level row by row, being careful that each is exactly 54 chars. Count characters in groups of 10.

Alternatively, design levels at a smaller width, say 40, and verify by counting. 40 chars per row: 4 groups of 10.

Level 1 (40 wide, 13 high):

```
0: "........................................"
1: "........................................"
2: "........................................"
3: "........................................"
4: "........................................"
5: "..........G.G..................G........"
6: ".........#####......G.G.......###....E.."
7: "..P...............#####.............###."
8: ".###......###..............T........##.."  -- hmm
```

Still messy. Let me build each level deliberately, row by row, counting as I go. Using a 40-char grid with column indices 0-39.

Row template: index
"0123456789 0123456789 0123456789 0123456789"

Level 1 design plan:
- Player spawns at column 2, standing on a ground platform in row 9 (platform is row 10).
- Ground: rows 11-12 are mostly solid, with a water gap at columns 16-18 and fire in a hole at columns 27-29.
- Middle platforms, gems.
- Trophy on a platform around columns 24-26, row 7.
- Exit at column 37, on a pedestal, near the right edge.
- 1 enemy on the ground row.

Rows (height 13, width 40):

r0: dots.
r1: dots.
r2: dots.
r3: dots.
r4: dots.
r5: gems at columns 10-12? Place "G.G" at columns 10-12, above a platform on r6 columns 9-13.
r6: "#########" at columns 9-13. Also gem "G.G" at columns 22-24, above the platform? Trophy platform later.
r7: platform columns 21-25, trophy T at column 23 on r6? Trophy floats; put T at r6 column 23, above the platform on r7.
Let me settle:

r5: "..........G.G........................." → columns 10, 12 are gems.
r6: ".........#####........G.G............." → solid columns 9-13; gems at columns 22, 24.
r7: ".....................#####......T....." → solid columns 21-25; trophy at column 32? No, T is at column 32 of r7.
Hmm, T needs a floor: pedestal for T at r8 columns 31-33.
r8: "...............................###...." → columns 31-33.
r9: "..P..................M................" → spawn at column 2, enemy at column 21? Enemy walks on top of the ground row 10.
r10: "##########...######.####....##########" wait, I need water holes and fire.

Ground: r10 solid except gaps: water gap at columns 13-15 (WW), fire pit at columns 26-28: fire sits on top of a solid at r11? Fire tiles: F on r10 inside the pit, solid at r11. Let's make the ground 2 rows thick: r10 and r11.

r10: cols 0-12 "#############" (0-12), cols 13-15 gap with water (W on r10, W on r11?), cols 16-25 solid, cols 26-28 fire pit (F on r10, solid on r11), cols 29-39 solid.
r11: cols 0-12 solid, cols 13-15 W, cols 16-25 solid, cols 26-28 F? Fire pit: F only in the row the player would fall into, floor beneath. Put F at r11 cols 26-28, r10 cols 26-28 empty, and r12 solid underneath? Total height 13, rows 0-12. Let's use height 14, rows 0-13. Bottom rows: r12 and r13 ground.

Simplify: height 14.
r12: ground row, mostly solid: gaps at cols 13-15 (water), 26-28 (fire pit floor at r13).
r13: solid everywhere except cols 13-15 are W (water is 2 deep), cols 26-28 are F.

So falling into the cols 13-15 gap: W on r12 and r13 → instant death. Fire pit: r12 cols 26-28 empty, r13 has F — jumpable (gap 3 tiles, ~4-tile horizontal jump with speed 3.2 and airtime ~0.7s… jump full airtime: 2*10.5/0.5 = 42 frames = 0.7s at 60fps → horizontal 42*3.2 ≈ 134px ≈ 4.2 tiles. OK, can jump a 3-tile gap.)

Upper structure:
- Spawn on r11? Player stands on top of r12 → player y is in row 11 area. P at r11 column 2.
- Enemy M at r11 column 20 (walks on r12).
- Platform A r9 columns 5-8 (jump from ground, r12 top to r9 top = 3 tiles up, OK).
- Gems on top of platform A: G at r8 columns 5, 7.
- Platform B r8 columns 12-16 — above the water gap, reachable from platform A (r9 → r8, 1 up, horizontal gap columns 8 → 12, 4 tiles, OK).
- Platform C r9 columns 20-24 (below B, drop from B or jump from ground).
- Trophy platform D r10? No — trophy should require some navigation. Place trophy platform at r7 columns 21-25? Reachable from B (r8 col 16 → r7 col 21: 1 up, 5 horizontal gap — tight). Or from C (r9 → r7, 2 up, no problem if columns overlap: C is columns 20-24, D is directly above at r7 columns 21-25? Then jumping from C r9 to D r7: 2 tiles up, no problem.)
Wait, D at r7 with C at r9 below means 1-tile gap between? C top r9, D bottom r8… D at r7 occupies row 7; player standing on C is at r8. Jumping 2 up to land on D (top r7, standing at r6). Fine.
- Trophy T at r6 column 23.
- Platform E r8 columns 29-31 (drop/jump from C across the fire pit? C ends at col 24, fire pit cols 26-28 at r12… E at r8 columns 29-31 is reachable from D (r7 col 25 → r8 col 29: drop + 4 across, OK) or directly from C.
- Exit pedestal r9 columns 33-35, E at r8 column 34. Reachable from E (r8 → r9 top, drop) hmm, exit pedestal r9 top, player stands on r8. From platform E (r8 top, standing on r7) drop right to pedestal. Fine.

That gives a solid Level 1. Now write rows carefully, width 40:

r0: 40 dots
r1: 40 dots
r2: 40 dots
r3: 40 dots
r4: 40 dots
r5: 40 dots
r6: cols: T at 23 → dots and T: ".......................T................"
   positions 0-39: T at index 23. Count: 23 dots + "T" + 16 dots = 40. ✓
r7: platform D cols 21-25: 21 dots + "#####" (5) + 14 dots = 40. ".....................#####.............."
r8: gems? Gems on B? Gems at r7 cols 13, 15, above B (r8)? B top r8, gems float at r7. But D is also r7 cols 21-25 — no problem. Platform B cols 12-16 at r8: "#############"? cols 12-16 is 5 tiles. Platform E cols 29-31: 3 tiles.
   r8 = 12 dots + "#####" + 12 dots (cols 17-28) + "###" + 8 dots = 12+5+12+3+8=40. ✓
   "............#####............###........"
   Gems at r7 cols 13, 15: but r7 currently is 21 dots + platform. Rebuild r7: gems G at 13, 15; platform D at cols 21-25.
   r7 = 13 dots + G + dot + G + 5 dots (17-20) + "#####" + 14 dots = 13+1+1+1+5+5+14=40 ✓
   ".............G.G....#####.............."
   Count: 13 dots, G, dot, G, 5 dots = index 16… wait, 13+1+1+1+5 = 21 chars, so platform at indices 21-25 ✓, then 14 dots → total 40 ✓.
r9: platform A cols 5-8 (4), platform C cols 20-24 (5), exit pedestal cols 33-35 (3).
   = 5 dots + "####" + 11 dots (9-19) + "#####" + 8 dots (25-32) + "###" + 4 dots = 5+4+11+5+8+3+4=40 ✓
   ".....####...........#####........###...."
   Hmm wait, pedestal top r9 means standing row r8; exit E at r8 column 34. But r8 has 8 dots at cols 25-32 then "###" at 33-35? No — r8 is platform E at 29-31, then 8 dots at 32-39. Exit E is at r8 col 34, which is empty on r8 ✓. So E marker at index 34 of r8. Update r8:
   r8 = 12 dots + "#####" (12-16) + 12 dots (17-28) + "###" (29-31) + 2 dots (32-33) + "E" (34) + 5 dots (35-39) = 12+5+12+3+2+1+5=40 ✓
   "............#####............###..E....."
r10: empty (dots).
r11: P at column 2, M at column 20: "..P.................M..................." = 2 dots + P + 17 dots (3-19) + M + 19 dots = 2+1+17+1+19=40 ✓
r12: cols 0-12 solid (13), cols 13-15 empty (fall to water), cols 16-25 solid (10), cols 26-28 empty (fire pit), cols 29-39 solid (11): 13+3+10+3+11=40 ✓
   "#############...##########...###########"
r13: 13 solid + WWW + 10 solid + FFF + 11 solid:
   "#############WWW##########FFF###########"

Wait: water pit cols 13-15 is 3 wide, jumpable ✓. Fire pit cols 26-28, F at bottom r13, falling in = death ✓.

Reachability check: exit pedestal cols 33-35 top r9; from platform E (cols 29-31, r8): walk right and drop ✓. Trophy D r7 cols 21-25, from C (r9 cols 20-24): jump 2 up ✓. From ground to C: ground r12 top → C r9 top = 3 up ✓ (barely, max 3.4). From ground to A: r12→r9, 3 up ✓. A (r9 col 8) → B (r8 col 12): 1 up, gap cols 9-11 (3 wide) ✓.

Gems at r7 cols 13, 15, above B: stand on B (r8), gems at r7 adjacent above — collect with head overlap ✓. Gems at r5? Deleted; fine. Add one more gem at r5 col 23, above trophy platform? Player stands at r6 on D; gem at r5 col 23… T is at r6 col 23. Both on the same tile? No — T at r6 col 23, gem above at r5 col 23? Collect T by walking; gem requires jump — fine, add it. r5: 23 dots + G + 16 dots. OK, add it.

Level 2 — more vertical/hazardous, maybe 44 wide. Design similarly, add 2 enemies and more fire. Also add floating fire platforms? Keep fire on the ground.

Level 2 (width 44, height 14):
Theme: fire caves. Let me build:

r0-r3 dots.
r4: gem row: G at columns 8, 10, above a platform at r5.
r5: platform cols 7-11 ("#####").
r6: …
Let me think about the layout: a zig-zag up and down, with a trophy in the center, guarded by an enemy on the platform.

Plan:
- Spawn on ground left, col 2.
- Ground r12/r13: gaps with fire at cols 10-12, water at cols 22-24, fire at cols 32-34.
- Platform r10 cols 4-7; r9 cols 13-17 (enemy); r10 cols 25-28; trophy platform r7 cols 19-21 (above enemy platform, reached by jumping from r9 cols 13-17? 2 up from r9 → r7 platform cols 19-21, horizontal: from col 17 to col 19, OK); exit platform right r10 cols 36-39, exit E at r9 col 38, or ground right side beyond final fire pit.

Enemy placement: one on ground at col 16, one on platform r9.

Gems sprinkled.

Rows (44 wide):
r4: G at cols 8, 10: "........G.G................................." = 8 dots + G + dot + G + 33 dots = 8+1+1+1+33=44 ✓
r5: platform cols 7-11: 7 dots + "#####" + 32 dots = 44 ✓ ".......#####................................"
r6: gem above r9 platform? Gem at r7 cols 14, 16 (above enemy platform r8?)… Let me restructure rows:

Actually, let's do:
r6: dots
r7: trophy platform cols 19-21: 19 dots + "###" + 22 dots = 44 ✓; T at r6 col 20: r6: 20 dots + T + 23 dots = 44 ✓.
r8: gem at cols 15, 17, above platform r9 cols 14-18: r8 = 15 dots + G + dot + G + 26 dots = 44 ✓.
r9: 14 dots + "#####" + 25 dots = 44 ✓.
r10: platform cols 4-7 (4) and cols 25-28 (4), exit platform cols 37-40 (4): 4 dots + "####" + 17 dots (8-24) + "####" + 8 dots (29-36) + "####" + 3 dots (41-43) = 4+4+17+4+8+4+3=44 ✓.
   "....####.................####........####..."
r11: P col 2, M col 16 (on r9 platform? Enemy on platform: M at r8 col 16 — but gem at r8 col 15, 17, M at 16 between them ✓). Ground enemy M at r11 col 30? Ground cols 29-31 exist (r12 solid? Gap 32-34 is fire). M on r11 at col 30. Also M on r8 col 16.
   r11 = "..P............................M..........." → 2 dots + P + 27 dots (3-29) + M + 11 dots = 2+1+27+1+11=42. Need 44: 2+1+27+1+13=44. "..P.............................M..........."
   Count: indices: P at 2, M at 30. 30 = 2+1+27 → yes dots 3..29 = 27 ✓, then M, then dots 31..43 = 13 ✓.
r8 update: M at col 16, G at 15, 17: 15 dots + G + M + G + 26 dots = 15+3+26=44 ✓ "...............GMG.........................."
r12: solid cols 0-9 (10), fire gap cols 10-12, solid 13-21 (9), water gap 22-24, solid 25-31 (7), fire gap 32-34, solid 35-43 (9): 10+3+9+3+7+3+9=44 ✓
   "##########...#########...#######...#########"
r13: 10 solid + FFF + 9 solid + WWW + 7 solid + FFF + 9 solid:
   "##########FFF#########WWW#######FFF#########"

Route check: ground r12 top, standing r11. Platform r10 cols 4-7: jump 2 up from ground ✓. r10 col 7 → r9 cols 14-18: 1 up, horizontal gap cols 8-13 = 6 tiles — too far. Add intermediate platform at r10 cols 10-13? That's above the fire pit (cols 10-12) — good, platform above fire is dangerous! Add r10 cols 10-13: r10 becomes 4 dots + "####" (4-7) + 2 dots (8-9) + "####" (10-13) + 11 dots (14-24) + "####" (25-28) + 8 dots (29-36) + "####" (37-40) + 3 dots = 4+4+2+4+11+4+8+4+3=44 ✓
"....####..####...........####........####..."
Then r10 col 13 → r9 col 14: jump 1 up, adjacent ✓. Or from ground below, jump to r10 10-13 (2 up) ✓.
r9 col 18 → r7 cols 19-21: 2 up ✓.
r7 col 21 → r10 cols 25-28: drop/jump right ✓. Then r10 col 28 → exit platform r10 cols 37-40: gap cols 29-36 = 8 wide, same height — too far. Drop to ground (r12 solid cols 25-31), cross fire pit 32-34 (3-wide jump ✓), and from ground to exit platform r10 cols 37-40: ground r12 top → r10 top = 2 up ✓.
Exit E on r9 platform: E at r9 col 38. r9 currently has 14 dots + platform… update r9: 14 dots + "#####" (14-18) + 19 dots (19-37) + E at 38 + 5 dots = 14+5+19+1+5=44 ✓ "..............#####...................E....."
Hmm wait, exit platform r10 cols 37-40, exit stands on it at r9 col 38 ✓.

Trophy T at r6 col 20, above platform r7 cols 19-21 ✓. Gems at r4 cols 8, 10, above platform r5 cols 7-11: from platform r10 cols 4-7, jump to r5?? 5 tiles up — impossible. Route to r5 platform: from ground? r12→r5 = 7 up. No good. Need stairs: r10 cols 4-7 → add r7 cols 2-5? Then r7 col 5 → r5 cols 7-11 (2 up, gap 1) ✓. Add platform r7 cols 2-5: update r7: 2 dots + "####" + 13 dots (6-18) + "###" (19-21) + 22 dots = 2+4+13+3+22=44 ✓
  "..####.............###......................"
r10 col 7 → r7 col 5? 3 up, 2 back horizontally — OK (max 3.4 up) ✓.

Level 2 is good. Enemies: M at r8 col 16 patrols platform r9 cols 14-18 (walks on top of r9). M at r11 col 30 patrols ground between the pits (cols 25-31) ✓ (cliff/wall check flips it).

Level 3 — "The Gauntlet", harder. Width 48, height 14. Water theme + both hazards, 3 enemies.

Quickly design similarly:
r12 ground: solid 0-7, water 8-10, solid 11-18, fire 19-21, solid 22-29, water 30-33 (4 wide), solid 34-47.
r13: 8 # + WWW + 8 # + FFF + 8 # + WWWW + 14 #. Count: 8+3+8+3+8+4+14=48 ✓.
r12: 8 # + "..." + 8 # + "..." + 8 # + "...." + 14 # ✓.
- Spawn P col 2, r11.
- Water gap 30-33 is 4 wide: need platform above r11 cols 31-32? Small stepping-stone platform at r11? Place platform r11 cols 31-32 (2 tiles). Hmm, a 4-wide gap can be jumped (max 4.2 tiles), barely; add platform r11 cols 31-32 as a rest. Actually, jumping 4-wide from edge col 29 to col 34: player width 20px… with speed 3.2 and 42-frame full airtime: 134px = 4.2 tiles — just barely. Add stepping stone.
- Trophy high center: platform r6 cols 23-25, T at r5 col 24.
- Stairs: ground → r10 cols 12-14 → r8 cols 16-19 → r6 cols 23-25? Gap 20-22 (3) and 2 up ✓.
- Alternative route: platform r9 cols 6-8? Cross water 8-10 at r9 height, then r8 cols 16-19.
   Ground col 7 → r10 cols 12-14: 2 up, gap 8-11 (4 wide) hmm, gap above water cols 8-10 = 3 wide, jump 2 up and 4 across — tight. Make r10 platform cols 11-13 (right after the pit): gap cols 8-10 = 3 wide, 2 up ✓.
- Exit on high pedestal right: platform r10 cols 40-43, E at r9 col 42? Or stairs: ground → r10 cols 36-38? Let's do: exit platform r9 cols 43-46, E at r8 col 45; step r11 cols 39-40? Ground r12 → r11 step cols 39-40 (1 up) → r9? 2 up from r11 top to r9 top ✓ platform r9 cols 43-46, gap 41-42 ✓.
- Enemies: M r11 col 15 (ground section 11-18), M r7 col 17 (on r8 platform cols 16-19), M r11 col 36 (ground 34-47, patrols until wall/pit).
- Gems: r9? Sprinkle: G at r9 cols 12, 14 (above r10 platform cols 11-13)? Platform top r10, stand at r9: gems at r9 cols 12, 14? 14 is outside platform (platform 11-13), gem at r9 col 13… let's do gems at r9 cols 11, 13? Overlaps platform edge; simpler: gems above trophy route, at r7 col 17? Enemy walks there. Gems at r5 cols 23, 25, above trophy platform (stand at r5… T at r5 col 24 same row ✓ nice cluster).
- Also fire pillars? Place F at r11 cols 19-21 (above solid r12? no — r12 19-21 is empty pit). Keep pits.

Rows for level 3 (48 wide):
r0-r4 dots.
r5: 23 dots + G + T? T at col 24, G at 23, 25: 23 dots + "GTG" + 22 dots = 23+3+22=48 ✓
r6: 23 dots + "###" + 22 dots ✓
r7: M at col 17: 17 dots + M + 30 dots = 48 ✓
r8: 16 dots + "####" + 28 dots = 48 ✓
r9: gems at cols 11, 13? Platform r10 cols 11-13 → stand at r9; gems float at r8? r8 has platform at 16-19. Gems at r9 cols 11, 13: fine. Exit platform r9 cols 43-46, E at r8 col 45: update r8: 16 dots + "####" (16-19) + 25 dots (20-44) + E at 45 + 2 dots = 16+4+25+1+2=48 ✓
   r9: 11 dots + G + dot + G + 29 dots (14-42) + "####" (43-46) + 1 dot = 11+1+1+1+29+4+1=48 ✓
r10: 11 dots + "###" (11-13) + 22 dots (14-35) + "##"? Exit step: r11 cols 39-40. Platform r10 cols 40-43? Not needed; keep r10: 11 dots + "###" + 34 dots = 48 ✓
r11: P col 2, M col 15, step platform cols 39-40, M col 36… M walks on ground; step platform at r11 cols 39-40 (solid). Wait, step platform should be solid tiles at r11 (1 tile above ground): player jumps 1 up on it, then jumps 2 up from there to r9 platform. r11 = "..P............M...................M..##........"
   Count: 2 dots + P (2) + 12 dots (3-14) + M (15) + 20 dots (16-35) + M (36) + 2 dots (37-38) + "##" (39-40) + 7 dots (41-47) = 2+1+12+1+20+1+2+2+7=48 ✓
r12: 8 # + "..." (8-10) + 8 # (11-18) + "..." (19-21) + 8 # (22-29) + "...." (30-33) + 14 # (34-47) = 8+3+8+3+8+4+14=48 ✓
   "########...########...########....##############"
r13: "########WWW########FFF########WWWW##############"

Check: M col 15 on r11 patrols ground section cols 11-18 ✓. M col 36 patrols section 34-47, but step platform at r11 cols 39-40 is a wall for it — enemy hits wall, flips ✓ fine.
Trophy route: ground → r10 cols 11-13 (jump over water pit 8-10: from col 7 edge, 2 up and 3-4 across — OK). → r8 cols 16-19 (from r10 col 13: 2 up, gap 14-15 = 2 ✓). → r6 cols 23-25 (from r8 col 19: 2 up, gap 20-22 = 3 ✓). Grab GTG ✓. Then descend right: r6 → ground cols 22-29 ✓. Fire pit 19-21 below platform r8 cols 16-19 — falling = death ✓. Water 30-33: jump from col 29 to col 34 = 4 wide — barely, or… no resting platform above. Max jump distance: from very edge… 42 frames * 3.2 = 134px ≈ 4.2 tiles; need to clear 4 tiles = 128px + player width margin — actually player left edge from col 30 to col 34*32 = 128px, player w=20, need ~148px? Hmm: standing at edge col 29, player right edge at x=30*32. Land on col 34: player left edge ≤ 34*32. Player left edge initially ≈ 30*32 - 20. Distance = 34*32 - (960-20) = 1088-940 = 148px > 134. Not doable! Need stepping stones. Add platform r11 cols 31-32 above water: update r11: "..P............M...................M..##........" → add "##" at 31-32: 2 dots + P + 12 dots + M + 15 dots (16-30) + "##" (31-32) + 3 dots (33-35) + M (36) + 2 dots + "##" (39-40) + 7 dots = 2+1+12+1+15+2+3+1+2+2+7=48 ✓
   "..P............M...............##...M..##........"
   Count: after P: dots 3-14 (12), M at 15, dots 16-30 (15), "##" at 31-32, dots 33-35 (3), M at 36, dots 37-38, ## at 39-40, dots 41-47 (7). Total = 2+1+12+1+15+2+3+1+2+2+7 = 48 ✓
   String: "..P............M...............##...M..##......."
   Hmm count: "..P" (3) + 12 dots (15) + "M" (16) + 15 dots (31) + "##" (33) + 3 dots (36) + "M" (37) + 2 dots (39) + "##" (41) + 7 dots (48). ✓
   Wait, platform at r11 cols 31-32: ground r12 below cols 30-33 is a gap, so platform floats above water ✓. Player jumps from ground col 29 to platform (1 tile up? Platform top r11, ground top r12 → 1 up, gap 30 = 1-2 wide ✓), then to col 34 (1 up? Same height… platform top r11, ground top r12: from platform (standing at r10) jump down/right 2 tiles to col 34 ✓).
   Also M at col 15: fine. Enemy at col 36 hits ## wall at 39, patrols 34-38 ✓.

Exit E at r8 col 45, platform r9 cols 43-46: from step r11 cols 39-40 (standing r10), jump 2 up to r9 platform cols 43-46: gap 41-42 = 2 ✓. Then walk to E ✓.

Also, add an enemy on r5 platform (guarding trophy)? Platform r6 cols 23-25 is 3 wide, enemy patrols. Add M at r5 col 24? Trophy T is at r5 col 24. Conflict; skip.

Level 3 is good. 3 levels.

Enemy patrol logic: vx = ±1; each frame check tile ahead at feet and wall ahead; if wall or no floor ahead, flip.

Now code. Structure:

```html
<!DOCTYPE html>
<html><head><meta charset="utf-8"><title>Dangerous Dave-ish</title>
<style> ... dark background, centered canvas, HUD styling via canvas draw ... </style>
</head><body>
<canvas id="game" width="960" height="480"></canvas>
<script> ... </script>
</body></html>
```

Canvas 960x480; level height 14 rows * 32 = 448 < 480, so offset or draw HUD in top 32px? Camera vertical fixed: levelH*TS=448, canvas 480, offset 32 downward, HUD in top band. Good.

State machine: 'title' | 'play' | 'dead' | 'levelComplete' | 'gameover' | 'won'.

Death: animation timer ~40 frames (flash/rotate), then lives-- and respawn or game over.

Level clear: overlay for ~90 frames, then next level or victory.

Input: keydown/keyup, keys object. preventDefault arrows/space.

Player physics constants:
- accel 0.6, max speed 3.4, friction 0.8 (when no input), gravity 0.55, jumpV -11 → height = 121/1.1 = 110px ≈ 3.4 tiles ✓. Airtime = 2*11/0.55 = 40 frames → distance 136px. ✓ Matches calculation.
- Coyote frames 6, jump buffer 6.

Hazard detection: sample tiles overlapped by slightly-shrunken hitbox; if tile is F or W, die. Water maybe only if submerged > half? Instant death is fine.

Enemies: array {x, y, w: 26, h: 22, vx}. Ground y placed at (row+1)*TS - h.

Trophy: {x, y (tile), taken}. Draw at tile center with bob. Gem same.

Exit: tile; door drawn 2 tiles tall (occupying exit tile + above). If hasTrophy and player AABB overlaps exit tile region, activate. If not hasTrophy, show hint "Get the trophy!".

Background draw: vertical gradient per level theme + parallax cave hills (procedural, seeded per level: draw rounded hills using sin).

Tile draw:
- '#': brick with mortar lines, subtle color per level theme.
- F: animated flames: draw 3 flame tongues using sin(time + x). Orange/yellow gradient blobs. Also embers.
- W: water: blue fill with animated surface highlight and sine ripples; slightly transparent.
- T: gold cup: cup body, handles, stem, base + shine + glow pulse.
- G: gem: cyan diamond with sparkle.
- E door: gray/stone arch; green glow when unlocked, otherwise darker + lock icon.

Player draw: little explorer: body rect, head, hat, eye, legs animated with walk cycle, arms. Flip with scale(-1, 1) translate for direction. Death: rotate + flash red.

Enemy: purple blob with eyes, squash animation.

HUD: top bar (y 0-32): "SCORE", "LIVES ♥", "LEVEL", trophy icon showing collected/not.

Title screen: big text, control instructions, "Press ENTER".

Level intro text: briefly show level name.

Sound: skip (no assets; WebAudio beeps possible — procedural, allowed). Add tiny WebAudio blips for jump/gem/death/win. Nice touch; keep short. Add simple beep(freq, dur, type) function. Guard AudioContext creation on first input.

Now write the final code carefully.

Parse:
```js
function loadLevel(n){
  const rows = LEVELS[n];
  const W = Math.max(...rows.map(r=>r.length));
  grid = []; hazards etc: single grid of chars, padded with '.'.
  entities...
}
```
Grid char handling: '#' solid; 'W', 'F' hazards (non-solid); others empty. Store entities separately and replace with '.'.

isSolid(tx,ty): outside → treated as solid on left/right? Outside horizontally: solid to prevent leaving; above: empty; below: solid.

Death respawn: reset player position to spawn point, keep trophy? In DD, collected items stay. Keep trophy/gems collected; reset enemies.

Score: gem 100, trophy 1000, level clear 500.

Lives: 3.

Now write. Also mobile? Skip.

Camera shake on death — small polish, cheap.

Draw player with squash on landing? Keep it simple.

Let's write the JS carefully (~450 lines).

Enemy edge check details:
```js
function updateEnemy(e){
  e.x += e.vx;
  const dir = Math.sign(e.vx);
  const footY = e.y + e.h + 1;
  const aheadX = dir>0 ? e.x + e.w + 1 : e.x - 1;
  const wallTy = Math.floor((e.y + e.h/2)/TS);
  if(isSolid(Math.floor(aheadX/TS), wallTy) || !isSolid(Math.floor(aheadX/TS), Math.floor(footY/TS))){
    e.vx = -e.vx; e.x += e.vx*2;
  }
}
```

isSolid outside: tx<0 or tx>=W → true; ty<0 → false; ty>=H → true.

Hazard check function:
```js
function touchesHazard(b){
  const x0=Math.floor((b.x+4)/TS), x1=Math.floor((b.x+b.w-4)/TS);
  const y0=Math.floor((b.y+4)/TS), y1=Math.floor((b.y+b.h-4)/TS);
  for(ty y0..y1) for(tx x0..x1){ const c=tile(tx,ty); if(c==='F'||c==='W') return true; }
}
```

Water should maybe only kill when player is deep in: fine, kills when overlapping.

Fire visual: F tile is non-solid, player falls through while dying — that's OK.

Player vertical collision:
```js
p.vy += G; cap 12;
p.y += p.vy;
if(p.vy>0){ ty=floor((p.y+p.h)/TS); for tx in range: if solid → p.y=ty*TS-p.h; p.vy=0; grounded=true }
if(p.vy<0){ ty=floor(p.y/TS); ... p.y=(ty+1)*TS; p.vy=0 }
```

Jump: if (jumpBuffered && (grounded || coyote>0)) → vy=jumpV.

Variable jump: on keyup jump, if vy<0 vy*=0.5.

Now write the file.

Flame draw function:
```js
function drawFire(x,y,t){
  // x,y top-left of tile in px
  const flick = Math.sin(t*0.2 + x*0.7);
  ctx gradient... draw 3 tongues: for i in 0..2: cx = x+6+i*10 + sin(t*0.15+i*2+x)*3; height varies.
}
```
Use overlapping radial gradients or simple bezier flames. Simple: 3 orange flame tongues (triangles/quadratic curves), inner yellow.

Water: fill rect with blue gradient, surface waves: draw sine-wave light stroke; bubbles.

OK, writing final answer file now. Also add level names: ["The Caverns", "Lava Depths", "The Gauntlet"].

Background themes per level: colors: L1 teal cave, L2 dark red, L3 deep blue.

Parallax hills: for i layers, draw silhouette using sin functions, offset by camX*factor.

Title screen: draw some tiles as decoration? Just text + small animated flame/player preview. Keep it text-based.

Enter key for state transition. R key to restart.

Let me finalize level strings, double-check widths:

Level 1 (width 40):
```
"........................................",  r0
"........................................",  r1
"........................................",  r2
"........................................",  r3
"........................................",  r4
".......................G................",  r5  (G at 23)
".......................T................",  r6  (T at 23)
".............G.G....#####...............",  r7
"............#####............###..E.....",  r8
".....####...........#####........###....",  r9
"........................................",  r10
"..P.................M...................",  r11
"#############...##########...###########",  r12
"#############WWW##########FFF###########",  r13
```
Check r7: 13 dots + "G.G" (3) + 4 dots (17-20) + "#####" (21-25) + 14 dots = 13+3+4+5+14=39. Off by one! Let me recount: indices: G at 13, dot 14, G at 15, dots 16-20 (5 dots), platform 21-25, dots 26-39 (14). Total = 13+1+1+1+5+5+14 = 40 ✓. So the string: 13 dots, "G.G", 5 dots, "#####", 14 dots. ".............G.G.....#####.............." — earlier I wrote 4 dots; correct is 5. String: ".............G.G.....#####" + 14 dots.
r8: 12 dots + "#####" (12-16) + 12 dots (17-28) + "###" (29-31) + 2 dots (32-33) + "E" (34) + 5 dots (35-39): "............#####............###..E....." Count: 12+5+12+3+2+1+5=40 ✓. Check the 12 dots after platform: indices 17..28 = 12 ✓ then "###" at 29, 30, 31 ✓ dots 32, 33, E 34 ✓.
r9: ".....####...........#####........###...." : 5 dots + "####" (5-8) + 11 dots (9-19) + "#####" (20-24) + 8 dots (25-32) + "###" (33-35) + 4 dots = 5+4+11+5+8+3+4=40 ✓.
r5/r6: 23 dots + char + 16 dots ✓.
r11: 2 dots + P + 17 dots (3-19) + M + 19 dots (21-39): 2+1+17+1+19=40 ✓ "..P.................M..................."
r12: 13 # + "..." + 10 # + "..." + 11 # = 40 ✓ "#############...##########...###########" (count: 13+3+10+3+11=40 ✓)
r13: 13 # + WWW + 10 # + FFF + 11 # ✓.

Wait — Level 1 route: T at r6 col 23, platform D r7 cols 21-25 right below ✓ standing on r6 ✓. E at r8 col 34, pedestal r9 cols 33-35 ✓.
Platform B r8 cols 12-16; gems at r7 cols 13, 15 ✓ (head height when standing on B at r7 ✓).
Platform C r9 cols 20-24 → D r7: jump 2 up ✓ (r9 top to r7 top = 2 tiles = 64px < 110 ✓).
Platform A r9 cols 5-8 → B r8 cols 12-16: 1 up, gap 9-11 ✓.
Ground to A: 3 up, 99px < 110 ✓.
Gem G at r5 col 23: from D standing r6, jump 1 up ✓.

Fire pit r13 cols 26-28: falls in through empty r12 cols 26-28 ✓. Ground gap r12 cols 13-15 above water r13 cols 13-15 ✓.

Level 2 (width 44):
```
r0-3: 44 dots
r4: "........G.G.............................."  -> 8 dots + G.G + 33 dots = 44 ✓ "........G.G..............................."? Count dots after: 44-11=33 ✓. String: "........G.G" + 33 dots.
r5: 7 dots + "#####" + 32 dots ✓
r6: 20 dots + "T" + 23 dots ✓
r7: "..####.............###......................" → 2 dots + "####" (2-5) + 13 dots (6-18) + "###" (19-21) + 22 dots = 44 ✓
r8: "...............GMG.........................." → 15 dots + GMG (15-17) + 26 dots = 44 ✓
r9: "..............#####...................E....." → 14 dots + "#####" (14-18) + 19 dots (19-37) + E (38) + 5 dots = 44 ✓
r10: "....####..####...........####........####..." → 4 dots + "####" (4-7) + 2 dots (8-9) + "####" (10-13) + 11 dots (14-24) + "####" (25-28) + 8 dots (29-36) + "####" (37-40) + 3 dots (41-43) = 4+4+2+4+11+4+8+4+3=44 ✓
r11: "..P.............................M..........." → P col 2, M col 30: 2+1+27+1+13=44 ✓
r12: "##########...#########...#######...#########" → 10+3+9+3+7+3+9=44 ✓
r13: "##########FFF#########WWW#######FFF#########" ✓
```
Check r4: gems at cols 8, 10, above platform r5 cols 7-11 ✓ stand on r4 ✓.
Route to r5 platform: r10 cols 4-7 top → r7 cols 2-5 (3 up, overlap ✓) → r5 cols 7-11 (from r7 col 5: 2 up, gap col 6 ✓).
Exit platform r10 cols 37-40; E at r9 col 38 stands on it ✓. From r10 cols 25-28 drop to ground cols 25-31, jump fire pit 32-34, ground cols 35+, jump 2 up to r10 cols 37-40 ✓ (r12 top → r10 top = 2 up ✓).

Level 3 (width 48):
```
r0-r4: 48 dots
r5: 23 dots + "GTG" + 22 dots ✓
r6: 23 dots + "###" + 22 dots ✓
r7: 17 dots + "M" + 30 dots ✓
r8: 16 dots + "####" + 25 dots + "E" + 2 dots → E at 45 ✓ 16+4+25+1+2=48 ✓
r9: 11 dots + "G" + "." + "G" + 29 dots (14-42) + "####" (43-46) + 1 dot = 48 ✓
   "...........G.G.............................####."
r10: 11 dots + "###" + 34 dots ✓
r11: "..P............M...............##...M..##......." (calculated 48 ✓)
r12: "########...########...########....##############" 8+3+8+3+8+4+14=48 ✓
r13: "########WWW########FFF########WWWW##############" ✓
```
Level 3 r9: gems at 11, 13, above platform r10 cols 11-13 ✓.
M at r7 col 17: on platform r8 cols 16-19 ✓.
M at r8 col… no, M at r7 is standing on r8 ✓ patrols 16-19.

One concern: Level 3, player going right on ground cols 22-29, enemy M at r11 col 36 area; fine.

All levels height 14 (rows 0-13) ✓. Level 1 has width 40*32 = 1280 > canvas 960 ✓ camera works. Good.

Spawn safety: P at r11 col 2, ground r12 below ✓.

Enemy hitbox vs tile: enemy w 26 h 22, spawn y = (row+1)*TS - h.

Now enemy on r8 platform r9 cols 14-18 (Level 2): walks, flips at edge col 13/col 19 ✓.

Now write code. Include a brief instruction overlay during play for the first level? Show level name toast at level start.

Audio:
```js
let AC=null;
function beep(f,d,type='square',vol=0.04,slide=0){ if(!AC) return; const o=AC.createOscillator(), g=AC.createGain(); ... }
```
Initialize AC on first keydown.

Sounds: jump (square 300→? short), gem (sine 900, 0.08), trophy (arpeggio), death (saw 200→60), level clear (arpeggio), door unlock.

Now write everything. Also handle 'dead' state: timer, draw player spinning/falling, then respawn.

Edge cases: player falling below the level (shouldn't happen since r13 has solid except W pits… r13 water pit cols 13-15, Level 1: falling into water pit hits W at r12 or r13 → instant death before falling through ✓. If somehow y > levelH*TS + 100 → die.

Draw order: background → tiles (including water/fire behind player) → gems/trophy/door → enemies → player → HUD → overlays.

Door is 2 tiles tall: draw at exit tile and one above.

Write the file.

Now, writing the script carefully.

```js
'use strict';
const cvs=document.getElementById('game'), ctx=cvs.getContext('2d');
const TS=32, VW=cvs.width, VH=cvs.height;
const LEVEL_YOFF=32; // HUD band
```

Actually simpler: canvas 960x480; draw world with translate(-camX, LEVEL_YOFF).

Constants:
```js
const GRAV=0.55, JUMPV=-11, MOVE=3.4, ACC=0.6, FRICT=0.78;
```

Game object:
```js
const G={state:'title', level:0, score:0, lives:3, t:0};
```

loadLevel builds: grid (2D char array), player {x, y, vx, vy, w:20, h:28, dir:1, grounded, coyote, jbuf, spawnX, spawnY}, enemies [], gems [{tx, ty, taken}], trophy {tx, ty, taken}, exit {tx, ty}, hasTrophy, name.

Input:
```js
const keys={};
addEventListener('keydown', e=>{ if(['ArrowLeft','ArrowRight','ArrowUp','ArrowDown',' '].includes(e.key)) e.preventDefault(); keys[e.key.toLowerCase()...]});
```
Use e.key: 'ArrowLeft', 'a', etc. Normalize to lowercase.

jumpPressed edge: track in keydown (if !repeat) set jbuf=6. Jump cut in keyup.

Update player:
```js
const L = keys['arrowleft']||keys['a'], R = ...
if(L){p.vx=Math.max(p.vx-ACC,-MOVE); p.dir=-1}
else if(R){...}
else p.vx*=FRICT, snap to 0 if |vx|<0.05
p.vy=Math.min(p.vy+GRAV, 13);
if(p.jbuf>0)p.jbuf--;
if(p.coyote>0)p.coyote--;
if(p.jbuf>0&&(p.grounded||p.coyote>0)){p.vy=JUMPV; p.grounded=false; p.coyote=0; p.jbuf=0; sound}
// horizontal
p.x+=p.vx; resolve; clamp within level bounds
// vertical
const wasGrounded=p.grounded; p.grounded=false;
p.y+=p.vy; resolve, set grounded on landing; if grounded → coyote=6
```

Then hazards, enemy update + collision, gems, trophy, exit.

Camera: camX += (target-camX)*0.12 smooth, clamped.

Death function: state='dead', deadTimer=50, sound, score unchanged, shake=10.

Respawn: reset player pos/vel, reset enemies (re-init from level spawn list), state='play'.

Store level data globally after parse: keep parsed `level` object; for enemy reset, reparse enemies from a saved list of original spawn rows. Save enemySpawns=[{tx, ty}].

Exit check: if overlap exitRect (1-tile wide, 2-tall region) and hasTrophy → state='complete', timer=100, score+=500.

After complete timer: level++ → loadLevel or state='won'.

Title: Enter → startGame (reset score/lives, level 0).
Game over: Enter → title.
Won: Enter → title.

Draw functions — write procedural art:

drawBrick(x, y, theme):
```js
ctx.fillStyle=theme.brick; fillRect; 
ctx.fillStyle=theme.brickDark; horizontal mortar lines at y+? Brick pattern: 2 rows of bricks per tile with offset.
Highlight top edge.
```

Fire:
```js
function drawFire(x,y,t){
  for(let i=0;i<3;i++){
    const bx=x+5+i*11, ph=t*0.25+i*2.1+x*0.05;
    const h=14+Math.sin(ph)*5+Math.sin(ph*2.7)*3;
    const w=9+Math.sin(ph*1.3)*2;
    // outer flame
    ctx.fillStyle='#ff5a1f';
    ctx.beginPath(); ctx.moveTo(bx-w/2, y+TS); 
    ctx.quadraticCurveTo(bx-w/2-2, y+TS-h*0.5, bx+Math.sin(ph)*2, y+TS-h);
    ctx.quadraticCurveTo(bx+w/2+2, y+TS-h*0.5, bx+w/2, y+TS); ctx.fill();
    // inner
    ctx.fillStyle='#ffd23f'; smaller version
  }
  // glow
}
```

Water:
```js
function drawWater(x,y,t,isSurface){
  gradient blue fill; if surface: draw waves: sine-wave line along top, brighter color; bubbles: small circles animated upward.
}
```
isSurface: tile above is not W.

Trophy: gold cup with shine, bob = sin.
Gem: diamond shape, sparkle.
Door:
```js
function drawDoor(x,y,unlocked,t){ // x, y base tile (exit tile), door 1 wide, 2 tall
  frame: dark arch; inner: if unlocked → green glow gradient + swirl, else gray darkness + lock.
}
```

Player draw:
```js
function drawPlayer(p,t){
  ctx.save(); translate(p.x+p.w/2, p.y+p.h); scale(p.dir,1);
  walk cycle: legPhase = p.grounded && |vx|>0.3 ? t*0.35 : 0;
  // legs
  // body: red shirt rect
  // head: skin-color circle, hat: brown
  // eye
  ctx.restore();
}
```
Coordinates: origin at bottom center, draw upward with negative y. h=28: legs 8, torso 10, head r6.

Enemy blob:
```js
squash = 1+sin(t*0.2+e.x)*0.08;
body: round blob (arc), purple; eyes: two white circles + pupil facing movement; feet wiggle.
```

HUD: bar fillRect 0, 0, VW, 32 dark; text with ctx.font. Trophy icon: mini cup + check/×.

Background: gradient per theme; parallax: 2 layers of stalactite/hill silhouettes:
```js
function drawBg(theme, camX){
  gradient fill;
  layer(f=0.3, color, baseY, amp): iterate x stepping 8: y = baseY + sin((x+camX*f)*0.01)*amp + sin(...)*...; fill down to bottom.
}
```
World draw translated by yoff, so draw bg full canvas first without translate.

Level themes:
```js
const THEMES=[
 {sky:['#0d1b2a','#1b3a4b'], brick:'#7a5c3e', brickDark:'#5a4028', hill:'#12283a', hill2:'#0f2030'},
 {sky:['#1a0d0d','#3a1b1b'], brick:'#6e4a4a'...},
 {sky:['#0d1a12','#1b3a2a'], ...}
]
```

OK. Overlays: title screen, level toast (show `toastTimer`), death flash, complete text, game over, victory.

Now write. Note: `keys` uses lowercased e.key; ' ' (space) is also jump — ' ' stays as ' '.

Jump keys: ArrowUp, w, ' '.

Let me write the final HTML.

Also small detail: trophy collected → HUD shows trophy icon + play unlock sound; message "Now reach the exit!".

Door overlap check: exit rect x=tx*TS, y=(ty-1)*TS, w=TS, h=2*TS.

Also if player touches door without trophy: show small text above door "Locked! Find the trophy" while nearby.

Time to write. Estimating ~600 lines total. Going for it.

Recheck level string widths once more with code: normalize by padding with '.' — safe.

Enemy collision during 'dead'/'complete' states: skip updates other than timer.

Shake: shake timer, offset random*shake.

Now write the whole file.

After writing, quickly sanity-check JS syntax with node (extract script and node --check). Can do with a simple bash: sed to extract between <script> and </script> to file and node --check. Worth doing.

Extract the script and run `node --check` to validate the JS syntax. Also, should I quickly simulate the parsing logic to check the level's connectivity? At the very least I'll do a syntax check, and depending on the case, write a simple reachability check in Node (copying the level and logic) too. That sounds good: use BFS over jumpable moves to verify that each level's trophy and exit are reachable. Let me first do the syntax check, then write a simple BFS test that duplicates the jump rules (movement: walking, jumps of up to 3 tiles up / 4 tiles horizontal, falling any distance, avoiding hazards) to simulate reachability. I'll implement a simplified BFS over grid positions: state = (tile x, tile y), where y is the tile where the player stands (feet rest on top of a solid). Moves: walk left/right on the floor; fall to the floor below; jump up to 3 tiles up and 4 tiles horizontal to a landing spot where the top of a solid is beneath the feet and the path isn't blocked... an approximate BFS: from a standing position (x, y), where y is the row of the feet (the row of the top of the solid being stood on, the player occupies y-1.., etc.). Simplification: allow transitions to any (x2, y2) with y - y2 <= 3 (height gained is 3 or less), |x2-x| <= 4 + (y - y2), and there's a floor at (x2, y2), i.e., tile(x2,y2) is solid, and the tiles at (x2, y2-1) and (x2, y2-2) are non-solid, and the intermediate tiles aren't hazards... rough but it can detect design errors. Alright, let's run it.

There's no python3. If node is available, use node for extraction.

Perform reachability BFS on the 3 levels and confirm that the trophy and the exit are reachable, and that there are no hazards blocking the path.

My BFS might be too strict (my jump model is approximate, and my "span" reduction may be too strict). Let me check whether it's a level design issue or a BFS bug.

Max jump: height v=11, g=0.55 → h = 121/1.1 = 110px = 3.44 tiles. So rising up to 3 tiles is OK. Horizontal distance in full jump: 40 frames * 3.4 = 136px = 4.25 tiles. But horizontal distance shrinks when also rising r tiles.

Time to rise r tiles and land r tiles higher: total displacement 0 vertically... if landing at the same height, air time is 40 frames → 4.25 tiles. If landing r tiles higher, time t satisfying v*t - g t²/2 = r*32 → 11t - 0.275t² = 32r. For r=1: 0.275t²-11t+32=0 → t = (11 - sqrt(121-35.2))/0.55 = (11-9.26)/0.55 = 3.16... this is the ascending crossing; landing occurs on the descending side: t=(11+9.26)/0.55 = 36.8 frames → horizontal distance 125px ≈ 3.9 tiles. r=2: 11t-0.275t²=64 → discriminant=121-70.4=50.6, sqrt=7.11, t=(11+7.11)/0.55=32.9 → 112px ≈ 3.5 tiles. r=3: 11t-0.275t²=96 → discriminant=121-105.6=15.4, sqrt=3.92, t=(11+3.92)/0.55=27.1 → 92px ≈ 2.9 tiles.

So the spans should be r=0:4, r=1:3 (3.9 → effectively 3 considering width margin, or 4?), r=2:3, r=3:2. In my BFS the spans are r0:4, r1:3 (4-ceil(0.5)=4-1=3), r2:3 (4-1=3), r3:2 (4-2=2). Hmm, what I actually wrote was span = r===0?4:(4-Math.ceil(r/2)) → r1:3, r2:3, r3:2. Seems reasonable.

But also about the player's width: jumping over a gap of width 4 requires the left edge to move 4 tiles + width? Standing at the edge of column x (ground is at y, body is above it). The player's right edge extends into the next tile (w=20 < 32). Actually since the player is 20px wide and the tile is 32, the effective clearance is greater. BFS treats the state as a single tile; jumping a gap of width g means moving from standing at x to standing at x+g+1, and the horizontal movement of the foot position is... The player's x is continuous; can take off from the very edge. Foot tile x → landing tile x': the horizontal travel of the center ≈ (x'-x)*32 - 20 (because width 20 can straddle). So gap 4 (x'=x+5? no, gap of 4 columns between platforms: last floor tile is x, next floor tile is x+5): needed center travel = 5*32-20=140px > 136. Tight/impossible. Gap 3: x'=x+4 → 4*32-20=108px ✓.

Level 2's exit: exit is r9 col38, on top of platform r10 cols37-40. Approach is from ground cols35-43 (r12 floor, standing is r11... no, floor is r12 so standing y=12 (foot is on top of row 12? In BFS is start y the foot row = the row of the solid being stood on? Setting start=[spawn[0],spawn[1]+1]; spawn r11 → foot row 12, solid is at row 12 ✓. canStand checks solid(x,y). So state's y = row of solid underfoot.)

To reach exit: need to stand at y=10 (platform r10 is solid at row 10) near col38, or stand on the ground and overlap the exit rect {x:E.tx*TS+4, y:(E.ty-1)*TS, h:2*TS} — the exit is the tile at r9 col38 and r8 col38. Jumping from the ground (standing y=12, body at r11/r10), the player's head reaches up to about 3.4 tiles above the feet → feet are y*TS - ... during a jump feet rise 110px ≈ r12 top -110 → feet are row ≈ 12*32-110 = 274 → row 8.6. Exit rect is from y=8*32=256 to 320, x is 38*32+4..38*32+28. Jumping from ground col 36-37, the player can overlap the exit rect (x col38, y rows 8-9). Rect's bottom = 320 = r10 top; player during jump: when feet are at 320 or above, and x overlaps, the body is within the rect. Feet reach a minimum of 274 < 320 ✓. So jumping from ground near col38 triggers exit. My BFS's "near" check: seen.has((tx+dx),(ty+dy)) where dy is 0..2 from the trophy tile... for exit's ty=9: checks for standing states at (37..39, 9..11). Ground standing is y=12 — not included. So the BFS is too strict about the exit. In the actual game, exit contact happens mid-jump. That's why Level 2's exit is "false".

Similarly Level 3's exit: E is r8 col45, platform r9 cols43-46. Steps r11 cols39-40 (standing y=11). Jump from y=11 to y=9: rise 2, horizontal 3 (from col40 to col43). My span r2=3 ✓. Hmm, why does it fail? Maybe the BFS can't even reach the steps in the first place: steps are cols39-40, r11 solid. From ground y=12 col38: rise 1, h... walk to col38, then jump 1 up to col39: r=1, h=1 ✓ canStand(39,11): solid(39,11)='#' ✓, t(39,10)='.', t(39,9)='.' ✓. Then from y=11 col40, jump r=2 h=3 to col43 y=9: canStand(43,9): solid(43,9)? r9 row: "...........G.G.............................####." — cols43-46 are "####" ✓. Body at r8 col43: 'E' is at col45, r8 col43 is '.' ✓. So it should be found... unless the BFS can't reach ground col38, because water gap cols30-33: stepping stones are r11 cols31-32. From ground y=12 col29, jump r=1 to stepping stone (31,11): rise 1, h=2 ✓. canStand(31,11): solid(31,11) is '#' ✓ body r10 col31 '.', r9 col31 '.' ✓. Then from (32,11) or (31,11) to col34 y=12: r=0? Descending from y=11 to y=12: my BFS's jumps only rise r≥0, same height or higher; descent is handled by walk + fall: walking from stepping-stone tile (32,11) to col33: not solid → fall: ny goes from 11 → solid at 12? solid(33,12)? r12: cols30-33 are gaps ("...."). So fall from (33,11): ny goes 11→12? solid(33,12)=false (gap), ny=13: t(33,13)='W' → not solid, ny=14=H → nothing. Actually wait, fall check: landHaz checks t(nx,ny-1). Falling to col34: walk from (33?) — stepping stone is at col32, walking right to col33: fall into water → die. In actual game, the player jumps from the stepping stone to col34: a jump that descends 1 and moves h=2. My BFS doesn't model descending jumps! That's the bug. In Level 1, water gap cols13-15: jump from ground col12 (y=12) to col16 (y=12): r=0, h=4 ✓ within span 4. Level 3's stepping stone requires a descending jump.

Add descending jumps: allow landings y' > y, up to 3 tiles descent, with horizontal span ~4+ (descents give more time). Descending d: air time until 32d descent: 0.275t²-11t+... solve 11t-0.275t² = -32d. d=1: 0.275t²-11t-32=0 → t=(11+sqrt(121+35.2))/0.55=(11+12.5)/0.55=42.7 → horizontal 145px ≈ 4.5 → span 4. d=2: t=(11+sqrt(121+70.4))/0.55=(11+13.8)/0.55=45 → span 4. d=3+: span 4-5.

Also fix the near() for the exit: include jump contact — more simply: consider the exit reachable if there's a seen state with x in [tx-1,tx+1] and foot y in [ty-1 ... ty+2], or even if there's a state below/near where a jump can overlap. Let me extend near: for exit tile (tx,ty), door rect rows are ty-1..ty. If seen has (x in tx±1, y in ty-1..ty+2), the player can reach — foot at ty+2 means standing one row below door bottom? Door bottom is (ty+1)*TS... door rect is y=(ty-1)*TS to (ty+1)*TS. Player standing at foot row ty+2: feet are at (ty+2)*TS top = rect bottom + 32. Even with jump, if the state isn't near... hmm. Let me also allow: if there's a state with |x-tx|<=1 and y in ty+1..ty+3, and jump rise ≥ (y-(ty))*... more simply: if there's a state with |x-tx|<=1 and y ∈ [ty+1, ty+3], and y - riseMax(=3) <= ty+1 then reachable by jump → i.e., y <= ty+4. Just extend near to dy -2..+4.

Let me fix the BFS: add descending jumps and a wider near. Then re-check.

Bug: maxSpan is using `disp` but the parameter is `dispPx`. Fixing it.

All three levels are clearable. Also, let me briefly verify the soundness of the hazard placements: e.g., the enemy patrol in level 1 is on the r12 ground between water holes... M at r11, column 20, on the ground section columns 16–25, patrols between the water hole (13–15) and the fire hole (26–28). My enemy flip logic also flips at F/W floor tiles ✓.

One more check: the game loads level 0 for the title screen; after startGame, it reloads. No problem.

Potential gameplay issue: in `updatePlayer`, `die()` is called inside a loop over enemies with `return die()` — die returns undefined, but no problem.

When state='complete', the player is drawn frozen — no problem.

Edge case: `drawPlayer` when globalAlpha is changed for death — restored with ctx.restore ✓ (globalAlpha is set inside save/restore).

HUD: `drawCup` is drawn outside the translated context ✓.

Title screen uses drawEnemy with an object that has t etc. ✓. drawBrick's title call passes th and coordinates; tile() requires LV — LV has been preloaded via loadLevel(0) before the loop ✓. However, drawBrick's title call uses y=VH-64, and it calls tile(tx,ty-1) with ty=9 — reads LV's grid, no problem.

One bug: in drawBrick, `ctx.fillRect(x+((off+8)%32), ...)` is fine.

Also, `sStomp` is used for the locked-door message. OK.

Confirmed: keydown ' ' — k = ' '.length===1 → ' '.toLowerCase() = ' '. keys[' ']. In updatePlayer, only ArrowLeft/a etc. are used for movement; jump is handled via the jbuf set on keydown. ✓

Enter in states like 'play' does nothing ✓.

Death while in a pit: the player sinks and is drawn under the tiles with alpha fade — tiles are drawn before the player, so the player is drawn on top of the tiles; either way, the alpha fades.

All good. I'll present the final answer.

All the levels have been verified, and everything is self-contained. I'll summarize.