Raycaster.z

        /////////////////////////////////////////////////////
        /////// Raycasting Engine Script, version 0.2 ///////
        /////// by blue_knight						  ///////
        /////////////////////////////////////////////////////
        /////////////////////////////////////////////////////
        // This is a fun little script
        // that renders the current screens in first person
        // using raycasting and column rendering.
        // X, Y is on the horizontal plane.
        // Z is up in 3D space.
        // This script has no set limits, except the map limit
        // 16x8 screens.
        /////////////////////////////////////////////////////

        const int scrWidth  = 256;
        const int scrHeight = 176;

        ffc script Raycaster
        {
        	/////////////////////////////
        	// startX     : start X position in virtual space.
        	// startY     : start Y position in virtual space.
        	// BackgroundTiles : Tile index for the background.
        	/////////////////////////////
        	void run(int startX, int startY, int BackgroundTiles)
        	{
        		//use virtual coordinates for Link's position.
        		//since he is not displayed, we don't bother keeping local coordinates, so Link's position is forced to the center.
        		float camPos_X = startX;
        		float camPos_Y = startY;
        		float camDir_X;
        		float camDir_Y;
        		float camYaw = 0;
        		float moveSpeed = 1.0;
        		float playerRadius = 16;
        		
        		//ginormous array...
        		int map_combo[1024];	//holds the 32x32 area centered on the camera.
        		int map_left_x=0;
        		int map_left_y=0;
        		
        		int map_cenX = 0;
        		int map_cenY = 0;
        		
        		int curScreen = Game->GetCurScreen();
        		int curMap = Game->GetCurMap();
        	
        		while (true)
        		{
        			//update the movement.
        			if ( Link->InputLeft )
        				camYaw-=2;
        			else if ( Link->InputRight )
        				camYaw+=2;
        				
        			if (camYaw < 0 )
        				camYaw += 360;
        			else if ( camYaw >= 360 )
        				camYaw -= 360;
        			
        			camDir_X = Cos(camYaw);
        			camDir_Y = Sin(camYaw);
        			
        			float newPosX = camPos_X;
        			float newPosY = camPos_Y;
        			float travelDirX;
        			float travelDirY;
        			bool bCollisionNeeded = false;
        			if ( Link->InputUp )
        			{
        				newPosX = newPosX + camDir_X*moveSpeed;
        				newPosY = newPosY + camDir_Y*moveSpeed;
        				bCollisionNeeded = true;
        				
        				travelDirX = camDir_X;
        				travelDirY = camDir_Y;
        			}
        			else if ( Link->InputDown )
        			{
        				newPosX = newPosX - camDir_X*moveSpeed;
        				newPosY = newPosY - camDir_Y*moveSpeed;
        				bCollisionNeeded = true;
        				
        				travelDirX = -camDir_X;
        				travelDirY = -camDir_Y;
        			}
        			
        			//Super basic collision for now.
        			//If we're intersecting a solid combo after moving, we revert the move.
        			//note that we actually check ahead in the direction of travel so we don't get too close to
        			//the wall.
        			if ( bCollisionNeeded )
        			{
        				if ( ComboSolid( Floor(newPosX+travelDirX*playerRadius), Floor(newPosY+travelDirY*playerRadius), curMap, curScreen ) )
        				{
        					newPosX = camPos_X;
        					newPosY = camPos_Y;
        				}
        			}
        			camPos_X = newPosX;
        			camPos_Y = newPosY;
        			
        			//Read the area around the camera into an array
        			//whenever we change cells.
        			//This way we don't have to call GetComboFromTileIndex() or Game->GetComboData()
        			//up to 16 times per ray.
        			//This improves our performance by 40% or more.
        			int mx = camPos_X>>4;
        			int my = camPos_Y>>4;
        			if ( mx != map_cenX || my != map_cenY )
        			{
        				map_cenX = mx;
        				map_cenY = my;
        				map_left_x = Max(mx-16,0);
        				map_left_y = Max(my-16,0);
        				for (int y=0; y<32; y++)
        				{
        					int yy = y+map_left_y;
        					for (int x=0; x<32; x++)
        					{
        						int xx = x+map_left_x;
        						map_combo[y*32+x] = GetComboFromTileIndex(xx, yy, curMap, curScreen);
        					}
        				}
        			}
        			
        			//Finally draw the world.
        			DrawWorld( camDir_X, camDir_Y, camPos_X, camPos_Y, BackgroundTiles, map_combo, map_left_x, map_left_y );
        			
        			DisableInput();
        			
        			Waitframe();
        		}
        	}
        	
        	void DisableInput()
        	{
        		Link->X = 128;
        		Link->Y = 88;
        		Link->InputLeft = false;
        		Link->InputRight = false;
        		Link->InputUp = false;
        		Link->InputDown = false;
        		Link->InputA = false;
        		Link->InputB = false;
        		Link->InputL = false;
        		Link->InputR = false;
        		Link->InputStart = false;
        		Link->InputEx1 = false;
        		Link->InputEx2 = false;
        		Link->InputEx3 = false;
        		Link->InputEx4 = false;
        	}
        	
        	bool ComboSolid(int x, int y, int map, int curScr)
        	{
        		bool solid = false;
        		
        		int cx = (x>>4)&15;
        		int cy = (y>>4)%11;
        		
        		int scr = curScr;
        		scr += ( x>>8 );
        		scr += ( Floor(y/176)<<4 );
        		
        		int s = Game->GetComboSolid( map, scr, (cy<<4)+cx );
        		if ( s != 0 )
        			solid = true;
        			
        		return solid;
        	}
        	
        	int GetComboFromTileIndex(int tx, int ty, int map, int curScr)
        	{
        		int cx = tx&15;
        		int cy = ty%11;
        		
        		int scr = curScr;
        		scr += ( tx>>4 );
        		scr += ( Floor(ty/11)<<4 );
        		
        		return Game->GetComboData( map, scr, (cy<<4)+cx );
        	}
        		
        	//draw the "3D" world.
        	void DrawWorld(float camDirX, float camDirY, float cX, float cY, int BackgroundTiles, int map_combo, int map_left_x, int map_left_y)
        	{
        		float cenY = scrHeight*0.5;
        		
        		//This camera has no pitch, though looking up and down can be faked later.
        		//Anyway, the camera plane is perpendicular to the camera direction, 
        		//so a simple 2D "perp product" is good enough [i.e. P(x,y) = (-Dy,Dx)]
        		float planeX = -camDirY;
        		float planeY =  camDirX;
        				
        		//we do raycasting in "map space", where each tile = 1 unit.
        		float camX = cX/16;
        		float camY = cY/16;
        		
        		int mapX = Floor(camX);
        		int mapY = Floor(camY);
        		
        		//maximum extents, 8x8 screens for now.
        		int maxTileX = map_left_x+32;
        		int maxTileY = map_left_y+32;
        		
        		//maximum number of raycasting steps. Setting this lower
        		//will improve performance, setting it higher allows more distant walls to be rendered.
        		int MAX_STEPS = 16;
        		
        		//Draw the background.
        		Screen->DrawTile(1, 0, 0, BackgroundTiles, 1, 11, 0, 256, 176, 0, 0, 0, 0, false, 128);
        				
        		//Note that we're pixel doubling for performance, later this should be an option
        		//for people with fast computers.
        		for (int x=0; x<scrWidth; x+=2)
        		{
        			int mx = mapX;
        			int my = mapY;
        			
        			//compute the screen ray from the x position and camera paramters.
        			float sx = (2 * x/scrWidth) - 1;
        			float rayDirX = camDirX + planeX*sx;
        			float rayDirY = camDirY + planeY*sx;
        			
        			//compute the DDA parameters, will detail in some documentation later.
        			float rXX = rayDirX*rayDirX;
        			float rYY = rayDirY*rayDirY;
        			
        			float deltaDistX = 32767;
        			float deltaDistY = 32767;
        			if ( rXX != 0 ) deltaDistX = Sqrt( 1.0 + rYY/rXX );
        			if ( rYY != 0 ) deltaDistY = Sqrt( 1.0 + rXX/rYY );
        		
        			int stepX;
        			int stepY;
        			float sideDistX;
        			float sideDistY;
        			if ( rayDirX < 0 )
        			{ stepX = -1; sideDistX = (camX - mx) * deltaDistX; }
        			else
        			{ stepX = 1; sideDistX = (mx + 1.0 - camX)*deltaDistX; }
        			
        			if ( rayDirY < 0 )
        			{ stepY = -1; sideDistY = (camY - my)*deltaDistY; }
        			else
        			{ stepY = 1; sideDistY = (my + 1.0 - camY)*deltaDistY; }
        			
        			//now that we have the DDA parameters, actually walk the ray and find the closest intersecting wall.
        			int hit = 0;
        			int iter = 0;
        			int side;
        			while (hit == 0 && iter < MAX_STEPS)
        			{
        				if ( sideDistX < sideDistY )
        				{
        					sideDistX += deltaDistX;
        					mx += stepX;
        					side = 0;
        					if ( mx < map_left_x || mx >= maxTileX )
        						break;
        				}
        				else
        				{
        					sideDistY += deltaDistY;
        					my += stepY;
        					side = 1;
        					if ( my < map_left_y || my >= maxTileY )
        						break;
        				}
        				hit = map_combo[ ((my-map_left_y)<<5)+(mx-map_left_x) ];
        				iter++;
        			}
        			
        			//if we've hit something we figure out the column to render.
        			if ( hit )
        			{
        				float wallDist;
        				int u;
        				//compute the distance to the wall and the texture coordinate.
        				if ( side == 0 )
        				{
        					wallDist = (mx - camX + (1 - stepX)*0.5 ) / rayDirX;
        					u = camY + rayDirY*wallDist;
        				}
        				else
        				{
        					wallDist = (my - camY + (1 - stepY)*0.5 ) / rayDirY;
        					u = camX + rayDirX*wallDist;
        				}
        				//we use 16x16 tiles for textures.
        				u = Floor( u*16 )&15;
        				
        				//compute the wall height.
        				wallDist = Abs(wallDist);
        				float height = 256.0 / wallDist;
        				
        				//compute the column dimensions.
        				int y0 = Floor(cenY - height*0.5);
        				int y1 = Floor(cenY + height*0.5);
        				
        				if ( y0 < -96 ) y0 = -96;
        				if ( y1 > 240 ) y1 = 240;
        				
        				//shading depends on the "side" (so some faces are darker then others)
        				//and the distance.
        				int shading = Floor(wallDist/2) + side;
        				if ( shading > 7 ) shading = 7;
        				//textures are hard to author for this, but we compute the final tile we need for this column based on
        				//the texture coordinate and shading.
        				int tile = Game->ComboTile(hit) + u+(shading*20);

        				//Quad() doesn't work well here, but DrawTile() does since we're rendering a screen aligned quad.
        				Screen->DrawTile(1, x, y0, tile, 1, 1, 0, 2, (y1-y0), 0, 0, 0, 0, false, 128);
        			}
        		}
        	}
        }