raycaster

package
{
    import flash.display.Shape;
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.events.KeyboardEvent;
    import flash.geom.ColorTransform;
    import flash.text.TextField;
    import flash.utils.getTimer;
    import flash.display.StageQuality;

    public class Main extends Sprite
    {
        public var mapWidth:int = 24;
        public var mapHeight:int = 24;

        public var worldMap:Array = [
            [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],
            [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],
            [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],
            [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],
            [1,0,0,0,0,0,2,2,2,2,2,0,0,0,0,3,0,3,0,3,0,0,0,1],
            [1,0,0,0,0,0,2,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,1],
            [1,0,0,0,0,0,2,0,0,0,2,0,0,0,0,3,0,0,0,3,0,0,0,1],
            [1,0,0,0,0,0,2,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,1],
            [1,0,0,0,0,0,2,2,0,2,2,0,0,0,0,3,0,3,0,3,0,0,0,1],
            [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],
            [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],
            [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],
            [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],
            [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],
            [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],
            [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],
            [1,4,4,4,4,4,4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],
            [1,4,0,4,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],
            [1,4,0,0,0,0,5,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],
            [1,4,0,4,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],
            [1,4,0,4,4,4,4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],
            [1,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],
            [1,4,4,4,4,4,4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],
            [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]
        ];

        //starting x and y positions
        public var posX:Number = 22;
        public var posY:Number = 12;

        //initial direction vector
        public var dirX:Number = -1;
        public var dirY:Number = 0;

        //2d raycaster version of the camera plane
        public var planeX:Number = 0;
        public var planeY:Number = 0.66;

        //time it takes to process each frame
        public var time:Number = 0;
        public var oldTime:Number = 0;

        //set size to 512x384
        [SWF(backgroundColor = "0x000000" , widthPercent = "50" , heightPercent = "50")]

        //keyboard booleans
        public var left:Boolean = false;
        public var right:Boolean = false;
        public var up:Boolean = false;
        public var down:Boolean = false;

        //fps counter
        public var fps:TextField = new TextField();

        //verticle line for drawing
        public var verLine:Sprite = new Sprite();

        public function Main():void
        {
            stage.frameRate = 60;
            stage.quality = StageQuality.LOW;

            stage.addEventListener(Event.ENTER_FRAME, update);
            stage.addEventListener(KeyboardEvent.KEY_DOWN, keyDown);
            stage.addEventListener(KeyboardEvent.KEY_UP, keyUp);

            addChild(fps); //FPS counter
            addChild(verLine);
        }

        public function update(e:Event):void
        {
            for(var x:Number = 0; x < stage.stageWidth; x++)
            {
                //calculate ray position and direction
                var cameraX:Number = 2 * x / Number(stage.stageWidth) - 1; //x-coordinate in camera space
                var rayPosX:Number = posX;
                var rayPosY:Number = posY;
                var rayDirX:Number = dirX + planeX * cameraX;
                var rayDirY:Number = dirY + planeY * cameraX;

                //which box of the map we're in
                var mapX:int = int(rayPosX);
                var mapY:int = int(rayPosY);

                //length of ray from current position to next x or y-side
                var sideDistX:Number;
                var sideDistY:Number;

                //length of ray from one x or y-side to next x or y-side
                var deltaDistX:Number = Math.sqrt(1 + (rayDirY * rayDirY) / (rayDirX * rayDirX));
                var deltaDistY:Number = Math.sqrt(1 + (rayDirX * rayDirX) / (rayDirY * rayDirY));
                var perpWallDist:Number;

                //what direction to step in x or y-direction (either +1 or -1)
                var stepX:int;
                var stepY:int;

                var hit:int = 0; //was there a wall hit?
                var side:int; //was a NS or a EW wall hit?

                //calculate step and initial sideDist
                if (rayDirX < 0)
                {
                    stepX = -1;
                    sideDistX = (rayPosX - mapX) * deltaDistX;
                }
                else
                {
                    stepX = 1;
                    sideDistX = (mapX + 1.0 - rayPosX) * deltaDistX;
                }

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

                //perform DDA
                while (hit == 0)
                {
                    //jump to next map square, OR in x-direction, OR in y-direction
                    if (sideDistX < sideDistY)
                    {
                        sideDistX += deltaDistX;
                        mapX += stepX;
                        side = 0;
                    }
                    else
                    {
                        sideDistY += deltaDistY;
                        mapY += stepY;
                        side = 1;
                    }

                    //Check if ray has hit a wall
                    if (worldMap[mapX][mapY] > 0)
                    {
                        hit = 1;
                    }
                }

                //Calculate distance projected on camera direction (oblique distance will give fisheye effect!)
                if (side == 0)
                {
                    perpWallDist = Math.abs((mapX - rayPosX + (1 - stepX) / 2) / rayDirX);
                }
                else
                {
                    perpWallDist = Math.abs((mapY - rayPosY + (1 - stepY) / 2) / rayDirY);
                }

                //Calculate height of line to draw on screen
                var lineHeight:int = Math.abs(int(stage.stageHeight / perpWallDist));

                //calculate lowest and highest pixel to fill in current stripe
                var drawStart:int = -lineHeight / 2 + stage.stageHeight / 2;

                if (drawStart < 0)
                {
                    drawStart = 0;
                }

                var drawEnd:int = lineHeight / 2 + stage.stageHeight / 2;

                if (drawEnd >= stage.stageHeight)
                {
                    drawEnd = stage.stageHeight - 1;
                }

                //choose wall color
                var colour:ColorTransform = this.transform.colorTransform;
                switch(worldMap[mapX][mapY])
                {
                    case 1:  colour.color = 0xFF0000; break; //red
                    case 2:  colour.color = 0x0000FF; break; //green
                    case 3:  colour.color = 0x00FF00; break; //blue
                    case 4:  colour.color = 0xFFFFFF; break; //white
                    default: colour.color = 0xFFFF00; break; //yellow
                }

                //give x and y sides different brightness
                if (side == 1)
                {
                    colour.color = colour.color / 2;
                }

                //draw the pixels of the stripe as a vertical line
                verLine.graphics.lineStyle(1, colour.color, 1);
                verLine.graphics.moveTo(x, drawStart);
                verLine.graphics.lineTo(x, drawEnd);

                //timing for input and FPS counter
                oldTime = time;
                time = getTimer();
                var frameTime:Number = (time - oldTime) / 1000.0; //frameTime is the time this frame has taken, in seconds
                fps.text = ("" + 1.0 / frameTime);
                //redraw();
                //cls();

                //speed modifiers
                var moveSpeed:Number = frameTime * 5.0; //the constant value is in squares/second
                var rotSpeed:Number = frameTime * 3.0; //the constant value is in radians/second

                //move forward if no wall in front of you
                if (up)
                {
                    if(worldMap[int(posX + dirX * moveSpeed)][int(posY)] == false) {posX += dirX * moveSpeed;}
                    if(worldMap[int(posX)][int(posY + dirY * moveSpeed)] == false) {posY += dirY * moveSpeed;}
                }

                 //move backwards if no wall behind you
                if (down)
                {
                    if(worldMap[int(posX - dirX * moveSpeed)][int(posY)] == false) {posX -= dirX * moveSpeed;}
                    if(worldMap[int(posX)][int(posY - dirY * moveSpeed)] == false) {posY -= dirY * moveSpeed;}
                }

                //rotate to the right
                if (right)
                {
                    //both camera direction and camera plane must be rotated
                    var oldDirX:Number = dirX;
                    dirX = dirX * Math.cos(-rotSpeed) - dirY * Math.sin(-rotSpeed);
                    dirY = oldDirX * Math.sin(-rotSpeed) + dirY * Math.cos(-rotSpeed);
                    var oldPlaneX:Number = planeX;
                    planeX = planeX * Math.cos(-rotSpeed) - planeY * Math.sin(-rotSpeed);
                    planeY = oldPlaneX * Math.sin(-rotSpeed) + planeY * Math.cos(-rotSpeed);
                }

                //rotate to the left
                if (left)
                {
                    //both camera direction and camera plane must be rotated
                    oldDirX = dirX;
                    dirX = dirX * Math.cos(rotSpeed) - dirY * Math.sin(rotSpeed);
                    dirY = oldDirX * Math.sin(rotSpeed) + dirY * Math.cos(rotSpeed);
                    oldPlaneX = planeX;
                    planeX = planeX * Math.cos(rotSpeed) - planeY * Math.sin(rotSpeed);
                    planeY = oldPlaneX * Math.sin(rotSpeed) + planeY * Math.cos(rotSpeed);
                }
            }
        }

            public function keyDown(e:KeyboardEvent):void
            {
                if (e.keyCode == 37)
                {
                    left = true;
                }
                if (e.keyCode == 38)
                {
                    up = true;
                }
                if (e.keyCode == 39)
                {
                    right = true;
                }
                if (e.keyCode == 40)
                {
                    down = true;
                }
            }

            public function keyUp(e:KeyboardEvent):void
            {
                if (e.keyCode == 37)
                {
                    left = false;
                }
                if (e.keyCode == 38)
                {
                    up = false;
                }
                if (e.keyCode == 39)
                {
                    right = false;
                }
                if (e.keyCode == 40)
                {
                    down = false;
                }
            }
        }
    }