**Developing Core Mechanics**

I'm currently focused on establishing the foundational elements for the raycasting engine. My latest efforts involve refining the rendering loop and implementing procedural texture generation within the constraints of a single HTML file.

**Generating Textures Procedurally**

I'm now deeply engaged in creating entirely procedural textures, bypassing any external image assets. My current focus is on developing algorithms to generate these textures directly within the JavaScript code, ensuring they adhere to the single-file constraint.

**Refining Rendering Pipeline**

My latest efforts are focused on optimizing the core rendering loop, specifically how I'm calculating and drawing wall segments. I'm experimenting with different approaches to ensure smooth performance and accurate depth perception before tackling sprite rendering.

**Generating Textures Procedurally**

I'm now deeply engaged in creating entirely procedural textures, bypassing any external image assets. My current focus is on developing algorithms to generate these textures directly within the JavaScript code, ensuring they adhere to the single-file constraint.

**Generating Textures Programmatically**

I'm now deeply engaged in developing algorithms to generate textures directly within the JavaScript code. My current focus is on creating simple, repeating patterns that will serve as wall textures, adhering strictly to the single-file constraint.

**Generating Textures Dynamically**

I'm currently refining my approach to procedural texture generation, focusing on creating distinct visual characteristics for different wall types. My recent work involves devising algorithms that dynamically produce repeating patterns based on simple mathematical functions, all within the confines of a single JavaScript block.

**Refining Texture Algorithms**

I am now focused on enhancing the procedural texture generation. My recent work involves implementing algorithms that create more varied and visually interesting repeating patterns for walls, ensuring they remain dynamic and within the single-file constraint.

**Developing Raycasting Engine**

I am now focused on building the core raycasting engine. My recent work involves implementing the algorithm to cast rays from the player's perspective and calculate intersections with maze walls, determining the distance for rendering.

**Updating Core Rendering**

My current focus is on refining the core raycasting loop and implementing procedural textures. I'm working on generating repeating wall patterns directly in JavaScript to meet the single-file constraint.

**Updating Core Rendering**

I am now focused on refining the raycasting loop and implementing procedural textures for the walls. My recent work involves generating simple repeating patterns directly in JavaScript to adhere to the single-file constraint.

**Developing Core Loop**

I am now focused on refining the main game loop and integrating procedural texture generation for walls. My recent work involves calculating ray-wall intersections and mapping those hit points to simple, repeating patterns generated directly in JavaScript.

**Refining Procedural Textures**

I am now focused on enhancing the procedural texture generation. My recent work involves implementing algorithms that create more varied and visually interesting repeating patterns for walls, ensuring they remain dynamic and within the single-file constraint.

**Developing Core Loop**

I am now focused on refining the main game loop and integrating procedural texture generation for walls. My recent work involves calculating ray-wall intersections and mapping those hit points to simple, repeating patterns generated directly in JavaScript.

**Developing Core Loop**

I am now focused on refining the main game loop and integrating procedural texture generation for walls. My recent work involves calculating ray-wall intersections and mapping those hit points to simple, repeating patterns generated directly in JavaScript.

**Developing Core Loop**

My focus is on refining the main game loop and integrating procedural texture generation for walls. I'm calculating ray-wall intersections and mapping hit points to simple, repeating patterns generated directly in JavaScript.

**Refining Core Loop**

I am now focused on refining the main game loop and integrating procedural texture generation for walls. My recent work involves calculating ray-wall intersections and mapping those hit points to simple, repeating patterns generated directly in JavaScript.

**Refining Texture Algorithms**

I'm currently focused on enhancing the procedural texture generation. My recent work involves implementing algorithms that create more varied and visually interesting repeating patterns for walls, ensuring they remain dynamic and within the single-file constraint.

**Developing Core Loop**

I am now focused on refining the main game loop and integrating procedural texture generation for walls. My recent work involves calculating ray-wall intersections and mapping those hit points to simple, repeating patterns generated directly in JavaScript.

**Developing Core Loop**

I am now refining the main game loop and integrating procedural texture generation for walls. My recent work involves calculating ray-wall intersections and mapping those hit points to simple, repeating patterns generated directly in JavaScript.

**Developing Core Loop**

I am refining the main game loop, focusing on integrating procedural texture generation for walls. My recent work involves calculating ray-wall intersections and mapping those hit points to simple, repeating patterns generated directly in JavaScript.

**Refining Procedural Textures**

I am now focused on enhancing the procedural texture generation. My recent work involves implementing algorithms that create more varied and visually interesting repeating patterns for walls, ensuring they remain dynamic and within the single-file constraint.

**Developing Core Loop**

I am refining the main game loop and integrating procedural texture generation for walls. My recent work involves calculating ray-wall intersections and mapping those hit points to simple, repeating patterns generated directly in JavaScript.

**Updating Core Rendering**

I am currently refining the raycasting loop, focusing on precise wall intersection calculations. My recent work involves implementing the DDA algorithm to accurately detect wall hits and determine distances, preparing for procedural texture application to the rendered wall segments.

**Developing Core Loop**

I'm refining the main game loop and integrating procedural texture generation for walls. My recent work involves calculating ray-wall intersections and mapping those hit points to simple, repeating patterns generated directly in JavaScript.

**Developing Core Loop**

I am refining the main game loop and integrating procedural texture generation for walls. My recent work involves calculating ray-wall intersections and mapping those hit points to simple, repeating patterns generated directly in JavaScript.

**Developing Core Loop**

I am refining the main game loop and integrating procedural texture generation for walls. My recent work involves calculating ray-wall intersections and mapping those hit points to simple, repeating patterns generated directly in JavaScript.

**Developing Core Loop**

I am refining the main game loop and integrating procedural texture generation for walls. My recent work involves calculating ray-wall intersections and mapping those hit points to simple, repeating patterns generated directly in JavaScript.

**Developing Core Loop**

I'm refining the main game loop and integrating procedural texture generation for walls. My recent work involves calculating ray-wall intersections and mapping those hit points to simple, repeating patterns generated directly in JavaScript.

**Developing Core Loop**

I am refining the main game loop and integrating procedural texture generation for walls. My recent work involves calculating ray-wall intersections and mapping those hit points to simple, repeating patterns generated directly in JavaScript.

**Developing Core Loop**

I am refining the main game loop and integrating procedural texture generation for walls. My recent work involves calculating ray-wall intersections and mapping those hit points to simple, repeating patterns generated directly in JavaScript.

**Refining Raycasting Calculations**

I'm currently refining the core raycasting loop and focusing on precise wall intersection calculations. My recent work involves implementing the DDA algorithm to accurately detect wall hits and determine distances, preparing for procedural texture application to the rendered wall segments.

**Updating Core Rendering**

I am refining the raycasting loop and implementing procedural textures. My current focus involves accurately calculating wall intersection points and applying dynamically generated repeating patterns to create visual depth and detail for the walls within the single-file constraint.

**Refining Procedural Textures**

I am now focused on enhancing the procedural texture generation. My recent work involves implementing algorithms that create more varied and visually interesting repeating patterns for walls, ensuring they remain dynamic and within the single-file constraint.

**Updating Core Rendering**

I am refining the raycasting loop, focusing on precise wall intersection calculations. My recent work involves implementing the DDA algorithm to accurately detect wall hits and determine distances, preparing for procedural texture application to the rendered wall segments.

**Refining Procedural Textures**

I'm currently focused on enhancing the procedural texture generation. My recent work involves implementing algorithms that create more varied and visually interesting repeating patterns for walls, ensuring they remain dynamic and within the single-file constraint.

**Refining Texture Mapping**

I'm currently refining how procedural textures are mapped onto the rendered walls. My focus is on accurately calculating the UV coordinates based on ray intersection points, ensuring patterns align correctly and dynamically generated textures provide visual depth.

**Updating Core Rendering**

I am refining the raycasting loop and implementing procedural textures. My current focus involves accurately calculating wall intersection points and applying dynamically generated repeating patterns to create visual depth and detail for the walls within the single-file constraint.

**Refining Procedural Textures**

I'm currently focused on enhancing the procedural texture generation. My recent work involves implementing algorithms that create more varied and visually interesting repeating patterns for walls, ensuring they remain dynamic and within the single-file constraint.

**Developing Core Loop**

I am refining the main game loop and integrating procedural texture generation for walls. My recent work involves calculating ray-wall intersections and mapping those hit points to simple, repeating patterns generated directly in JavaScript.

**Updating Rendering Pipeline**

My focus is on refining the raycasting loop and integrating procedural texture generation for walls. I'm calculating ray-wall intersections and mapping hit points to dynamically generated repeating patterns for visual depth.

**Refining Procedural Textures**

I am now focused on enhancing the procedural texture generation. My recent work involves implementing algorithms that create more varied and visually interesting repeating patterns for walls, ensuring they remain dynamic and within the single-file constraint.

**Developing Core Loop**

I am refining the main game loop and integrating procedural texture generation for walls. My recent work involves calculating ray-wall intersections and mapping those hit points to simple, repeating patterns generated directly in JavaScript.

**Developing Core Loop**

I am refining the main game loop and integrating procedural texture generation for walls. My recent work involves calculating ray-wall intersections and mapping those hit points to simple, repeating patterns generated directly in JavaScript.

**Refining Procedural Textures**

I am now focused on enhancing the procedural texture generation. My recent work involves implementing algorithms that create more varied and visually interesting repeating patterns for walls, ensuring they remain dynamic and within the single-file constraint.

**Refining Texture Mapping**

I'm currently refining how procedural textures are mapped onto the rendered walls. My focus is on accurately calculating the UV coordinates based on ray intersection points, ensuring patterns align correctly and dynamically generated textures provide visual depth.

**Updating Core Rendering**

I am refining the raycasting loop and integrating procedural texture generation. My current work involves accurately calculating wall intersection points and applying dynamically generated repeating patterns to create visual depth and detail for the walls within the single-file constraint.

**Developing Core Loop**

I am refining the main game loop and integrating procedural texture generation for walls. My recent work involves calculating ray-wall intersections and mapping those hit points to simple, repeating patterns generated directly in JavaScript.

**Developing Core Loop**

I am refining the main game loop and integrating procedural texture generation for walls. My recent work involves calculating ray-wall intersections and mapping those hit points to simple, repeating patterns generated directly in JavaScript.

**Developing Core Loop**

I am refining the main game loop and integrating procedural texture generation for walls. My recent work involves calculating ray-wall intersections and mapping those hit points to simple, repeating patterns generated directly in JavaScript.

**Developing Core Loop**

I am refining the main game loop and integrating procedural texture generation for walls. My recent work involves calculating ray-wall intersections and mapping those hit points to simple, repeating patterns generated directly in JavaScript.

**Developing Core Loop**

I am refining the main game loop and integrating procedural texture generation for walls. My recent work involves calculating ray-wall intersections and mapping those hit points to simple, repeating patterns generated directly in JavaScript.

**Updating Core Rendering**

I am refining the raycasting loop and integrating procedural texture generation. My current work involves accurately calculating wall intersection points and applying dynamically generated repeating patterns to create visual depth and detail for the walls within the single-file constraint.

**Developing Core Raycasting**

I'm refining the raycasting algorithm, focusing on accurate wall intersection detection and distance calculation. My latest efforts involve implementing a robust DDA algorithm and correctly calculating procedural texture coordinates (U, V) for rendering.

**Developing Core Raycasting**

I'm refining the raycasting algorithm, focusing on accurate wall intersection detection and distance calculation. My latest efforts involve implementing a robust DDA algorithm and correctly calculating procedural texture coordinates (U, V) for rendering. I'm also updating the rendering pipeline to incorporate fog and better procedural wall coloring.

**Developing Core Raycasting**

I'm refining the raycasting algorithm, focusing on accurate wall intersection detection and distance calculation. My latest efforts involve implementing a robust DDA algorithm and correctly calculating procedural texture coordinates (U, V) for rendering.

**Developing Core Raycasting**

I'm refining the raycasting algorithm, focusing on accurate wall intersection detection and distance calculation. My latest efforts involve implementing a robust DDA algorithm and correctly calculating procedural texture coordinates (U, V) for rendering.

**Updating Core Rendering**

My focus is on refining the raycasting loop and implementing procedural textures. I am accurately calculating wall intersection points and applying dynamically generated repeating patterns to create visual depth and detail for the walls within the single-file constraint.

 === 0 ? 0.9 : 1.1;
            r *= checker;
            g *= checker;
            b *= checker;

            // Clamp colors to valid range [0, 255]
            r = Math.max(0, Math.min(255, r));
            g = Math.max(0, Math.min(255, g));
            b = Math.max(0, Math.min(255, b));

            return `rgb(${r | 0}, ${g | 0}, ${b | 0})`;
        }

        // --- Raycasting Engine ---
        // Implements the Digital Differential Analyzer (DDA) algorithm to find wall intersections.
        // Returns distance, hit coordinates, tile type, which side was hit, and texture UV coordinates.
        function castRay(rayAngle, rayOriginX, rayOriginY, wallMap) {
            const TWO_PI = 2 * Math.PI;
            const PI_OVER_2 = Math.PI / 2;

            // Normalize ray angle to be within [0, 2*PI)
            rayAngle = rayAngle % TWO_PI;
            if (rayAngle < 0) rayAngle += TWO_PI;

            // Current map coordinates
            let mapX = Math.floor(rayOriginX / MAZE_CELL_SIZE);
            let mapY = Math.floor(rayOriginY / MAZE_CELL_SIZE);

            let side; // 0 for vertical wall (hit vertical grid line), 1 for horizontal (hit horizontal grid line)
            let wallX, wallY; // World coordinates of the precise wall hit

            let deltaDistX, deltaDistY;
            let distToWallX, distToWallY;

            const cosAngle = Math.cos(rayAngle);
            const sinAngle = Math.sin(rayAngle);
            const tanAngle = Math.tan(rayAngle);

            // Calculate distances to cross one cell in X and Y directions
            if (Math.abs(cosAngle) < 1e-6) deltaDistX = Infinity; else deltaDistX = Math.abs(MAZE_CELL_SIZE / cosAngle);
            if (Math.abs(sinAngle) < 1e-6) deltaDistY = Infinity; else deltaDistY = Math.abs(MAZE_CELL_SIZE / sinAngle);

            let stepX, stepY;

            // Calculate initial distances to the first grid lines and determine step direction
            if (cosAngle >= 0) { // Ray going right
                stepX = 1;
                distToWallX = (MAZE_CELL_SIZE - (rayOriginX % MAZE_CELL_SIZE)) / cosAngle;
            } else { // Ray going left
                stepX = -1;
                distToWallX = (rayOriginX % MAZE_CELL_SIZE) / -cosAngle;
            }

            if (sinAngle >= 0) { // Ray going down
                stepY = 1;
                distToWallY = (MAZE_CELL_SIZE - (rayOriginY % MAZE_CELL_SIZE)) / sinAngle;
            } else { // Ray going up
                stepY = -1;
                distToWallY = (rayOriginY % MAZE_CELL_SIZE) / -sinAngle;
            }

            // DDA loop: iteratively step through the grid until a wall is hit or bounds are exceeded.
            let hit = false;
            let tileType = 0;
            const MAX_ITER = 100; // Safety break to prevent infinite loops
            let iter = 0;

            while (!hit && iter < MAX_ITER) {
                // Advance in the direction of the smaller distance to the next grid line.
                if (distToWallX < distToWallY) {
                    distToWallX += deltaDistX;
                    mapX += stepX;
                    side = 0; // Hit a vertical grid line (East/West wall)
                } else {
                    distToWallY += deltaDistY;
                    mapY += stepY;
                    side = 1; // Hit a horizontal grid line (North/South wall)
                }

                // Check if map coordinates are out of bounds.
                if (mapX < 0 || mapX >= MAZE_COLS || mapY < 0 || mapY >= MAZE_ROWS) {
                    break; // Ray went out of bounds.
                }

                // Check if a wall is hit at the current map coordinates.
                if (wallMap[mapY][mapX] !== 0) {
                    hit = true;
                    tileType = wallMap[mapY][mapX];

                    // Calculate the precise world coordinates of the wall hit.
                    if (side === 0) { // Hit a vertical line
                        wallX = mapX * MAZE_CELL_SIZE;
                        wallY = rayOriginY + (wallX - rayOriginX) * tanAngle;
                    } else { // Hit a horizontal line
                        wallY = mapY * MAZE_CELL_SIZE;
                        // Handle case where tanAngle is zero (horizontal ray) to prevent division by zero.
                        if (Math.abs(tanAngle) < 1e-6) { // Ray is horizontal, shouldn't happen if deltaDistX is finite
                             wallX = rayOriginX; // Does not advance in x for vertical movement
                        } else {
                             wallX = rayOriginX + (wallY - rayOriginY) / tanAngle;
                        }
                    }
                    break; // Exit loop once a wall is hit.
                }
                iter++;
            }

            if (hit) {
                // Calculate the actual distance to the wall.
                let distance;
                if (side === 0) distance = distToWallX - deltaDistX; else distance = distToWallY - deltaDistY;

                // Apply fisheye correction to distance.
                distance *= Math.cos(rayAngle - player.angle);

                // Calculate texture UV coordinates.
                let texU, texV; // U: horizontal on texture, V: vertical on texture

                if (side === 0) { // Hit a vertical wall (North/South direction on the map grid)
                    // The V coordinate (vertical on texture) is based on the Y position on the wall.
                    // The U coordinate (horizontal on texture) is based on the X position on the wall.
                    texU = (wallY % MAZE_CELL_SIZE) / MAZE_CELL_SIZE; // Fractional Y position on the wall
                    texV = (wallX % MAZE_CELL_SIZE) / MAZE_CELL_SIZE; // Fractional X position on the wall (determines tiling)
                } else { // Hit a horizontal wall (East/West direction on the map grid)
                    // The U coordinate (horizontal on texture) is based on the X position on the wall.
                    // The V coordinate (vertical on texture) is based on the Y position on the wall.
                    texU = (wallX % MAZE_CELL_SIZE) / MAZE_CELL_SIZE; // Fractional X position on the wall
                    texV = (wallY % MAZE_CELL_SIZE) / MAZE_CELL_SIZE; // Fractional Y position on the wall (determines tiling)
                }

                // Ensure texture coordinates are within the valid range [0, 1].
                texU = Math.max(0, Math.min(1, texU));
                texV = Math.max(0, Math.min(1, texV));

                return { distance, x: wallX, y: wallY, tileType, side, texU, texV };
            }

            return null; // No wall hit within max iterations or bounds.
        }

        // --- Rendering ---
        function render() {
            // Clear canvas with a background color.
            ctx.fillStyle = 'rgb(0,0,0)'; // Black background
            ctx.fillRect(0, 0, CANVAS_WIDTH, CANVAS_HEIGHT);

            // Render Floor and Ceiling with simple procedural gradients.
            const floorColor1 = 'rgb(50,50,50)';
            const floorColor2 = 'rgb(70,70,70)';
            const ceilColor1 = 'rgb(100,100,100)';
            const ceilColor2 = 'rgb(80,80,80)';

            for (let y = 0; y < CANVAS_HEIGHT; y++) {
                for (let x = 0; x < CANVAS_WIDTH; x++) {
                    if (y < CANVAS_HEIGHT / 2) { // Ceiling
                        // Simple gradient from dark to lighter grey.
                        const shade = (y / (CANVAS_HEIGHT / 2)) * 0.7 + 0.1;
                        ctx.fillStyle = `rgb(${100 * shade | 0}, ${100 * shade | 0}, ${100 * shade | 0})`;
                    } else { // Floor
                        // Simple gradient from dark to lighter grey.
                        const shade = ((y - CANVAS_HEIGHT / 2) / (CANVAS_HEIGHT / 2)) * 0.7 + 0.1;
                        ctx.fillStyle = `rgb(${50 * shade | 0}, ${50 * shade | 0}, ${50 * shade | 0})`;
                    }
                    ctx.fillRect(x, y, 1, 1);
                }
            }

            // Raycasting for walls.
            const numRays = CANVAS_WIDTH; // One ray per pixel column.
            const angleStep = player.fov / numRays; // Angle increment for each ray.

            for (let i = 0; i < numRays; i++) {
                // Calculate the angle for the current ray.
                const rayAngle = player.angle - player.fov / 2 + i * angleStep;
                const ray = castRay(rayAngle, player.x, player.y, maze);

                if (ray) {
                    const correctedDistance = ray.distance;

                    // Calculate the height of the wall slice to draw on screen.
                    // This formula projects the world-height (MAZE_CELL_SIZE) onto the screen based on distance.
                    const wallHeightOnScreen = (MAZE_CELL_SIZE * (CANVAS_HEIGHT / 2)) / correctedDistance;

                    const drawStartX = i; // The column index on the canvas for this ray.
                    const drawEndX = i + 1; // The end column index (exclusive).

                    // Calculate the vertical position of the wall slice on screen.
                    const wallTop = (CANVAS_HEIGHT / 2) - wallHeightOnScreen / 2;
                    const wallBottom = wallTop + wallHeightOnScreen;

                    // Clamp the drawing to the screen's vertical bounds.
                    const screenTop = Math.max(0, wallTop);
                    const screenBottom = Math.min(CANVAS_HEIGHT, wallBottom);

                    // Only draw if the wall slice is visible.
                    if (screenBottom > screenTop) {
                        // Get the procedural color for the wall using its type and texture coordinates.
                        const wallColor = getProceduralWallColor(ray.tileType, ray.texU, ray.texV);

                        // Apply basic fog effect based on distance.
                        const fogFactor = 1 - Math.max(0, Math.min(1, correctedDistance / (MAZE_COLS * MAZE_CELL_SIZE * 1.5))); // Max distance for fog.
                        const r = parseInt(wallColor.substring(4, wallColor.indexOf(',')));
                        const g = parseInt(wallColor.substring(wallColor.indexOf(',') + 1, wallColor.lastIndexOf(',')));
                        const b = parseInt(wallColor.substring(wallColor.lastIndexOf(',') + 1, wallColor.length - 1 ));

                        const foggedR = Math.floor(r * fogFactor);
                        const foggedG = Math.floor(g * fogFactor);
                        const foggedB = Math.floor(b * fogFactor);

                        ctx.fillStyle = `rgb(${foggedR}, ${foggedG}, ${foggedB})`;
                        ctx.fillRect(drawStartX, screenTop, drawEndX - drawStartX, screenBottom - screenTop);
                    }
                }
            }
        }

        // --- Game Loop ---
        // Handles player input, updates game state, and triggers rendering.
        function update() {
            // Player Movement (WASD, strafing with A/D).
            let moveX = 0, moveY = 0;
            if (keys['w']) {
                moveX += player.moveSpeed * Math.cos(player.angle);
                moveY += player.moveSpeed * Math.sin(player.angle);
            }
            if (keys['s']) {
                moveX -= player.moveSpeed * Math.cos(player.angle);
                moveY -= player.moveSpeed * Math.sin(player.angle);
            }
            // Strafing left (A) and right (D) - perpendicular to player's facing direction.
            if (keys['a']) {
                moveX -= player.moveSpeed * Math.cos(player.angle - Math.PI / 2);
                moveY -= player.moveSpeed * Math.sin(player.angle - Math.PI / 2);
            }
            if (keys['d']) {
                moveX += player.moveSpeed * Math.cos(player.angle - Math.PI / 2);
                moveY += player.moveSpeed * Math.sin(player.angle - Math.PI / 2);
            }

            // Collision Detection: Basic check against maze walls.
            const newPlayerX = player.x + moveX;
            const newPlayerY = player.y + moveY;

            const currentCellX = Math.floor(player.x / MAZE_CELL_SIZE);
            const currentCellY = Math.floor(player.y / MAZE_CELL_SIZE);
            const nextCellX = Math.floor(newPlayerX / MAZE_CELL_SIZE);
            const nextCellY = Math.floor(newPlayerY / MAZE_CELL_SIZE);

            // Check if the next cell is within bounds and not a wall.
            if (nextCellX >= 0 && nextCellX < MAZE_COLS && nextCellY >= 0 && nextCellY < MAZE_ROWS) {
                if (maze[nextCellY][nextCellX] === 0) { // If it's an empty cell, allow movement.
                    player.x = newPlayerX;
                    player.y = newPlayerY;
                } else {
                    // Collision with a wall. Try to slide along it.
                    // If moved more horizontally and hit a vertical wall: allow horizontal movement.
                    if (Math.abs(moveX) > Math.abs(moveY) && maze[currentCellY][nextCellX] === 0) {
                        player.x = newPlayerX;
                    }
                    // If moved more vertically and hit a horizontal wall: allow vertical movement.
                    else if (Math.abs(moveY) > Math.abs(moveX) && maze[nextCellY][currentCellX] === 0) {
                        player.y = newPlayerY;
                    }
                    // If neither sliding condition met, movement is blocked.
                }
            } else {
                // Attempted to move out of bounds - effectively blocked.
            }

            // Player Rotation (Arrow Keys).
            if (keys['arrowleft']) {
                player.angle -= player.rotSpeed;
            }
            if (keys['arrowright']) {
                player.angle += player.rotSpeed;
            }

            // Normalize player angle to stay within [0, 2*PI).
            player.angle = player.angle % (2 * Math.PI);
            if (player.angle < 0) player.angle += 2 * Math.PI;

            // Trigger rendering for the current frame.
            render();

            // Request the next animation frame.
            requestAnimationFrame(update);
        }

        // --- Start Game ---
        // Initialize canvas size and start the game loop.
        canvas.width = CANVAS_WIDTH;
        canvas.height = CANVAS_HEIGHT;
        update(); // Start the animation loop.

    </script>
</body>
</html>
```<header>
**Refining Texture Mapping**

I'm currently refining how procedural textures are mapped onto the rendered walls. My focus is on accurately calculating the UV coordinates based on ray intersection points, ensuring patterns align correctly and dynamically generated textures provide visual depth.

**Developing Core Raycasting**

I'm refining the raycasting algorithm, focusing on accurate wall intersection detection and distance calculation. My latest efforts involve implementing a robust DDA algorithm and correctly calculating procedural texture coordinates (U, V) for rendering.

**Updating Core Rendering**

My focus is on refining the raycasting loop and implementing procedural textures. I am accurately calculating wall intersection points and applying dynamically generated repeating patterns to create visual depth and detail for the walls within the single-file constraint.

**Developing Core Raycasting**

I'm refining the raycasting algorithm, focusing on accurate wall intersection detection and distance calculation. My latest efforts involve implementing a robust DDA algorithm and correctly calculating procedural texture coordinates (U, V) for rendering.

**Updating Core Rendering**

My current focus is on refining the raycasting loop and implementing procedural textures. I'm working on generating repeating wall patterns directly in JavaScript to meet the single-file constraint.

**Refining Texture Mapping**

I'm now focused on accurately mapping procedurally generated textures onto the walls. My latest work involves calculating precise UV coordinates based on ray intersection points to ensure patterns align correctly and provide visual depth, all within the single-file constraint.

**Refining Texture Mapping**

I'm now focused on accurately mapping procedurally generated textures onto the walls. My latest work involves calculating precise UV coordinates based on ray intersection points to ensure patterns align correctly and provide visual depth, all within the single-file constraint.

**Developing Core Raycasting**

I'm refining the raycasting algorithm, focusing on accurate wall intersection detection and distance calculation. My latest efforts involve implementing a robust DDA algorithm and correctly calculating procedural texture coordinates (U, V) for rendering.

**Developing Core Raycasting**

I'm refining the raycasting algorithm, focusing on accurate wall intersection detection and distance calculation. My latest efforts involve implementing a robust DDA algorithm and correctly calculating procedural texture coordinates (U, V) for rendering.

**Developing Raycasting Core**

I'm refining the raycasting algorithm, focusing on accurate wall intersection detection and distance calculation. My latest efforts involve implementing a robust DDA algorithm and correctly calculating procedural texture coordinates (U, V) for rendering.

**Refining Texture Mapping**

I'm currently refining how procedural textures are mapped onto the rendered walls. My focus is on accurately calculating the UV coordinates based on ray intersection points, ensuring patterns align correctly and dynamically generated textures provide visual depth.

**Developing Raycasting Logic**

I'm refining the core raycasting algorithm, focusing on accurate wall intersection detection and distance calculation. My latest efforts involve implementing a robust DDA algorithm and correctly calculating procedural texture coordinates (U, V) for rendering.

**Developing Raycasting Core**

I'm refining the raycasting algorithm, focusing on accurate wall intersection detection and distance calculation. My latest efforts involve implementing a robust DDA algorithm and correctly calculating procedural texture coordinates (U, V) for rendering.

**Refining Texture Mapping**

I'm now focused on accurately mapping procedurally generated textures onto the walls. My latest work involves calculating precise UV coordinates based on ray intersection points to ensure patterns align correctly and provide visual depth, all within the single-file constraint.

**Refining Texture Mapping**

I'm now focused on accurately mapping procedurally generated textures onto the walls. My latest work involves calculating precise UV coordinates based on ray intersection points to ensure patterns align correctly and provide visual depth, all within the single-file constraint.

**Refining Texture Mapping**

I'm now focused on accurately mapping procedurally generated textures onto the walls. My latest work involves calculating precise UV coordinates based on ray intersection points to ensure patterns align correctly and provide visual depth, all within the single-file constraint.

**Refining Texture Mapping**

I'm currently refining how procedural textures are mapped onto the rendered walls. My focus is on accurately calculating the UV coordinates based on ray intersection points, ensuring patterns align correctly and dynamically generated textures provide visual depth.

**Refining Texture Mapping**

I'm currently refining how procedural textures are mapped onto the rendered walls. My focus is on accurately calculating the UV coordinates based on ray intersection points, ensuring patterns align correctly and dynamically generated textures provide visual depth.

**Updating Core Rendering**

My current focus is on refining the raycasting loop and implementing procedural textures. I am accurately calculating wall intersection points and applying dynamically generated repeating patterns to create visual depth and detail for the walls within the single-file constraint.

**Refining Texture Mapping**

I'm now focused on accurately mapping procedurally generated textures onto the walls. My latest work involves calculating precise UV coordinates based on ray intersection points to ensure patterns align correctly and provide visual depth, all within the single-file constraint.

**Refining Texture Mapping**

I'm currently refining how procedural textures are mapped onto the rendered walls. My focus is on accurately calculating the UV coordinates based on ray intersection points, ensuring patterns align correctly and dynamically generated textures provide visual depth.

**Developing Core Raycasting**

I'm refining the raycasting algorithm, focusing on accurate wall intersection detection and distance calculation. My latest efforts involve implementing a robust DDA algorithm and correctly calculating procedural texture coordinates (U, V) for rendering.

**Updating Core Rendering**

My current focus is on refining the raycasting loop and implementing procedural textures. I am accurately calculating wall intersection points and applying dynamically generated repeating patterns to create visual depth and detail for the walls within the single-file constraint.