Dangerous Dave platformer · deepseek-v4.1-flash

Let me build this. I'll create a single index.html with a tile-based platformer. Let me think through the design carefully to ensure the level is completable and physically reachable.

Let me design a level using a grid of tiles. Tile size ~32px. Canvas maybe 960x480 (30x15 tiles).

Let me design with a tile map. Legend:
- `#` solid wall/platform
- ` ` empty
- `T` trophy
- `E` exit
- `F` fire hazard
- `W` water hazard
- `1` enemy spawn
- `P` player spawn

Let me lay out a 30x15 grid. Actually let me do 32 wide x 15 tall = 1024px wide, 480 tall. Canvas 960 maybe. Let's do width 30, height 15, tile 32 → 960x480.

Let me carefully design. I'll make a level that's a side-scroller. I'll draw the whole level fitting in the canvas (no scrolling needed), 30 cols.

Row indices 0..14 top to bottom.

Let me design:

```
Row 0:  ##############################
Row 1:  #                            #
Row 2:  #                            #
Row 3:  #         T                  #
Row 4:  #      #####          E      #
Row 5:  #                     ####  #
Row 6:  #    1                       #
Row 7:  #  ######       ####         #
Row 8:  #                            #
Row 9:  #                  #####     #
Row 10: #        ####      1         #
Row 11: #                     ####   #
Row 12: # P                    W     #
Row 13: #                          F #
Row 14: ##############################
```

Hmm, need to ensure reachability and that trophy is reachable. Let me think more concretely with physics: jump height. Let me just make a straightforward level.

Let me define tile size 32. Player size ~24x28. Gravity enough to jump ~2.5 tiles high.

Let me design carefully with reachable platforms:

Columns 0-29. Border walls at col 0 and 29, floor at row 14.

I'll build a path: start bottom-left. Floor at row 13 (walkable, row 14 is solid). Wait let me set floor solid at row 14, walkable row 13.

Let me make platforms that are reachable with jumps of at most ~2 tiles up and ~3 tiles across.

Plan:
- Player starts at (col 2, row 13) on floor row 14.
- Ground floor row 14 solid across.
- Water hazard pit maybe can't since floor solid. I can make water on the floor region.

Actually easier: floor has solid row 14. Water placed on row 13 (on top of floor). Fire on row 13 too. Enemy patrols on a platform.

Let me define platforms:
- Floor: row 14 all solid.
- Platform A: row 11, cols 4-8
- Platform B: row 8, cols 8-12
- Platform C: row 11, cols 13-17
- Platform D: row 8, cols 18-22 (trophy here)
- Platform E: row 11, cols 22-26
- Exit at row 10 on top of platform E? Hmm exit should be on a surface.

Let me reconsider. Trophy must be collected before exit. Reachability: jumping from platform A (row 11 top surface) to platform B (row 8) is 3 tiles up - too high. Let me keep vertical gaps ≤2.

Simpler staircase design:

- Floor row 14 solid, cols 0-29.
- Start at col 2, row 13.
- Step platform at row 12, cols 5-7 (1 tile above floor). Actually row 12 top surface = player stands at row 11. From floor standing row 13, step up to row 12 top? Let me define standing row = tile above solid.

Let me define "standing row" as the row of the tile the player occupies when standing on a platform whose solid tile is directly below. If platform solid tile at row R, player stands with feet at top of row R, occupying roughly row R-1.

From floor (solid row 14), player at row 13. Jump up 2 tiles → can reach floor level row 11 (solid row 12 top? no). Let's say can reach standing on platform with solid at row 12 (standing row 11) easily, and with solid at row 11 (standing row 10) with a good jump.

Let me lay out a gentle staircase:

- Platform 1: solid row 12, cols 4-7
- Platform 2: solid row 10, cols 8-11
- Platform 3: solid row 8, cols 12-15
- Platform 4: solid row 6, cols 16-19

Each step is 2 up and 4 across (adjacent or slight gap). With jump height of ~2.5 tiles and horizontal speed, should be fine. But I need to verify jump height. Let me tune gravity/jump to reach ~3 tiles.

Alternative: make it more forgiving with solid rows 13, 12, 11, 10 (1-tile steps). Easier. Let me do a mix.

Actually let me just make a robust level and tune physics so jump reaches about 3.2 tiles high, so 2-tile gaps are easy.

Let me define level map as array of strings, each 30 chars, 15 rows.

Let me carefully construct. I'll use:

Row 0:  "##############################"
Row 1:  "#                            #"
Row 2:  "#                            #"
Row 3:  "#            T               #"
Row 4:  "#         #######            #"
Row 5:  "#                            #"
Row 6:  "#                    E       #"
Row 7:  "#                  #####     #"
Row 8:  "#        #####               #"
Row 9:  "#                            #"
Row 10: "#    #####        1          #"
Row 11: "#                            #"
Row 12: "#  P               W     F   #"
Row 13: "#       1                    #"
Row 14: "##############################"

Hmm this is getting messy. Let me be systematic and count characters exactly.

I'll write a Python-like plan mentally but easier with a table. Let me use a helper: I'll define each row as list of 30 chars.

Let me index columns 0-29.

Border: col 0 and col 29 are '#' in all rows (except maybe none). Floor row 14 all '#'.

Gameplay path (left to right staircase then back?) Let me keep it left to right.

Design:
- Player start at col 2, row 12 (standing on platform at row 13? need solid below). Let me put a start platform.

Let me just create a clean design:

```
col:            11111111112222222222
     0123456789012345678901234567890
r0   ##############################
r1   #                            #
r2   #                            #
r3   #          T                 #
r4   #       ######               #
r5   #                            #
r6   #                    E       #
r7   #                 ########   #
r8   #        #######             #
r9   #                            #
r10  #   ####                     #
r11  #                            #
r12  # P                          #
r13  #          ######    ######   #
r14  ##############################
```

Hmm wait 30 chars. Let me count: "##############################" = 30 #. Good.

But I need fire and water hazards and an enemy. Let me incorporate.

Actually, let me reconsider layout for a clear path and hazards. Let me use a floor at row 14, player starts row 13. Then climb platforms. Trophy on top platform. Exit on a mid platform to the right. Hazards on the floor and on some platforms. Enemy patrolling on floor.

But if the path goes up, the player might fall back to floor where hazards are. That's fine.

Let me design:

Row 0:  30 '#'
Row 1:  '#' + 28 spaces + '#'
Row 2:  same
Row 3:  '#' + 28 spaces + '#'  → maybe trophy here
Row 4:  '#' + platforms
...

Let me place:
- Trophy at col 23, row 3, standing on platform at row 4 (cols 20-25).
- Exit at col 26, row 9, standing on platform at row 10 (cols 24-28). Hmm.

Actually exit and trophy positions - exit should be reachable after trophy. Let me place trophy high and exit somewhere you pass.

Let me do a winding path:

Ground floor row 14. Start at col 2.
Platforms (solid rows):
- r12: cols 5-8  (step up 1)
- r10: cols 9-12 (step up 2)
- r12: cols 13-16 (down 2)
- r10: cols 17-20 (up 2)
- r8: cols 21-24 (up 2) → trophy at r7 col 22
- r11: cols 25-28 (down 3) → exit at r10 col 26

Hmm down is fine (falling).

Let me check horizontal gaps: from platform r12 cols5-8 to r10 cols9-12: adjacent, gap 0, up 2. Good. From r10 cols9-12 to r12 cols13-16: adjacent, down 2. From r12 cols13-16 to r10 cols17-20: up 2 adjacent. From r10 cols17-20 to r8 cols21-24: up 2 adjacent. From r8 cols21-24 to r11 cols25-28: down 3, adjacent. Good.

Hazards:
- Water on floor at r13 cols 10-13? But that's under platforms, player falls there. Hmm.
- Fire on platform r12 col 15 (so player must jump over it).
- Water pit: maybe make a gap in the floor with water. Let me make floor not fully solid; have a water pool at cols 9-13 on row 14, with row 14 being water? But water is hazard, not solid. Then falling in water = death. That's fine.

Actually simpler: keep floor solid row 14, and place water tiles at row 13 on the floor at some columns. Touching water = death. Fire tiles similarly.

Let me place fire at r11 (on platform r10? no). Let me place:
- Fire on platform r12 at col 15 (row 11). Since platform top is row 12 means player stands at row 11. Fire tile at row 11 col 15. Player must jump over it.

Wait platform r12 solid, so player standing occupies row 11. Fire hazard should be at row 11 on that platform.

Hmm but platform r12 cols13-16, fire at col15 row 11.

- Water on the floor: water tile at row 13, cols 20-22? But under platform r10 cols17-20 and path. Actually player could fall to floor and need to avoid. Let me place water at row 13 cols 9-11 maybe, but that's below platform r10 cols9-12. Falling there kills. Fine.

Hmm, but if water occupies floor tiles at row 13, and player is walking on floor at row 13, they'd die. Good.

- Enemy: patrolling on floor at row 13, cols 5-8 maybe? But player starts at col2 and needs to go to platform at col5. Enemy on floor could be avoided by jumping. Let me place enemy patrol on a platform instead: on platform r10 cols 9-12, patrolling between cols 9-12 at row 9. Hmm that might block path.

Let me place enemy on the floor patrolling cols 4-8 at row 13. Player starts col2, can jump over enemy or onto platform.

Actually enemy patrol on floor near start is good for demonstrating.

Let me finalize map. I'll construct each row string of 30 chars.

Let me use '.' for empty to make counting easier, then convert.

Columns 0-29.

Row 0: all '#' (30)
Row 1: '#' + 28 '.' + '#'
Row 2: same
Row 3: '#' ... trophy? Let me place trophy at r7 col22 instead since platform r8. Let me keep row 3 empty.
Row 4-6: mostly empty.

Let me just write it out.

r0:  "##############################"
r1:  "#............................#"
r2:  "#............................#"
r3:  "#............................#"
r4:  "#............................#"
r5:  "#............................#"
r6:  "#............................#"
r7:  "#.....................T......#"   -> trophy at col 22 (0-indexed). Let's count: col0 '#', then dots. Need T at col22. So 21 dots after col0? cols1..21 are dots (21 dots), col22='T', cols23..28 dots (6), col29 '#'. Total 1+21+1+6+1=30. Good.
r8:  "#....................####....#"   -> platform r8 cols21-24. Count: col0 '#', cols1-20 dots (20), cols21-24 '####', cols25-28 dots (4), col29 '#'. 1+20+4+4+1=30. Good.
r9:  "#............................#"
r10: "#.................####.......#"   -> platform r10 cols18-21? Let me recompute path.

Hmm, I changed design. Let me carefully redo with the plan:
- platform r12: cols 5-8
- platform r10: cols 9-12
- platform r12: cols 13-16
- platform r10: cols 17-20
- platform r8: cols 21-24
- platform r11: cols 25-28

Wait but r8 platform cols21-24 and r11 platform cols25-28 adjacent and down 3. Fine.

But then trophy on r8 platform at r7 col22.

Exit on r11 platform at r10 col26.

Let me construct rows:

r7: T at col22.
r8: '#' cols21-24.
r10: '#' cols9-12 and cols17-20.
r11: '#' cols25-28.
r12: '#' cols5-8 and cols13-16.

Let me also add fire/water/enemy/player.

Player start: floor row14 top, at col2 row13. Put 'P' at r13 col2.

Hazards:
- Water: floor row13 cols 9-11? But platform r10 cols9-12 above. Player could fall. Let's put water at r13 cols 10-11 (2 tiles).
- Actually let me put water in the gap between start area and first platform? Floor is continuous, so player walks. Water at cols 10-11 on floor.
- Fire: on platform r12 cols13-16 at r11 col15. So 'F' at r11 col15.
- Fire also maybe on r8 platform? Not needed.
- Enemy: on floor patrolling cols 4-8 at r13. But player starts col2 and platform starts col5. Enemy would be there. Hmm, enemy at floor could be jumped over. Let me place enemy on r10 platform cols9-12 at r9 col10? But water below. Enemy patrols. Might be tricky but ok.

Let me place enemy on the big floor to the right, e.g., cols 18-22 at r13, but that's under platforms. Player doesn't need to go there. Hmm, need enemy to be a threat/observable.

Maybe place enemy on platform r12 cols5-8 at r11? Then player must deal with it to progress. Let's place enemy patrol on r12 platform between cols5-8, at r11. Player jumps over it. That's the first platform. Good demonstration.

Wait but fire at r11 col15 (platform r12 cols13-16). Enemy at r11 on platform r12 cols5-8. Good.

Hmm but player jumping onto platform from floor: platform r12 top is row 11, player on floor row13. Step up 2 tiles. Player can jump onto it. But enemy patrols there. Player can jump over enemy. OK.

Let me reconsider: maybe make first step easier. Platform r12 is 2 tiles above floor standing (floor standing row13, platform standing row11 → 2 tiles up). With good jump (~3 tiles) fine.

Actually let me add an intermediate platform r13 to make it easier? No, keep simple but tune jump.

Let me now write map rows with all elements:

r0:  "##############################"
r1:  "#............................#"
r2:  "#............................#"
r3:  "#............................#"
r4:  "#............................#"
r5:  "#............................#"
r6:  "#............................#"
r7:  "#.....................T......#"
r8:  "#....................####....#"
r9:  "#............................#"
r10: "#........####....####........#"
r11: "#...........F....E....####...#"  wait exit at col26 and platform r11 cols25-28.

Let me redo r11: enemy at col? fire at col15, exit at col26.
r11: positions: col0 '#', cols1-14 dots, col15 'F', cols16-25 dots? then col26 'E', cols27-28 dots, col29 '#'.
Wait platform r11 cols25-28. Exit 'E' at col26 row10 (standing on platform). Actually exit should be at r10 (one above platform r11). Let me place E at r10 col26. And r11 platform solid cols25-28.

So r11 has platform '#' at cols25-28. Fire F at col15 row11 (on platform r12 cols13-16). Enemy at col6 row11 (on platform r12 cols5-8).

Let me write:

r11: col0 '#', cols1-5 dots(5), col6 '1'(enemy), cols7-14 dots(8), col15 'F', cols16-24 dots(9), cols25-28 '####', col29 '#'.
Count: 1+5+1+8+1+9+4+1 = 30. 

r10: col0 '#', cols1-8 dots(8), cols9-12 '####', cols13-16 dots(4), cols17-20 '####', cols21-25 dots(5), col26 'E', cols27-28 dots(2), col29 '#'.
Count: 1+8+4+4+4+5+1+2+1 = 30. 

r9: all dots inside. "#............................#"

r8: col0 '#', cols1-20 dots(20), cols21-24 '####', cols25-28 dots(4), col29 '#'.
Count 1+20+4+4+1=30. 

r7: col0 '#', cols1-21 dots(21), col22 'T', cols23-28 dots(6), col29 '#'.
Count 1+21+1+6+1=30. 

r12: col0 '#', cols1-4 dots(4), cols5-8 '####', cols9-12 dots(4), cols13-16 '####', cols17-28 dots(12), col29 '#'.
Count 1+4+4+4+4+12+1=30. 

r13: player at col2, water at cols10-11.
col0 '#', col1 '.', col2 'P', cols3-9 dots(7), cols10-11 'WW', cols12-28 dots(17), col29 '#'.
Count 1+1+1+7+2+17+1=30. 

r14: all '#'.

Now check reachability:
- Start floor row14, standing row13 at col2.
- Platform r12 cols5-8: from col2 row13, run right, jump up 2 tiles to stand on platform at row11. Horizontal distance: col2→col5 = 3 tiles. Should be fine while jumping. Enemy at col6 row11.
- From platform r12 cols5-8 (standing row11), jump to platform r10 cols9-12 (standing row9): adjacent, up 2. Fine.
- From r10 cols9-12 (row9) to r12 cols13-16 (standing row11): down 2, adjacent. Fine.
- Then fire at col15 row11 on that platform. Player lands on platform at col13, must jump over fire at col15. Platform cols13-16. Fire at col15. Jump over — jump length should cover. Player can also jump from platform to platform.
- From r12 cols13-16 (row11) to r10 cols17-20 (row9): up 2 adjacent. Fine.
- From r10 cols17-20 (row9) to r8 cols21-24 (row7): up 2 adjacent. Fine.
- Trophy at r7 col22 on platform r8. Collect.
- From r8 cols21-24 (row7) to r11 cols25-28 (standing row10): down 3, adjacent. Falling down fine.
- Exit at r10 col26 on platform r11. Reach.

Wait, r10 col26 E and platform r11 cols25-28 below → standing on platform r11 top row10. Good. Exit occupies r10 col26. Player reaches standing row10, overlaps exit.

Great. Water at cols10-11 on floor row13: player walking on floor from col2 rightward would hit water at col10-11. But player jumps to platform r10 cols9-12? Actually from platform r12 cols5-8, they jump right to platform r10. They might fall. Water is a hazard on the floor. Good, adds danger.

Hmm but is the first platform r12 cols5-8 reachable without touching the enemy? Enemy patrols platform. Player jumps onto platform edge col8 maybe, then enemy moves. Could collide. That's gameplay. But we want it "completable". Enemy can be jumped over. Fine.

Actually enemy at col6 on platform. When player lands on col8, enemy may approach. Player can jump over. It's fine.

Let me maybe make enemy patrol on the floor to the right instead, or keep. I'll keep it but ensure enemy collision works and can be avoided.

Now physics:
Tile size = 32. Canvas 960x480.

Player: width 22, height 28.
Gravity: let's use pixels/frame². Target jump height ~ 3 tiles = 96px. v = sqrt(2*g*h). If g=0.8, h=96 → v=sqrt(153.6)=12.4. Let's set jumpVelocity = -12.5, gravity = 0.8. Max height = v²/(2g)=156.25/1.6=97.6px ≈ 3.05 tiles. Good.

Horizontal speed ~3.2 px/frame. Time to apex = v/g = 15.6 frames. Horizontal distance in full jump (to same level) ~ 2*15.6*3.2 = 100px ≈ 3.1 tiles. Good for 3-tile horizontal gaps? From col2 to col5 is 3 tiles but player lands on top, needs to travel while rising 2 tiles. At height 2 tiles (64px), time to reach: 64 = 12.5t - 0.4t² → solve 0.4t² -12.5t +64=0 → t=(12.5±sqrt(156.25-102.4))/0.8=(12.5±7.33)/0.8 → t=6.46 or 24.8. At t=6.46, horizontal = 20.7px < 3 tiles. Hmm that means at the first moment reaching 2 tiles height, only moved 0.65 tiles horizontally. But the player continues rising to 3 tiles then can travel more before landing on the 2-tile-high platform. The platform top is at 2 tiles up. Player passes 2-tile height going up at t=6.46, reaches apex at 15.6, comes back to 2-tile height at t=24.8. At t=24.8 horizontal = 79px ≈ 2.5 tiles. So from starting at col2 (x=64), player can land on platform starting at col5 (x=160)? 64+79=143 < 160. Hmm not quite reaching. But player can run and jump from the edge of... there's no platform edge; they're on the floor. They can start jump earlier/later, and can get horizontal distance while running before jumping. Actually the floor is continuous so player can run at full speed and jump; reaching x=160 from x=64 while airborne requires 96px = 3 tiles, time = 96/3.2=30 frames. At t=30, height = 12.5*30 - 0.4*900 = 375-360=15px above start, i.e., ~0.5 tiles. So at 3 tiles horizontal they're only 0.5 tiles high → can't land on 2-tile platform. So the gap is too big!

Wait, but the player only needs to get onto the platform. They could jump from right next to the platform. Since floor is continuous up to col5, they can stand at col4 (x=128, adjacent to platform) and jump straight up then move right onto platform. At col4 floor, platform col5 begins at x=160. Distance 32px. At t=6.46 (2 tiles up) horizontal 20.7px, so x=128+20.7=148.7 still on floor. At t=10, height=12.5*10-0.4*100=125-40=85px (~2.65 tiles), horizontal=32px → x=160, now above platform top (row12 top at y=384? let me compute). Platform r12 solid, top at y=12*32=384. Standing row11 top at y=11*32=352. Floor row14 top at y=14*32=448. Player standing on floor: feet at y=448. Player feet at height 85px above → y=363, which is below platform top 384? Wait smaller y is higher. Feet y=448-85=363 < 384 means above the platform top. Good, so player can then move right onto platform and land. Actually at t=10 they're above the platform and moving right, so they can land. Fine.

But actually simpler: player doesn't have to jump the gap; they can walk to the base of the platform at col4/col5 area? At col5 the platform is solid at row12, so floor there is still solid r14. Player at col5 floor row13, but platform above at r12 — the space r13 is free, so player can stand under it? Player height 28px < 32, fits in row13. Then jump would be blocked by platform. Hmm. So player must jump from col4 to get onto platform.

Let me make it easier: make platform r12 cols4-7 instead of 5-8, and move enemy. Then from floor col3 (adjacent) jump up onto col4. Actually adjacency is fine, they can jump up 2 tiles and move 1 tile right.

Actually the issue is horizontal reach during jump. Since floor is continuous, the player can position right next to the platform and jump up. It's reachable. Good. Let me keep design but maybe reduce gaps to be safe.

Actually to be safe, let me add a small step at r13 (1 tile higher) before the first platform, so step up is only 1 tile. E.g., platform/block at r13 col4 (a raised block). Hmm r13 is floor walk level. A solid block at row13 means player must step onto it (1 tile up). Let me add step blocks.

Let me simplify: make first platform r13 (standing row12) cols 5-8. From floor row13, step up 1 tile onto it. Then r11 (standing row10) cols 9-12, up 2. Etc. Let me redo:

Platforms:
- r13: cols 5-8 (step 1)
- r11: cols 9-12 (step 2 from r13)
- r13: cols 13-16 (down 2)
- r11: cols 17-20 (up 2)
- r9: cols 21-24 (up 2)
- r12: cols 25-28 (down 3)

Hmm, then trophy on r9 platform at r8 col22? And exit on r12 platform standing r11 at r11 col26? Let me recompute rows.

This is getting complicated. Let me just use the original and trust that jump from adjacent works. Let me verify with a simulation mentally... I'll instead test in browser with the tool. Good—I have browser tools. So I can iterate.

Let me write the code with a debug-ish but clean approach, then test.

Physics implementation: I'll do axis-separated collision with tile grid.

Let me set constants:
- TILE=32
- Player w=20,h=28
- speed=3.4
- gravity=0.8
- jump=-12.8
- maxFall=16

Movement: horizontal then resolve collisions, vertical then resolve.

Level defined as array of strings with '.' empty.

Parse into grid; when hitting hazards/enemy check per frame.

Solid tiles: '#'. Hazards: 'W' water, 'F' fire. Trophy 'T', Exit 'E', enemy '1', player 'P'. These are non-solid (except maybe exit/trophy).

I'll create entity list from map: trophy object, exit object, hazards array, enemies array.

Enemy patrol: simple horizontal patrol between bounds computed at spawn—or just move left/right and reverse on hitting solid or ledge. I'll give each enemy a patrol range (min/max tile x) based on the platform it's on. Simplest: enemy moves left/right, reverses when next tile in movement direction is not solid or is wall. Let me implement: check tile below-ahead; if no solid below ahead tile, reverse. That keeps it on platform. Also reverse on wall.

Let me implement enemy with pixel position, velocity -1 or 1, speed 1.2. At each frame, compute next x; check if ground exists below the leading edge; if not or wall, reverse.

Player-enemy collision: AABB overlap → death.

Hazard collision: if player AABB overlaps a hazard tile → death. Water tile could be at floor but non-solid; player would fall into it? Since solid floor is below. Player standing at row13 overlapping water tile → death. Good. Fire on platform similarly.

Win: reach exit with trophy. If reach exit without trophy → show message "Collect the trophy first!" and keep active.

Loss: death. Show "You died!" with restart.

States: 'playing', 'dead', 'won', plus message.

Restart: reset everything.

Rendering: dangerous dave style. Background sky gradient, tiles as brown/dirt blocks with grass top, water animated blue, fire animated orange, trophy gold cup, exit as door/portal, player as little character with hat, enemy as blob.

Let me draw procedurally.

Also display controls on screen.

Let me also add level reachability but we'll test.

Let me write the file.

I'll use requestAnimationFrame with fixed timestep accumulator for stability.

Let me code.

Key handling: ArrowLeft/a, ArrowRight/d, Space jump, R restart.

Now, to make the map strings correct, let me carefully write them with exactly 30 chars.

Let me define:
```
const LEVEL = [
"##############################", //0
"#............................#", //1
"#............................#", //2
"#............................#", //3
"#............................#", //4
"#............................#", //5
"#............................#", //6
"#.....................T......#", //7
"#....................####....#", //8
"#............................#", //9
"#........####....####........#", //10  -> cols9-12 and 17-20
"#.....1.......F..........E...#", //11  -> enemy col6, fire col15, exit? 
"#....####....####............#", //12
"#.P.......WW.................#", //13
"##############################"  //14
];
```

Wait r11: need platform cols25-28. Let me redo. Also exit at r10 col26.

Let me carefully build each:

r7: "#.....................T......#"
Count: '#'(1) + '.'x21 + 'T' + '.'x6 + '#' = 1+21+1+6+1=30. T at index 22. ✓

r8: "#....................####....#"
'#'(1)+'.'x20+'####'(4)+'.'x4+'#'(1)=1+20+4+4+1=30. '#' at indices 21-24. ✓

r10: "#........####....####........#"
'#'(1)+'.'x8(8)+'####'(4)+'.'x4(4)+'####'(4)+'.'x8(8)+'#'(1) = 1+8+4+4+4+8+1=30. 
Platforms at indices 9-12 and 17-20. ✓ Exit should be at col26 r10. Add 'E' at index26: 
indices: 0 '#', 1-8 dots(8), 9-12 '####', 13-16 dots(4), 17-20 '####', 21-25 dots(5), 26 'E', 27-28 dots(2), 29 '#'. 
String: "#" + "........" + "####" + "...." + "####" + "....." + "E" + ".." + "#"
= "#........####....####.....E..#"
Count 1+8+4+4+4+5+1+2+1=30. ✓

r11: platform cols25-28, enemy col6, fire col15.
indices: 0 '#', 1-5 dots(5), 6 '1', 7-14 dots(8), 15 'F', 16-24 dots(9), 25-28 '####', 29 '#'.
String: "#" + "....." + "1" + "........" + "F" + "........." + "####" + "#"
= "#.....1........F.........####" + "#"? Let me concatenate: "#.....1" (7) + "........" (8)=15 + "F"=16 + "........." (9)=25 + "####"=29 + "#"=30. 
So "#.....1........F.........####" is 29 chars? Let me just build: 
"#" + "....." = "#....." (6 chars, indices0-5)
+ "1" = "#.....1" (7, index6)
+ "........" = "#.....1........" (15, indices7-14)
+ "F" = "#.....1........F" (16, index15)
+ "........." = "...", 9 dots → total 25, indices16-24
+ "####" → 29, indices25-28
+ "#" → 30, index29
Final: "#.....1........F.........####" wait that's missing last char. Let me write explicitly:
"#.....1" + "........" + "F" + "........." + "####" + "#"
= "#.....1........F.........####" + "#"
Hmm count the literal: 
"#.....1" = 7
+8 = 15
+1 = 16
+9 = 25
+4 = 29
+1 = 30.
So full string is "#.....1" + "........" + "F" + "........." + "####" + "#".
Let me just count characters in final literal later in code; I'll add a validation in JS that logs lengths. Actually I can add a runtime check. But better be precise. I'll write them and verify with a quick node/bash script after.

r12: platforms cols5-8 and 13-16.
indices: 0 '#', 1-4 dots(4), 5-8 '####', 9-12 dots(4), 13-16 '####', 17-28 dots(12), 29 '#'.
String: "#" + "...." + "####" + "...." + "####" + "............" + "#"
= "#....####....####............#"
Count: 1+4+4+4+4+12+1=30. ✓

r13: player col2, water cols10-11.
indices: 0 '#', 1 '.', 2 'P', 3-9 dots(7), 10-11 'WW', 12-28 dots(17), 29 '#'.
String: "#" + "." + "P" + "......." + "WW" + "................." + "#"
= "#.P.......WW.................#"
Count 1+1+1+7+2+17+1=30. ✓

Good. Now I'll verify lengths with a script.

Now about reachability again with platforms at r12/r13. From r13 step? r12 platform is 2 tiles above floor standing (floor row14, stand row13; platform r12 top row11... wait platform solid at r12, standing row11; that's 2 tiles up from row13). Hmm r13 is the player's standing row on floor. Platform r12 solid means its top surface is at row12, player stands at row11. Difference in standing rows: 13→11 = 2. So 2-tile step. OK.

The player can walk to col4 (floor) and jump up onto platform at col5. Fine.

Now let me also make sure the first platform's left edge at col5; player can position at col4 and jump. Good.

Water at cols10-11 floor. If the player falls from platform r10 cols9-12 down, they'd land in water → death. Good hazard.

Now, is exit reachable with trophy? Path described. Should be.

Let me also ensure enemy doesn't make it impossible. Enemy at r11 col6 on platform r12 (cols5-8). It will patrol between col5 and col8. Player lands on platform maybe on col8 side, jumps over enemy. Fine.

Now let me write the code, then test with browser. Let me also add a "debug" maybe not.

Let me write index.html.

I'll implement collision detection:
- solidAt(col,row): row out of bounds → treat top/bottom? If row<0 → not solid. If col<0 or col>=cols → solid (walls). If row>=rows → solid? Let's treat below as not solid (fall). But floor covers.

Player rect {x,y,w,h}. x,y top-left.

Horizontal move: x += vx; then check tile overlaps; for each solid tile, resolve by pushing out.

Standard:
```
function moveX(ent, dx){
 ent.x += dx;
 const t = tilesOverlapping(ent);
 for each solid tile:
   if dx>0: ent.x = tile.left - ent.w; 
   else: ent.x = tile.right;
}
```
But need iterate. Let me implement generic.

Actually simpler robust: after moving, compute tiles overlapped by rect; for each solid, if moving right, set x = min(x, tileX*TILE - w); if left, set x = max(x, (tileX+1)*TILE).

Vertical similar. On landing (moving down collision), grounded=true.

Let me write:

```
function collideX(e){
  const c1=Math.floor(e.x/TILE), c2=Math.floor((e.x+e.w-1)/TILE);
  const r1=Math.floor(e.y/TILE), r2=Math.floor((e.y+e.h-1)/TILE);
  for(let r=r1;r<=r2;r++)for(let c=c1;c<=c2;c++){
    if(isSolid(c,r)){
      if(e.vx>0){ e.x = c*TILE - e.w; }
      else if(e.vx<0){ e.x = (c+1)*TILE; }
      e.vx=0; return;
    }
  }
}
```

Hmm if multiple, fine enough.

Vertical:
```
function collideY(e){
  ... if(isSolid){
    if(e.vy>0){ e.y=r*TILE-e.h; e.grounded=true; }
    else if(e.vy<0){ e.y=(r+1)*TILE; }
    e.vy=0;
  }
}
```

For player grounded: set grounded=false before vertical move, then set true on downward collision. Also need to keep grounded when standing still (vy=0, no collision because not overlapping). Hmm typical approach: apply gravity each frame so vy>0 always when not grounded and will collide. When resting on ground, vy accumulates gravity then collides and resets to 0 each frame, setting grounded=true. So fine.

isSolid(c,r): if c<0||c>=COLS return true; if r<0 return false; if r>=ROWS return false; return grid[r][c]==='#'.

Now hazards: check overlap with hazard tiles each frame. Water/Fire are in grid. For player rect, compute overlapping tiles; if any is 'W' or 'F' → death.

But note: water at row13, player standing at row13 overlapping → immediate death if walking there. Good.

Enemy: enemy rect; check ground ahead for reversal.

Let me implement enemy update:
```
for each enemy:
  // move
  const nextX = e.x + e.dir*e.speed;
  // check wall
  const testY = e.y;
  // compute foot ahead
  const aheadX = e.dir>0 ? nextX+e.w+1 : nextX-1;
  const c = Math.floor(aheadX/TILE);
  const rBelow = Math.floor((e.y+e.h+2)/TILE);
  let groundAhead = isSolid(c, rBelow);
  // also wall ahead at body
  const rTop = Math.floor((e.y+e.h/2)/TILE);
  let wallAhead = isSolid(c, rTop);
  if(!groundAhead || wallAhead){ e.dir*=-1; }
  else e.x = nextX;
```
Also apply gravity to enemy so it sits on platform. Let me just place enemy exactly on platform and add gravity.

Enemy spawn from map: '1' at r11 col6. Enemy h maybe 26, placed at y = r*TILE + (TILE-h) so bottom = r*TILE + TILE? Wait tile r11 is empty (player space), platform solid at r12. Enemy should stand on top of r12, so enemy bottom at y=12*TILE=384. Enemy h=26 → y=384-26=358. Standing row 11 area. Good. Spawn y = (r+1)*TILE - h.

Actually general: for '1' at (c,r), set y=(r+1)*TILE - h. That puts bottom at bottom of tile r. Since tile below (r+1) solid, fine.

Player spawn similarly: 'P' at r13, y = (13+1)*TILE - h = 448-28=420. Bottom at 448 = top of row14. Good.

Trophy: at r7 col22. Trophy as an entity rect centered in tile, or just drawn. I'll make trophy object {x,y,w,h, collected}. Rect roughly tile-sized.

Exit: at r10 col26. Exit rect tile.

Trophy/exit don't need collision with tiles.

Win check: player overlaps exit and hasTrophy → won. If overlaps exit without trophy → show message (once) and keep playing. Keep message displayed maybe for 2s.

Let me now write the code.

Rendering details:
- Background: gradient sky (dark blue to lighter) plus maybe stars/moon for cave feel. Dangerous Dave is dark cave-ish. I'll do a dark gradient with a subtle grid.
- Tiles: draw as blocks with top highlight. I'll differentiate grass? Dangerous Dave uses brown/dark teal blocks. Let me draw dirt blocks: fill #5a3a1e, top edge #8b5a2b, plus small speckles.
- Water: animated with sine, blue with transparency.
- Fire: animated flames.
- Trophy: gold cup with handles.
- Exit: a door/portcullis with "EXIT" sign, glowing.
- Player: body with cap, eyes.
- Enemy: green/red blob with eyes.

I'll add a HUD showing trophy status, and controls text.

Let me write it.

Also fixed timestep: accumulate dt, step at 1/60.

Let me write file now.

I'll be careful with escaping.

Let me produce the HTML.

For the character, dimensions: w=20,h=28.

Let me consider jump reachability more with these physics. gravity=0.8 per frame at 60fps, jump=-13. Max height = 169/1.6=105.6px = 3.3 tiles. Good. Horizontal speed 3.2. Fine.

Let me now write.

Also should prevent space scrolling page; preventDefault.

Restart key R, and a button.

Let me code the game object with reset().

Let me write out.

After writing, run browser to inspect console, screenshot, test movement/jump near start.

Let me write the file.

Let me verify map row lengths and then test in browser.

Row 11 is 29 — missing the closing border '#'. I wrote `"#.....1........F.........####"` which needs another '#'. Let me fix. Should be `"#.....1........F.........####" + "#"` = 30 chars. Add a trailing '#'.