Build a Dangerous Dave–style platformer in a single index.html. Features: tile-based levels, the player collects a trophy, then heads to the exit door; hazards (fire, water), enemies that patrol, jumping, keyboard controls. Canvas rendering using procedural graphics.

Let me write a solid, self-contained game. Design:

- Grid, e.g., 40x22 tiles, tile size 32, canvas 800x480? Let's go with 25 cols x 15 rows displayed, camera... simpler: fixed level that fits on screen, e.g., 32 cols x 18 rows at 28px = 896x504. Camera scroll is also possible but fixed is simpler and more reliable. Let's go with a 30x16 grid, 32px tiles = 960x512 canvas.

Tiles: solid brick, ground, water (top of surface), fire, trophy, door, spikes? Fire and water are deadly. Patrolling enemies (horizontal walker type). Jump physics with gravity. Keys: arrows/WASD, space to jump.

Game states: playing, dead (respawn), win. Death counter, maybe a timer.

Write level as string rows. Legend:
- '#' solid brick
- '=' platform
- '~' water (dies on contact)
- '^' fire hazard
- 'T' trophy
- 'D' door (exit; locked until trophy is acquired)
- 'E' enemy spawn
- 'P' player spawn

Collision detection: AABB against tiles. Standard.

Enemy: walks back and forth, turns around at walls/edges. Kills player on contact. Can you stomp enemies Mario-style? Dangerous Dave had shooting, but stomping is simpler. Let's allow stomp kill, otherwise it's death.

Rendering: procedural — brick pattern, animated water waves, flickering flames, gold trophy, door, player as a small character with simple limb animation.

HUD: score, deaths, trophy status.

Let me write the code carefully.

Physics: player w=20, h=28 (tile 32). Gravity 0.5, jump velocity -10, movement speed 3.2. coyote time optional; keep it simple but a bit responsive.

Collision resolution: move x, resolve; move y, resolve.

Hazards: check overlap of player rect with fire/water tiles → death. Shrink hitbox a bit for fairness.

Door: touching door while holding trophy → win; otherwise show "need trophy".

Animation loop via requestAnimationFrame; simple timer-based frame count for fire flicker.

Level design (30 cols x 16 rows). Let me make one:

Row legend draft:

```
##############################
#P...#.........^.....#......#
#....#.....~~~......#..T....#
#....##====.........#=====..#
#...........................#
#..E......#####..^^..#......#
#========...........#..D....#
#...........~~~~~~..#=======#
#....##E....       .........#
```

Design carefully, 30 chars per row, 16 rows. Ensure reachability. Jump height: v=−10, g=0.5 → max height = v²/(2g)=100 px ≈ 3 tiles. So a 2–3 tile jump is possible. Horizontal reach while ascending: fine.

Let me lay out the level:

```
0: ##############################
1: #............................#
2: #..T...^.................D..#
3: #=====.....~~~.........#####
```

Hmm, need to be careful. Let me design systematically.

Grid 30x16. Ground on row 15 (bottom). Layout:

```
row0:  ##############################
row1:  #............................#
row2:  #............................#
row3:  #....T....................D..#
row4:  #..#####..................####
row5:  #..........~~~~...............#
```

Count the width. Simpler: write rows as strings and verify length 30 in code (pad/truncate). Carefully hand-craft and verify with a script after writing? Can't easily run a browser, but I can verify string lengths and basic reachability in my head with a node script.

Level plan (30x16):

```
##############################
#............................#
#............................#
#...T.....................D..#
#..###...................####
#........~..........~~~......#
#...####..........######..E..#
#............................#
#..........^...^.............#
#..######..#~~~#....######...#
#............................#
#..E...........####.....~~~..#
#.......####...............###
#.....................E......#
#P.....^^....####..........T?#
##############################
```

Hmm, one trophy is enough. Let me craft carefully:

Row indices 0..15, cols 0..29.

```
r0:  ##############################
r1:  #............................#
r2:  #............................#
r3:  #...T.....................D..#
r4:  #..####..................#####
r5:  #.........~~~................#
r6:  #...####..........######.....#
r7:  #............................#
r8:  #..........^^^^..............#
r9:  #..######..~~~~..E..######...#
r10: #............................#
r11: #..E...........####.....~~~..#
r12: #.......####...............###
r13: #......................E.....#
r14: #P.....^^....####............#
r15: ##############################
```

Check row lengths. I'll verify programmatically after writing the file with a node one-liner.

Reachability analysis:
- Player at r14 c1. Jump height about 3 tiles.
- Trophy on r3 c4, atop platform r4 c3-6. From the r6 platform (r6: "####" c4-7), a 2-tile hop up to r4's platform. From r6 platform to... from ground r14: jump reaches r12? Ground at r14, standing at r13 top? Ground is r15, standing on row 14? Player stands on top of r15, occupies r14. Jump of 3 tiles reaches r11. Platform at r12 c8-11 — reachable from ground (3 tiles up, top at r11). From r12 platform, jump to r11?? Actually need r9 platform "######" c18-23... wait let me re-check the path.

Path idea: ground → r12 platform (c8-11) → r9 platform? r9 is "######" c19-24... no wait r9: "#..######..~~~~..E..######...#" → blocks at c3-8 and c19-24, fire on r8 c11-14, water r9 c11-13? Hmm water at c12-15, and enemy on platform at c18? Let me recount r9: indices: 0:'#', 1'.', 2'.', 3-8 '######', 9'.', 10'.', 11-14 '~~~~', 15'.', 16'.', 17'E', 18'.', 19-24 '######', 25-28 '...', 29'#'. Enemy at c17 would float in air above... falls. Enemies need ground. Put 'E' on platforms or ground rows.

Let me simplify: enemies only placed on ground row or platform, and the engine drops enemies with gravity and patrols platform edges (turns at edge). This handles placement robustly: enemies fall to nearest ground and patrol. So I can place E anywhere above ground.

Actually, make enemies gravity-affected and turning at walls and platform edges — good.

Trophy path: trophy at r3 c4, platform r4 c3-6. To reach r4 platform (top r3), need platform of height ~r6 or higher nearby. r6 c4-7 platform is at r6; standing on it (occupies r5), jump 2 up → lands on r4 platform. Good. To reach r6 platform from ground: ground r14; r12 platform c8-11; jump up from ground to r12 (top r11, 3-tile jump, just barely). Then r12 to r6? Too far (6 rows). Add intermediate platform: r9 c3-8 platform. From r12 platform (c8-11) jump to r9 platform c3-8: up 3, horizontal overlap at c8. OK. Then r9→r6 (up 3, at c4-7 overlap). Good.

Door at r3 c27, platform r4 c25-29 (#####). Path to reach: right side. r12: ".......###" end c26-28? r12: "#.......####...............###" → c26-28 blocks. From ground r13-14 right side, jump up to r12 c26-28 (top r11). Then from r12 platform need to reach r6 c19-24 platform? r12 to r6 too far. Add r9 platform c19-24. r12 (c26-28) → r9 c19-24: up 3, horizontal gap from c26 to c24 — 2 gap, fine during jump. Then r9 → r6 c19-24? r6 blocks c19-24? r6: "#...####..........######.....#": c4-7 and c19-24 blocks. Wait r6 has 2 platforms: c4-7 (left, used for trophy path) and c19-24 (right, used for door path). From r9 c19-24 jump up 3 to r6 c19-24 — directly above. But standing on r9 c19-24 below r6 c19-24? Vertical gap between r6 and r9 is 3 rows (r7, r8 between). Jumping from r9 (occupies r8) upward 3 tiles to land on r6 top... r8 to r5-ish: max jump 3 tiles — tight but OK. Actually collision with platform directly above: jumping straight up from r9 platform c19-24 hits r6 platform bottom. Need to jump from side, e.g., from r9 c17-18 area to r6... hmm r6 c19-24 top r5. Jumping at edge c18 of r9 platform: rise 3 tiles reaching r6 level, drift right to land. Max rise ≈ 100px ≈ 3.1 tiles; required rise from standing on r9 (feet at r9 top = y=9*32) to feet at 6*32: 96px < 100. OK.

Alternatively, add a r7 or r8 stepping stone platform on the right. To ease, add r7 platform at c26-28? Actually r12 c26-28 → r7?? too far. Let me restructure the right side: ground → r12 (c26-28) → r9 (c19-24)... hmm r12 to r9 up 3 fine. Then r9 → r6 need up 3 + horizontal. Tight but playable; maybe lower the right r6 platform to r6 and add small platform at r8 c26-28? Then r9 c24 → r8? up 1. Then r8 c26-28 → r6 c19-24: up 2, gap 2. Good.

Also door on top of r4 c25-29 platform: from r6 c19-24 (occupies r5), jump up 2 to r4 platform c25-29, horizontal gap from c24 to c25 — adjacent. Good.

Middle area: fire and water hazards on ground: r14 "^" at c7-8. Water on r5 c11-13 (~~~)? Water should sit in pits or atop ground. Water tiles kill on contact; floating water looks weird but in Dave-like games that's fine? Better: put water in pits in the ground. Let me make a pit: at r15 keep floor, but dig a pit in the ground row with water at bottom? Level bottom row is r15 boundary. Create pit: remove ground at r14 and put water at r14 in those columns, with r15 floor below? Water on r14, walls around.

Simplify: water occupies some r14 tiles (replacing floor air), floor r15 still solid. Falling into it = death. Fire tiles also at r14 above floor. Both work as "hazards above floor".

Enemies: 2-3, gravity + patrol.

Final level strings (30 chars each):

```
r0:  ##############################
r1:  #............................#
r2:  #............................#
r3:  #...T.....................D..#
r4:  #..####..................#####
r5:  #............................#
r6:  #...####..........######.....#
r7:  #..........................###
r8:  #..........................###
```

Hmm wait, r7/r8 blocks at c27-28 make a wall; then r12? Let me redo right-side stepping stones: r9 platform c19-24, r8 platform c26-28.

Let me finalize:

```
r0:  ##############################
r1:  #............................#
r2:  #............................#
r3:  #...T.....................D..#
r4:  #..####..................#####
r5:  #............................#
r6:  #...####..........######.....#
r7:  #...........................##
r8:  #..........................###
r9:  #..######..~~~~....######....#
r10: #............................#
r11: #............................#
r12: #........###...........###...#
r13: #............................#
r14: #P....^^......~~~~.....E.....#
r15: ##############################
```

Hmm right path: from ground to r12 c24-26 (### at c24-26), then up to r9 c20-25? r9: blocks c3-8 and c20-25, water c11-14. Let me recount r9: "#..######..~~~~....######....#": 0'#', 1-2'.', 3-8 '######', 9-10'.', 11-14 '~~~~', 15-18'....', 19-24? wait 15,16,17,18 = 4 dots, then 19-24 '######' (6 chars), then 25-28 dots, 29 '#'. Total: 1+2+6+2+4+4+6+4+1 = 30. Good. Blocks at c3-8 and c19-24.

Right path: ground (r14) → r12 platform c24-26 (top r11, up 3: tight). Then r12 → r9 c19-24: up 3, gap from c24 to c24 overlaps — vertical hop on c24-26... r9 ends at c24 and r12 starts at c24. Jump straight up at c24, rising from feet r12 top (y=384) to 288: 96px OK. Then r9 (feet at 288, occupies r8) → r6 c19-24 (top r5): rise 96px, but directly above → head bonk. Jump from r9 c18 edge, drift right. Rise 96px to reach feet y 192... platform bottom at r6: y=192..224. Jumping straight up from r9 bonks. Move left/right then up while rising? Can't — r9 spans c19-24, directly below r6 c19-24. Problem: can't land. Fix: offset r6 right platform to c20-25? Still almost directly above. Better: make right path go via r7/r8 wall on the right: r8 c27-28, r7 c28-29 blocks... climb the walls: from r9 c24 jump right to r8 platform c27-28? Gap c25-26 (2 cols), up 1. Then from r8 c27-28 jump to r6 c19-24? Up 2, gap 3 cols leftward — doable (horizontal jump range ~ 4-5 cols). Then r6 → r4 c25-29 (top r3): up 2, gap: from r6 c24 to r4 c25 — adjacent, easy.

But wait, r7 c28-29 blocks — r7: "...........................###"? Blocks at c27,28 and wall c29 — that's "##" at 27-28 + '#' wall = "###" at end. And r8 blocks at c27-28: "..###"? r8: 27 dots then "###"? c27-28 blocks + c29 wall: row = 27 dots + "###" → length 30: 1('#') + 26 dots + '##'? Let me just write: r7: "#..........................###" → 1 + 26 + 3 = 30, blocks at c27-29 (wall merges). r8: "#..........................###" same blocks c27-28 (+wall). Hmm c29 always wall. So r7 has blocks at c27, 28 plus wall. Fine — stepping stone platform at c27-28 rows 7-8 forming pillar; top at r7. From r9 (top y=288) jump to top of r7?? That's up 2 rows (feet from 288 to 224 = 64px), horizontal gap c25-26. Fine. Then from r7 top (feet 224) to r6 platform? r6 c19-24 top at y=192: up 1, horizontal 3 left. Easy. Good, that works; keep r8 pillar for visuals or drop it — a pillar from r8 with top at r7 means blocks at r7 and r8 (pillar). Fine.

Trophy path (left): ground → where? Left stepping stones: r12 c8-10 (###). r12: "#........###...........###...#": 1 + 8 dots = c1-8, blocks c9-11, dots c12-22, wait let me count: "#"(1) + "........"(8, c1-8) + "###"(c9-11) + "..........."(11, c12-22) + "###"(c23-25) + "..."(c26-28) + "#" = 1+8+3+11+3+3+1=30. Right platform c23-25 (adjusted from c24-26). OK.

Left: ground → r12 c9-11 (top r11). Then r12 → r9 c3-8: up 3, gap c9 to c8 — adjacent. Rise 96px to r9 top at 288... feet 384 to 288 = 96 ✓. Then r9 c3-8 → r6 c4-7: directly above?? r6 blocks c4-7 above r9 c3-8. Overlap c4-7 — bonk again. Offset: r6 left platform to c4-7, r9 left to c3-8 — overlap. Jump from r9 c3 edge leftward? Nothing there. Hmm. Move r6 left platform to c5-8? Still overlap. Alternative: raise left path via wall: add pillar r7/r8 at c1-2? Then r9 c3 → r7 top c1-2: up 2, gap 1 left. Then r7 c1-2 → r6 c4-7? up 1, gap c3 (1 col). Then r6 → r4 c3-6: up 2, overlapping. Good.

So add blocks c1-2 on r7 and r8 (pillar adjacent to left wall).

r7: "#..........................###" → add blocks c1-2: "###........................###"? Let me write it out: '#'(c0) + '##'(c1-2) + dots c3-26 (24 dots) + '###'(c27-29). Length 1+2+24+3=30 ✓.
r8: same: "###" + 24 dots + "###".

Wait but these pillars: r8 c1-2 with top at r7? If blocks at r7 and r8, top at y of r7. From r9 c3 (feet 288) jump left to top of r7 (feet 224): up 64px, gap 1 col. ✓. From r7 c2 → r6 c4-7: up 32px, gap 1 col (c3). ✓. From r6 c4-7 (feet 192) → r4 c3-6 (top 96): up 96px, overlapping columns → head bonk directly above again! r4 c3-6 above r6 c4-7 overlap c4-6. Jump from r6 c7 edge? right of r4 platform ends c6. Jumping straight up from r6 c7 rises to feet 96, drift left to land at c6. ✓ (rise 96 = max, tight). Or place trophy platform at r4 c2-5? Still overlap c4-5. Hmm, alternative: reach trophy via r3 directly from r4?? Or make jump easier: raise trophy platform to r5? Trophy on r4 stands on platform r5? Let me move left trophy platform: platform at r5 c3-6, trophy at r4 c4. Then r6 c4-7 below overlaps... bonk. Move r6 left platform to c2-5? Then r7 pillar c1-2 is below r6 c2? Overlap at c2. Jump from r7 c1 edge... this is getting fiddly.

Cleaner approach: design so each upper platform is offset ≥2 cols from the one below. Or make jump height larger (jump v=-11 → height 121px ≈ 3.8 tiles) so up-3 jumps are comfortable, and accept bonks when directly above? No — bonks block the landing.

Better fix: shift platforms horizontally:

Left climb:
- Ground → r12 c9-11.
- r12 → r9 c3-7 (up 3, jump left from c9 to land at c7: gap 1 col, fine).
- r9 → r6 c1-4? r9 c3-7 vs r6 c1-4 overlap c3-4 — partial bonk; jump from r9 c3 up-left? Bonk at c3-4. Hmm.

The issue is: when jumping up 3 tiles, you can't have any platform tile above within your horizontal range during ascent, but you need horizontal proximity to land. Solution: make ascent 2-tile steps, or use edge jumps.

Edge jump works: standing at edge tile of lower platform, jump straight up at edge column (which is not under upper platform), drift toward upper platform at apex. If upper platform extends within ~2 cols of edge, works. So design: upper platform offset by ~1-2 cols from lower platform edge.

Left climb redo:
- r12 c9-11 (top r11, feet 384→352? feet at 12*32=384).
- r9 platform c3-8 (top 288): jump from r12 c9, rise 96, drift left 1 col. ✓ (no block above at c9).
- r6 platform c1-5 (top 192): r9 c3-8; jump from r9 c3? Above c3: r6 covers c1-5 → bonk. Jump from r9... need column to left of c1?? None (wall at c0). Instead jump from r9 edge... r6 above overlap c3-5. Problem.

Alternative: go up the left wall with pillars as before but offset: pillar top at r7 c1-2, r6 platform c4-8 (gap c3), r9 c2-7? Then r9 → r7 pillar: from r9 c2 jump left up to c1-2? r9 c2 above: r7 pillar c1-2 → bonk at c2. Jump from r9... r9 starts at c2. Hmm, move r9 left platform to c3-8, pillar c1-2 at r7 (top). Jump from r9 c3: above at c3 clear (pillar c1-2), rise 64px, drift left 1 → land on pillar. ✓. Pillar c1-2 → r6 platform c4-8: gap c3, up 32. ✓. r6 c4-8 → trophy platform r4 c6-10? Jump from r6 c8 right edge... trophy platform at r4 c6-10 above r6 c4-8 overlap c6-8 bonk; jump from r6 c8? Above c8 = r4 c8 block. Bonk. From r6... hmm above every column within r4 platform range that's above r6 bonks; need to jump from r6 column outside r4 range and drift: r6 c4-8, r4 c6-10 → jump from r6 c4 or c5 (clear above), rise 64, drift right. ✓.

Or simpler: trophy platform at r4 c3-6 reachable from r6 via edge jump at c7... as computed before (rise 96 tight). With jump v=-11 (121px) it's comfortable. Let me bump jump to -11, gravity 0.55 → height = 121/(1.1)=110px ≈3.4 tiles. Up-3 jumps comfortable.

OK, let me stop over-engineering; I'll set up generous jump (v=-11.5, g=0.6 → h≈110px) and design with mostly 2-tile climbs and edge jumps for 3-tile.

Final level (I'll trust edge-jump logic; verify lengths by script):

```
r0:  ##############################
r1:  #............................#
r2:  #............................#
r3:  #...T.....................D..#
r4:  #..####..................#####
r5:  #............................#
r6:  #...####..........######.....#
r7:  ###........................###
r8:  ###........................###
r9:  #..######..~~~~...######.....#
r10: #............................#
r11: #............................#
r12: #........###..........###....#
r13: #............................#
r14: #P....^^.......~~~~..E.......#
r15: ##############################
```

Right climb check: ground → r12 c23-25 (top 384? r12 → feet 384, up 3 from ground feet 480: 96 ✓). r12 c23-25 → r9 c19-24: jump from r12 c23?? above c23: r9 c23 block → bonk. Jump from r12 c25, above clear? r9 ends at c24 → c25 clear ✓, rise 96, drift left 1 ✓. r9 c19-24 → r7 pillar top c27-28 (top y=224, from 288: up 64): jump from r9 c24, above c24 clear? r7 blocks c27-29 → clear ✓, gap c25-26 (2 cols) ✓. Pillar → r6 c19-24 (top 192, from 224 up 32, gap c25-26 to c24... jump left 2 cols, up 1 ✓). r6 → r4 c25-29 (top 96): from r6 c24 edge, above c24 clear? r4 c25-29 → clear ✓, rise 96, drift right 1 ✓. Door at r3 c27 ✓.

Left climb: ground → r12 c9-11. r12 → r9 c3-8: jump from r12 c9, above clear (r9 ends at c8) ✓ rise 96 drift left 1 ✓. r9 c3-8 → r7 pillar c1-2 (top 224): from r9 c3, above c3 clear ✓ up 64 drift left 1 ✓. Pillar c1-2 → r6 c4-7 (top 192): from pillar c2, above clear? r6 starts c4 ✓ up 32, gap c3 ✓. r6 c4-7 → r4 c3-6 (top 96): jump from r6 c7, above c7 clear ✓ rise 96 drift left ✓. Trophy at r3 c4 ✓.

Hazards: fire on ground at r14 c6-7 ("^^"), water pit at r14 c16-19? r14: "#P....^^.......~~~~..E.......#" count: '#'(0) P(1) dots 2-5(4) ^^(6-7) dots 8-14(7) ~~~~(15-18) dots 19-20(2) E(21) dots 22-28(7) '#'. 1+1+4+2+7+4+2+1+7+1=30 ✓. Water at c15-18 on floor — passable by jump (4 cols wide jumpable? horizontal jump distance: airtime ~ 2*11.5/0.6 ≈ 38 frames * speed 3.5 ≈ 130px ≈ 4 tiles ✓ tight; fine, it's a hazard).

Water in r9 c11-14 floats?? r9: "#..######..~~~~...######.....#": blocks c3-8, water c11-14 floating in air. Looks weird. Give it a basin: add blocks below? Water at r9, put '====' basin at r10 c11-14? Floating water platform... actually in Dangerous Dave there is ground-level water. Floating water looks weird but acceptable as "water on platform"? Better: put basin: make water at r10 supported by blocks at r11? Simplify: remove floating water, keep just ground water, and put fire on r9? Instead of floating water, put fire below r8 c11-14? Fire also floats.

Alternative: make middle a raised water basin: blocks r10 c10-15 forming basin walls with water at r9 c11-14, basin rims at r10 c10 and c15. Visually: water held in a brick basin. Let me define r9: "#..######..~~~~...######.....#" water c11-14; r10: "#.........######.............#"? blocks c10-15 below water+edges. Then water rests on basin. And r9 left/right platforms at c3-8 and c19-24 float — fine, platforms always float.

But wait — does basin block the path between r12 and r9? Middle isn't much used. Fine. Also could place enemy on r9 right platform.

Enemies:
- E1 at r14 c21 (ground, patrols ground, needs to avoid walking into water pit at c15-18 and fire at c6-7: enemy patrol turns at walls; would walk into water/fire. Make enemy turn at hazard tiles too. Or just die in water? Simplest: enemy turns when next tile ahead is a wall, gap (edge), or hazard. Good.)
- E2 on r9 right platform c20-23: put 'E' at r8 c21 (falls to r9 platform). Patrols platform edges.
- E3 on ground right side or r6? One on r6 right platform c19-24: put E at r5 c22. Nice.

Enemies total 3. Put one more on r12? Let's keep 3.

Also add score: trophy +1000, stomp +200, level complete bonus. Death counter. Timer.

Stomp: player falling and overlapping enemy, player bottom above enemy center → kill enemy, bounce. Else player dies.

Respawn: reset position, keep trophy? Classic: lose... keep trophy collected state, respawn at start. Simpler and kinder.

Door: locked until trophy; touching locked door shows message "GET THE TROPHY FIRST!". With trophy → win screen, R to restart.

Rendering details:
- Background: dark gradient + subtle stars/cave dots.
- Bricks: brown/red brick pattern with mortar lines; platforms ('#') all same tile is fine.
- Water: animated sine wave top, blue gradient, bubbles.
- Fire: animated flame shape (layered triangles/circles in sin flicker), on top of small ember base.
- Trophy: gold cup with handles, sparkle.
- Door: door frame, metallic/gold when unlocked, gray with lock when locked.
- Player: small character with cap, body, legs animated while walking, arms. Direction flip.
- Enemies: blob-like creature with eyes and feet, purple/green.

HUD top bar: "TROPHY ✓/✗", score, deaths. Also message overlay.

Controls: ←/→ or A/D move, ↑/W/Space jump. Restart R.

Physics constants: tile 32, canvas 960x512. speed 3.4, jump -11.5, gravity 0.6, max fall 12. coyote 6 frames, jump buffer 6 frames for good feel.

Collision: standard tile AABB. Player size w=22, h=28.

Hazard check: overlap of player hitbox shrunk by 4px with tile rect. Fire tile: only bottom half deadly? Full tile deadly. Water: deadly when player sinks below top+8.

Enemy size 26x22, walks at speed 1, gravity, turns at edges/walls/hazards.

Death: brief particle burst, then respawn after 45 frames.

Win: overlay "YOU ESCAPED!" with score.

Let me code. Also verify row lengths via node after writing the file.

Code structure:

```html
<!DOCTYPE html><html><head><meta charset=utf-8><title>Dangerous Dave-like</title>
<style>...</style></head>
<body>
<div id="wrap"><h1>CAVE DASH</h1><canvas id="c" width="960" height="512"></canvas><p class="help">...</p></div>
<script>...</script>
</body></html>
```

JS outline:

```js
const TILE=32, COLS=30, ROWS=16;
const LEVEL=[ ...strings... ];
let grid=[], trophy={taken:false,x,y}, door={x,y}, spawn={x,y};
let enemies=[];
parse level.
solid = '#'.
function tileAt(c,r) -> char or '#' out of bounds.
function isSolid(c,r)
player={x,y,vx,vy,onGround,face,coyote,jbuf,anim,dead,deadTimer}
reset(full) / respawn()
keys handling.
update():
 input -> vx, jump with coyote/jbuf
 gravity, integrate with tile collision
 hazards
 enemies update + interact
 trophy pickup
 door check
draw():
 bg, tiles, animated water/fire, trophy, door, enemies, player, particles, HUD, overlays
```

Particles on death and on stomp and on pickup.

Let me write drawing functions:

drawBrick(x,y): fill with base #8a4a2a; draw darker mortar lines offset per row.

drawWater(x,y,t): animate top wave with clip? Simpler: draw blue rect full tile, lighter top with sin offset; add sparkle dots. Adjacent water tiles merge — fine to draw per tile with phase from column.

drawFire(x,y,t): flame: for i layers, use sin(t*speed + x) for height; draw orange/yellow flame shape with quadratic curves. Also glow.

drawTrophy: gold cup: rect base, stem, bowl via arcs, handles via arcs, sparkle.

drawDoor: frame + panels; locked: brown with keyhole + "LOCKED" tint; unlocked: glowing gold.

drawPlayer: rect for body, skin head, red cap, eyes, legs swinging with sin(anim), arms. Flip via scale.

drawEnemy: oval body, feet shuffle, eyes looking direction, occasional spikes.

Overlay messages centered.

Score: trophy 1000, stomp 250, win +500. Death count. Timer.

Let me write it all. Watch out for collision code.

X collision:
```js
p.x += p.vx;
if (p.vx>0){ let c=Math.floor((p.x+pw)/TILE); check rows top..bottom; if solid: p.x=c*TILE-pw-0.01; p.vx=0 }
similar left.
```
Y:
```js
p.y+=p.vy; onGround=false;
if vy>0: r=Math.floor((p.y+ph)/TILE); check cols; if solid: p.y=r*TILE-ph; vy=0; onGround=true
if vy<0: r=Math.floor(p.y/TILE); p.y=(r+1)*TILE; vy=0
```

Player hitbox: w 20 h 28. Use offsets for drawing.

Enemy update:
```js
e.vy+=G; resolve with tiles; walk e.dir; probe ahead tile at foot: if solid or !solid below ahead or hazard ahead → dir*=-1
Also if hit wall during move → reverse.
```

Enemy vs player: AABB overlap. If p.vy>0.5 and p bottom < e.y + e.h*0.5 → stomp: enemy dies (squish particle), p.vy=-7, score+=250. Else kill player.

Hazard check function: iterate tiles overlapped by shrunk player box; if '^' or '~' → death (water maybe require deeper: check p.y+ph > tileTop+10).

Also enemy death on hazard? Skip.

Message system: msg text + timer.

Game state: 'play', 'dead' (timer), 'win'.

Timer: frame count → seconds.

Draw HUD in canvas top area? Level fills canvas fully; draw HUD as semi-transparent bar overlay at top.

OK let me write. Also handle restart (R) anytime, and after win.

Let me write the file. Also add small camera shake on death? Optional, skip.

One more check — level strings, let me carefully write with exactly 30 chars:

```
"##############################",  // 30 #
"#............................#",
"#............................#",
"#...T.....................D..#",
"#..####..................#####",
"#............................#",
"#...####..........######.....#",
"###........................###",
"###........................###",
"#..######..~~~~...######.....#",
"#.........######.............#",
"#............................#",
"#........###..........###....#",
"#............................#",
"#P....^^.......~~~~..E.......",  // missing wall on right!
"##############################"
```

r14 needs trailing '#': "#P....^^.......~~~~..E.......#" ✓ (counted before).

r9 check: "#..######..~~~~...######.....#": 1+2+6+2+4+3+6+5+1=30 ✓. Blocks c3-8, water c11-14, blocks c18-23. Hmm earlier I said c19-24; let me recount: chars: 0'#';1'.';2'.';3-8 '######';9'.';10'.';11-14'~~~~';15'.';16'.';17'.';18-23'######';24'.';25'.';26'.';27'.';28'.';29'#'. So blocks at c18-23. Basin r10: "#.........######.............#": 1+9 dots (c1-9) + '######' c10-15 + 13 dots (c16-28) + '#' = 1+9+6+13+1=30 ✓. Basin c10-15 supports water at c11-14 with rims at c10, c15 ✓.

Right climb with r9 platform c18-23: r12 right "###": r12 = "#........###..........###....#": 1+8(c1-8)+'###'(c9-11)+10 dots(c12-21)+'###'(c22-24)+4 dots(c25-28)+'#' = 1+8+3+10+3+4+1=30 ✓. Right platform c22-24. Ground→r12 c22-24: rise 96 ✓. r12→r9: jump from r12 c24 (above: r9 c24 '.' ✓), rise 96, drift left 1 to c23 ✓. r9 c23 → r7 pillar c27-28: above c23 clear ✓, gap c24-26 (3 cols), up 2 (288→224=64px). Horizontal distance 3-4 tiles during 64px ascent... time to rise 64px: solve; total jump time ample (~2*11.5/0.6≈38f; time to reach +64: 11.5t-0.3t²=64 → t≈6.7f or 31.6f; horizontal range at 6.7f ≈ 23px... hmm, need to traverse gap while ascending 64px and land at t≈6.7f: 23px < 3 tiles (96px). Won't make it! But landing on descent also possible: at t=31.6f back to same height; land on pillar top requires horizontal distance of ~3.5 tiles=112px; at 3.4 speed: 31.6*3.4≈107px. Just barely. Risky.

Fix: extend r9 right platform rightward to c18-25? Then gap from r9 c25 to pillar c27 = 1 col gap, up 2 — easy. But r9 c24-25 vs r10 basin? basin at c10-15, no conflict. Update r9: "#..######..~~~~...########...#": blocks c18-25. Count: 1+2+6+2+4+3+8+3+1=30 ✓.

But now r9 right platform c18-25 under r7 pillar c27-28: from r9 c25 jump up-right to pillar top (up 2, gap 1) ✓. Pillar → r6 right platform c19-24: r6 = "#...####..........######.....#": 1+3(c1-3)+'####'(c4-7)+10 dots(c8-17)+'######'(c19-24)+5 dots(c25-29... wait c25-28 is 4 dots)+'#': 1+3+4+10+6+5+1=30 ✓. Blocks c19-24. Pillar top r7 (feet 224) → r6 top (feet 192): up 1, gap from c27 to c24 = 2 cols leftward... from pillar c27 jump up-left, land at c24: horizontal 3 tiles at ~32px rise — rise 32px: reach +32 at t≈3f, back to +32 on descent at t≈35f; plenty of horizontal ✓.

r6 c19-24 → r4 c25-29 (top 96): r4 = "#..####..................#####": 1+2(c1-2)+'####'(c3-6)+18 dots(c7-24)+'#####'(c25-29)=1+2+4+18+5=30 ✓. From r6 c24 edge, above c24 '.' ✓, rise 96, drift right 1 ✓ (up-3 jump at 110px max OK).

r4 → door r3 c27 ✓ (stand on r4 c27, door tile above).

Left check with updated strings:
- r6 left blocks c4-7. r7 pillar c1-2 (r7: "###........................###": 1+2+24 dots+3=30 ✓; dots c3-26).
- r9 left c3-8. r9→pillar: from r9 c3, above r7 c3 '.' ✓ up 2 gap 1 ✓.
- Pillar c1-2 → r6 c4-7: up 1 gap 1 ✓.
- r6 c4-7 → r4 c3-6: jump from r6 c7, above r4 c7 '.' ✓ rise 96 drift left ✓.
- Trophy r3 c4, stand on r4 c4 ✓.
- r12 left c9-11; ground → r12 ✓; r12 c9 → r9 c8: above c9 '.' ✓ rise 96 drift left 1 ✓.

All good. Enemy spawns: r14 c21 'E' → ground patrol between fire c6-7 and water c15-18... c21 to water c18 rightward? Patrol range c19-28. OK. Place E2 at r8 c20 (falls to r9 right platform c18-25, patrols, turns at edge — won't reach pillar area). E3 at r5 c21 → falls to r6 c19-24 platform.

Hmm, E on r9 left platform too? Place E at r8 c5 → lands on r9 c3-8 platform. Total 4 enemies. Fine.

Wait: enemy falling from r8 c20 — r9 platform below at c20, lands ✓. E at r5 c21: falls through r5→r6 at c21 ✓.

Enemy edge-turn needs "solid below ahead" check; hazard tiles shouldn't count as walkable: turn if tile ahead is solid OR hazard OR no solid below ahead.

Player spawn at r14 c1 → pixel x=1*32+6, y=14*32-28+? Place p.y = (r+1)*TILE - ph = 15*32-28? No: stand on r15 top → p.y = 15*32 - 28 = 452. Spawn y calc: (spawnRow+1)*32 - ph... spawn row r14: p.y = 14*32+32-28 = 452 ✓ (feet at 480 = r15 top ✓).

Trophy at r3 c4: draw centered in tile, pickup radius overlap.

Now let me write the code. Write carefully in one go.

Also water death check: require player bottom > tile top + 12 so grazes don't kill. Fire: shrink fire hitbox to bottom 75%? Use lenient inset 6px.

Draw order: bg → tiles (bricks, basin) → water → fire → door → trophy → enemies → player → particles → HUD → messages.

HUD: top-left: TROPHY status icon; top-center: score; top-right: deaths and time. Draw semi-transparent black bar height 26.

Let me code:

```js
(() => {
const TILE=32, COLS=30, ROWS=16, W=COLS*TILE, H=ROWS*TILE;
const cv=document.getElementById('c'), ctx=cv.getContext('2d');
const LEVEL=[...];
let grid, trophy, doorPos, spawnPos, enemies, parts, player, score, deaths, frames, state, msgT, msg, winT;

function parse(){...}
```

Player object, reset function. Key set. preventDefault on arrows/space.

update(dt frames): fixed step per RAF (assume 60fps; accumulate for stability? Keep simple: 1 step per RAF).

Enemy drawing anim via frames.

Death: state='dead', deadTimer=50, spawn particles. After timer → respawn (keep trophy, reset enemies? Keep enemies in place — reset positions to avoid camping? Reset enemies too).

Win: state='win'.

Restart key R: full reset.

Draw player with face flip: use translate+scale.

Let me write all the drawing details compact but decent.

Fire draw:
```js
function drawFire(x,y,t){
  // glow
  const ph = t*0.15 + x*0.7;
  for(let i=0;i<3;i++){
    const h = 18+8*Math.sin(ph+i*2.1)+4*Math.sin(ph*1.7+i);
    ctx.fillStyle=['#ff3d00','#ff9500','#ffd54a'][i];
    flame path: start at bottom center, quadratic
  }
}
```
Simpler: draw 3 ellipses/triangles stacked with sway offset.

Flame shape:
```js
function flame(cx, by, w, h, color, sway){
 ctx.beginPath();
 ctx.moveTo(cx-w/2, by);
 ctx.quadraticCurveTo(cx-w/2+sway, by-h*0.6, cx+sway, by-h);
 ctx.quadraticCurveTo(cx+w/2+sway, by-h*0.6, cx+w/2, by);
 ctx.closePath(); ctx.fill();
}
```

Water:
```js
function drawWater(x,y,t,c,r){
 const wave=Math.sin(t*0.08+c)*3;
 ctx.fillStyle='#0a3d91'; fillRect(x,y+6,w,h-6);
 lighter top: begin wave path...
}
```
Per-tile with phase by column will create discontinuity between tiles, since each tile draws its own wave starting at its x — but if I use global x in sin, continuous: waveY = sin(t*0.1 + x*0.05)*2 — continuous between tiles since using absolute x. Draw top strip as rect from y+6+wave to ..., simpler: fill whole tile dark blue; then lighter blue rect from y+4+wave to y+10; plus sparkle based on hash.

Actually the water surface should be at tile top (air above). Draw: gradient rect full tile; bright line at top offset by wave; occasional bubble.

Brick:
```js
function drawBrick(x,y){
 ctx.fillStyle='#7c3f24'; fillRect;
 ctx.fillStyle='#9c5530'; for each 8px row offset by (row%2)*8 draw bricks with 1px gap...
}
```
Use tile row for offset.

Trophy draw(x,y,bob): cup.

Door: 32x32 tile at r3; draw a taller door visually covering tile + below? Door tile is air in collision ('D' not solid). Draw door within tile as 24x30, plus frame. When unlocked, sparkle.

Player draw:
```js
function drawPlayer(){
 if dead skip (particles instead)
 px=p.x, py=p.y; w=20,h=28
 ctx.save(); translate(px+10,py); scale(face,1);
 legs: 2 rects with walk swing if moving & onGround; legs up if airborne
 body: blue rect y10..22
 arms
 head: skin rect y0..10, red cap on top y0..4 with brim
 eye white at x 4..
 ctx.restore();
}
```

Enemy: oval body, eyes, feet animate.

Particle: {x,y,vx,vy,life,color,size}.

OK let me write. Also HUD bar and controls help under canvas in HTML.

Edge cases: door check — player overlaps door tile AND trophy taken → win; else if overlap and !taken show "FIND THE TROPHY!" message once per second.

Let me write final code now.

Also handle jump input: keydown ArrowUp/w/space sets jbuf=7; onGround/coyote, if jbuf>0 → vy=-11.5. Variable jump: on keyup, if vy<-4 then vy=-4.

Let me write it all.

```js
const keys={};
addEventListener('keydown',e=>{
 if(['ArrowLeft','ArrowRight','ArrowUp','ArrowDown',' '].includes(e.key)) e.preventDefault();
 if(e.repeat) return... (for jump buffer, want repeat false)
 keys[e.key.toLowerCase()... ] 
```
Map: left = ArrowLeft/a, right, jump = ArrowUp/w/space.

Store in booleans: kL, kR; jump pressed sets jbuf; jump held flag for variable jump.

OK. Restart 'r' also.

Now enemy tile collision: same routine; write generic moveEntity(e,w,h) returning flags.

Let me write the file now.

After writing, verify level strings and simulate a few physics invariants in head with node... at least verify string lengths via node.

Let me write it.

Empty directory. Write index.html.

Next, verify: the length of the level rows, and the weird brick drawing code I wrote (the fillRect inside drawBrick using Math.min is suspicious, but since there's a "simpler second path" it's mostly harmless — actually, the first path might draw outside the tile: the fillRect using Math.max(x,bx+1) and the weird width calculation could draw pixels that overlap into adjacent tiles. Let me simplify drawBrick into a clean, correct implementation.)

Also, verify reachability with a simple BFS simulation in node.

Level verification passed: all row lengths are correct, and both the trophy and the door are reachable from the spawn point.

Two things to fix:
1. There was only 1 'E' in the level strings — I was planning 3–4 enemies. Add E to r8 c5 (falls onto the r9 left platform), and r5 c21 (falls onto the r6 right platform). Also might place one on the r9 right platform. Add: r8 c5 'E', r5 c21 'E'. Checking r8: "###........................###" → c5 becomes E. r5: "#............................#" → c21 'E', falls through r5 to… at r6 c19-24 there's a platform ✓ c21 lands there.

Note: an enemy at r8 c5 falls onto the r9 platform c3-8 ✓.

2. drawBrick has messy first-pass code that could draw outside the tile bounds. Replace with a clean implementation.

Apply the edits, then re-run verification with enemies included, and also quickly check enemy patrol logic — enemies on the r9 left platform: the platform is c3-8, with pillar blocks at c1-2 of r7/r8 above — the enemy patrols c3-8 and turns around at the edge ✓. An enemy at r6 right c19-24 patrols there; near the pillar c27-28 of r7/r8 — gap c25-26, edge turnaround ✓.

Note: the 'E' at r5 c21 falls onto the platform below. No problem.

Editing the level rows:
r5: "#............................#" → put E at c21: "#....................E.......#" — count: 1 + 20 dots (c1-20) + E(21) + 7 dots (22-28) + # = 1+20+1+7+1=30 ✓.
r8: "###........................###" → E at c5: "###..E...................###" count: 3 + 2 dots (3-4) + E(5) + 19 dots (6-24)? That makes 3+2+1+19=25, then need c25-26 dots and c27-28 '##' + c29 '#'. Original row: '###'(0-2) + 24 dots (3-26) + '###'(27-29). Replace the dot at c5 with E: "###..E" + 21 dots (6-26) + "###" = 6+21+3=30 ✓.

Wait — I added an enemy on the r8 left (pillar row "###..E..." — E at c5 falls onto the r9 platform at c3-8 ✓). And an E on the r5 c21 falls onto the r6 right platform at c19-24 ✓. So enemies are: ground at r14 c21, r9 left platform, r6 right platform = 3 enemies.

Re-running verification: length, enemies, and also simulating that enemies fall correctly (simple check: whether each E has solid ground somewhere below it). Also, to make sure there's no JS syntax error, run a JS syntax check on the script (extract the script and run node --check).

Row 8 ended up being 28 characters. I ended up writing "###..E...................###" — let me count: 3 + 2 + 1 + 19 + 3 = 28. Need 21 dots in the middle (c6〜c26), i.e., "###..E" + 21 dots + "###" = 6+21+3=30. Currently the middle has 19 dots. Add 2 more dots.

Wait, let me verify: "###..E" (6 chars: positions 0–5, E is at position 5) + dots c6–c26 = 21 dots + "###" = 30. What I wrote was: "###..E" + "....................." — let me count the number of dots in the edit: "###..E.....................###" — dots: need 21. I typed 21 dots. In the next check, let me confirm programmatically.

All good. Next, to confirm the game is actually clearable with the physics engine that's implemented, run a final full reachability simulation (with the same movement/collision code logic). The BFS I did earlier already uses the same constants and collision logic, and since the enemy changes don't affect the tiles for movement, reachability is still valid. But should I rerun BFS just to be safe? Adding the enemy doesn't change the grid for movement ('E' is treated as '.'). No problem.

Another consideration: the enemy at r5 c21 falls onto the r6 platform c19-24 and patrols there. The player's path to the door passes through there (r6 → r4 → door). Player can either stomp or avoid it. OK.

The enemy on the r9 left platform (c3-8) patrols right below the path where the player climbs up the pillar at c1-2 of r7/r8. Player jumps from r9 c3 to the pillar. There's a chance the enemy collides with the player but it's avoidable, no problem.

Also check: door is at r3 c26? The earlier parsing indicated the door is at c26. In row 3 there's D: "#...T.....................D..#": positions: 0#, 1-3 dots, 4 T, 5-25 dots (21), 26 D, 27-28 dots, 29#. Door is at c26. The r4 platform spans c25-29 ✓.

Also, drawDoor draws the door tile at doorPos. The player stands on r4 c25-29 and overlaps with the door tile r3 c26 ✓.

Potential gameplay bug: the hint message for when the door is locked is displayed on overlap. No problem.

Confirm no network/external resources: fonts are only the Courier New system font, no images, no fetch. ✓

Also double-check that the win overlay's score display is updated correctly — the draw loop continues even during the 'win' state, and update() early-returns except for updating particles... does update() return after the particles in the 'win' state? Check: inside update(), after particles: if(state==='dead'){...return;} if(state!=='play') return; — yes, particles are updated even during win. Good.

deadTimer: state 'dead' → respawn. The hasTrophy flag is preserved on respawn — as intended.

Done. Final file exists. Providing a summary.

Completed. Please summarize the game.