Coding Rays

Many ray casters, at least from the articles I have read on the subject, find where the ray intersects horizontal and vertical grid lines and uses those intersections to determine which wall the ray hit. My ray caster uses a slightly different approach. It figures out how far each step of a ray would be to reach the next horizontal or vertical line. It then steps using the intersection that would happen sooner.

protected function performCast(
playerX:Number,
playerY:Number,
playerD:Number)
{
var degreesToSlices:Number = playerD * _slicesInCircle / 360
var angle:Number = (degreesToSlices - _displayWidth / 2) * _sliceSize;
// var angle:Number = (playerD - 45) * _sliceSize; // todo - make proper
var startTileX:int = int(playerX);
var startTileY:int = int(playerY);
var tileX:int, tileY:int, tileIndex;
var tileStepX:int, tileStepY:int;
var stepX:Number, stepY:Number;
var stepSizeX:Number, stepSizeY:Number;
var distanceX:Number, distanceY:Number, distance:Number;

for (var cntr:int = 0; cntr < _displayWidth; ++cntr)
{
tileX = startTileX;
tileY = startTileY;
tileIndex = startTileY * _mapsize + startTileX;

// first, find the size of each step and the distance to the first step
stepX = Math.sin(angle);
if (stepX == 0) {
stepSizeX = 10000000; // big number
tileStepX = 1; // shouldn't matter
distanceX = stepSizeX;
} else if (stepX < 0) {
stepSizeX = -1/stepX;
tileStepX = -1;
distanceX = (playerX - Number(startTileX)) * stepSizeX;
} else {
stepSizeX = 1/stepX;
tileStepX = 1;
distanceX = (Number(startTileX+1) - playerX) * stepSizeX;
}
stepY = -Math.cos(angle);
if (stepY == 0) {
stepSizeY = 10000000; // big number
tileStepY = -1;
distanceY = stepSizeY;
} else if (stepY < 0) {
stepSizeY = -1/stepY;
tileStepY = -1;
distanceY = (playerY - Number(startTileY)) * stepSizeY;
} else {
stepSizeY = 1/stepY;
tileStepY = 1; // y is the big step
distanceY = (Number(startTileY+1) - playerY) * stepSizeY;
}

// now keep stepping through tiles until we hit a wall
do {
if (distanceX < distanceY) {
tileX += tileStepX;
tileIndex += tileStepX;
distance = distanceX;
distanceX += stepSizeX;
} else {
tileY += tileStepY;
tileIndex += (tileStepY * _mapsize);
distance = distanceY;
distanceY += stepSizeY;
}
} while (_map[tileIndex] < 4);
_castTileX[cntr] = tileX;
_castTileY[cntr] = tileY;
_castDistance[cntr] = distance;

_castHitX[cntr] = playerX + distance * stepX;
_castHitY[cntr] = playerY + distance * stepY;

// make sure we have next angle
angle += _sliceSize;
}
}