Yes — you’re talking about the DDA (Digital Differential Analyzer) algorithm, which is the standard way to do fast 2D grid ray casting for Wolfenstein-style engines.

The idea: instead of stepping pixel by pixel, you compute how far you need to go to reach the next vertical or next horizontal grid line, then keep stepping grid-by-grid until you hit a wall.

Here’s a compact JavaScript implementation outline:

js
Copy code
// grid: 2D array of 0 = empty, 1 = wall
// posX, posY: player position in map coords (floats, tile units)
// dirX, dirY: ray direction (normalized vector)
// maxDist: optional cutoff distance
function castRay(grid, posX, posY, dirX, dirY, maxDist = 100) {
  const mapWidth  = grid[0].length;
  const mapHeight = grid.length;

  // Current map square
  let mapX = Math.floor(posX);
  let mapY = Math.floor(posY);

  // Length of ray from one x or y-side to next x or y-side
  const deltaDistX = Math.abs(1 / dirX);
  const deltaDistY = Math.abs(1 / dirY);

  // Step direction (+1 or -1) and initial sideDist
  let stepX, stepY;
  let sideDistX, sideDistY;

  if (dirX < 0) {
    stepX = -1;
    sideDistX = (posX - mapX) * deltaDistX;
  } else {
    stepX = 1;
    sideDistX = (mapX + 1.0 - posX) * deltaDistX;
  }

  if (dirY < 0) {
    stepY = -1;
    sideDistY = (posY - mapY) * deltaDistY;
  } else {
    stepY = 1;
    sideDistY = (mapY + 1.0 - posY) * deltaDistY;
  }

  let hit = false;
  let side = 0; // 0 = hit x-side, 1 = hit y-side

  // DDA loop
  while (!hit) {
    if (sideDistX < sideDistY) {
      sideDistX += deltaDistX;
      mapX += stepX;
      side = 0;
    } else {
      sideDistY += deltaDistY;
      mapY += stepY;
      side = 1;
    }

    // Check for out of bounds
    if (mapX < 0 || mapX >= mapWidth || mapY < 0 || mapY >= mapHeight) {
      return null; // no hit
    }

    // Check if ray hit a wall
    if (grid[mapY][mapX] > 0) hit = true;
    if (Math.min(sideDistX, sideDistY) > maxDist) return null;
  }

  // Calculate distance to wall
  let perpWallDist;
  if (side === 0) {
    perpWallDist = (mapX - posX + (1 - stepX) / 2) / dirX;
  } else {
    perpWallDist = (mapY - posY + (1 - stepY) / 2) / dirY;
  }

  // Where on the wall did we hit? (texture coordinate)
  let wallX;
  if (side === 0) {
    wallX = posY + perpWallDist * dirY;
  } else {
    wallX = posX + perpWallDist * dirX;
  }
  wallX -= Math.floor(wallX); // fractional part only [0..1)

  return {
    mapX, mapY,         // tile coords
    side,               // hit vertical or horizontal wall
    distance: perpWallDist,
    textureX: wallX     // use this to index into texture
  };
}

Key points:

• DDA stepping means you only move to the next grid line each time → very fast.

• side tells you if you hit a vertical or horizontal wall (so you can darken one side for fake lighting).

• textureX gives you the fractional offset into the wall tile (for correct texture mapping).

👉 Then in your renderer, for each vertical screen stripe:

1. Compute the ray direction from the camera plane.

2. Call castRay.

3. Use distance to determine column height.

4. Use textureX to select the right column from your texture.

Do you want me to also show you how to set up the main loop that casts all rays for the screen (like Wolfenstein’s projection plane math), or are you mainly looking for just the DDA core?