The user wants a first-person raycasting maze shooter, Wolfenstein 3D style, in a single index.html file. This is a complex project that needs:

1. **Raycasting engine** - Cast rays from player position, render walls with distance-based shading
2. **Procedural textures** - Generate wall textures (brick, stone, etc.) using canvas
3. **Maze generation** - Procedurally generate a grid-based maze
4. **Player movement** - WASD for movement, arrow keys or mouse for turning
5. **Enemies** - Place enemies in the maze, render them as sprites, allow shooting
6. **Shooting mechanics** - Click to shoot, hit detection
7. **HUD** - Health, ammo, minimap, crosshair

Let me build this step by step in a single HTML file. I need to be careful about:
- No external resources
- Canvas-based rendering
- Raycasting algorithm (DDA - Digital Differential Analysis)
- Sprite rendering for enemies
- Procedural texture generation

Let me write this comprehensive game.

Let me verify the file is there and looks good, then test it quickly.

The user is asking me to build a first-person raycasting maze shooter. I've already written the file. Let me check if there's an issue with the code - I notice I defined a seededRandom function but I'm not using the "rng" parameter properly in some texture generation functions. Let me also review the code more carefully for any bugs.

Actually, looking at the code again, I see that the `genBrickTexture` and `genStoneTexture` functions accept an `rng` parameter but in `seededRandom`, the function doesn't properly handle the seed since I'm passing `seed` but the returned function captures `s` which is initialized from `seed`. That's fine.

But wait, I notice that `seededRandom` is called with a seed, but the seed I'm passing is `42` for brick, `99` for stone, etc. That should work fine.

Let me also check if there's a bug with `keys['arrowleft']` and `keys['arrowright']` - they're set in keydown but I'm checking for `keys['arrowleft']` in the game loop. That should work.

One issue: the `seededRandom` function I defined is not actually being used for `generateMaze` - the maze uses `Math.random()`. That's fine for variety.

Let me look at the code more carefully... I see that `genBrickTexture` and `genStoneTexture` define `const r = rng || seededRandom(42)` but this creates a closure that captures `r` but then uses `r()` inside the draw function. That should work since `createTexture` calls `drawFn(cx, TEX_SIZE)` synchronously.

Actually, I realize there might be an issue with the sprite rendering. The `invDet` calculation seems wrong - I'm computing it incorrectly. Let me fix the sprite rendering math.

The standard Wolfenstein 3D approach:
- planeX = -sin(angle) * tan(FOV/2) (or equivalent)
- planeY = cos(angle) * tan(FOV/2)

Then transformX = (dirY * dx - dirX * dy) / det
transformY = (-planeY * dx + planeX * dy) / det

where dirX = cos(angle), dirY = sin(angle), and det = planeX * dirY - dirX * planeY

Let me fix the sprite rendering to be more correct. Also, I want to make sure the whole thing works well.

Let me also review a few things:
1. The `zBuffer` is populated during wall rendering - good
2. The sprite rendering checks z-buffer per column - good
3. Enemy AI moves toward player - good
4. Collision detection with sliding - good

I think there are a couple of issues to fix:
1. The sprite transform math is a bit off
2. The `seededRandom` function might not be needed but it's fine

Let me also make the code a bit more polished - add better enemy behavior, fix the sprite rendering, and ensure everything works.

Actually, looking at it more carefully, the code looks functional. The main things are:
- Raycasting with DDA ✓
- Textured walls ✓
- Sprites with z-buffer ✓
- Enemy AI ✓
- Shooting ✓
- Minimap ✓
- HUD ✓

Let me fix the sprite transform to be more standard. The current approach uses a non-standard plane calculation. Let me rewrite the sprite rendering section.

Also, I notice that I'm not using pointer lock properly for the mouse - the mouse should control looking, but I need to make sure the pointer lock is properly requested and handled.

Let me make a cleaner, more robust version of the game.

The file is written and working. Let me verify the structure is complete and well-formed by checking a few key sections.

The file looks good and is complete. Let me do a final check to make sure everything is in order.