/* Raycasting renderer 12.0, by Stijn 
   http://www.jazz2online.com/snippets/182/raycasting-renderer/ */

//raycast rendering for jazz jackrabbit 2 + (https://jj2.plus)
//by stijn, 2023 (https://www.jazz2online.com)
#pragma name "Raycasting renderer"

// field of view
float fov = TWO_PI / 6;  // 60 degrees

// initial direction of the player
float angle = 0;

// speed at which the player can rotate
float turnSpeed = 0.01;

// speed at which the player can move
float moveSpeed = 2.0;

// ray precision (1.0 = pixel perfect, higher=worse)
float stepPrecision = 1.0;

// max distance for a ray (bigger is slower in large levels)
float maxDistance = 1250;
float maxWallHeight = 100.0;

// minimap scale, e.g. 16 = 1/16 scale
int minimapScale = 16;

// these are just constants and assorted things we'll use later, don't change
int wMap = 0;
int hMap = 0;
float planeDistance;
bool playerInit = false;
bool levelInit = false;
float turnX = 0.0;
float turnY = 0.0;
float xMap = 0.0;
float yMap = 0.0;

const int KEY_W = 87;
const int KEY_A = 65;
const int KEY_S = 83;
const int KEY_D = 68;
const int KEY_UP = 38;
const int KEY_DOWN = 40;
const int KEY_LEFT = 37;
const int KEY_RIGHT = 39;
const int KEY_M = 77;
const float PI = 3.14159;
const float HALF_PI = PI / 2;
const float TWO_PI = 6.28318;
bool showMinimap = true;
jjPIXELMAP@ minimap;
int keyDecay = 0;

float max(float one, float two) { return (one > two) ? one : two; }
float min(float one, float two) { return (one < two) ? one : two; }

// we're not controlling the rabbit this time, so keep it fixed in place
void onPlayer(jjPLAYER@ player) {
	if(!playerInit) {
		xMap = player.xPos;
		yMap = player.yPos;
		playerInit = true;
	}
	
	player.xSpeed = 0;
	player.ySpeed = 0;
	player.xPos = 0;
	player.yPos = 0;
	player.frozen = 1;
}

// in onMain, we handle set-up and movement controls
void onMain() {
	if(keyDecay > 0) {
		keyDecay -= 1;
	}
	
	if(!levelInit) {
		// determine map size in pixels
		hMap = jjLayers[4].height * 32;
		wMap = jjLayers[4].width * 32;
		
		// how far is the player from the 'projection screen'?
		planeDistance = float(jjResolutionWidth) / 2.0 / tan(fov / 2.0);
		
		// initialise minimap as top-down view of the map, scaled
		@minimap = jjPIXELMAP(wMap / minimapScale, hMap / minimapScale);
		int mmX = 0;
		int mmY = 0;
		for(int y = 0; y < hMap; y += minimapScale) {
			for(int x = 0; x < wMap; x += minimapScale) {
				if(jjMaskedPixel(x, y)) {
					minimap[mmX, mmY] = 16;
				} else {
					minimap[mmX, mmY] = 22;
				}		
				mmX += 1;
			}
			mmY += 1;
			mmX = 0;
		}
		
		minimap.save(jjAnimFrames[jjAnimations[jjAnimSets[ANIM::CUSTOM[0]].firstAnim].firstFrame]);
		
		jjConsole("Welcome to the third dimension");
		jjConsole("Control the camera with the WASD keys");
		jjConsole("Press M to toggle the mini-map (will give you some extra FPS)");
		levelInit = true;
	}
	
	// WASD controls; W and S move, A and D turn (no strafing)
	// mouselook and/or independent movement and rotation could be implemented
	// here
	if(!(jjKey[KEY_A] && jjKey[KEY_D])) {
		if(jjKey[KEY_A]) {
			if(angle > 0) {
				angle -= turnSpeed;
			} else {
				angle = TWO_PI;
			}
			
		}
		if(jjKey[KEY_D]) {
			if(angle < TWO_PI) {
				angle += turnSpeed;
			} else {
				angle = 0;
			}
		}
	}
	
	// move forward and backwards
	if(jjKey[KEY_W] || jjKey[KEY_S]) {
		float xNew = xMap;
		float yNew = yMap;
		float stepX;
		float stepY;
		if(angle > (TWO_PI * 0.875) || angle <= (TWO_PI * 0.125)) { // 'up'
			stepY = -moveSpeed;
			stepX = abs(stepY) * tan(angle);
		} else if(angle > (TWO_PI * 0.125) && angle <= (TWO_PI * 0.375)) { // 'right'
			stepX = moveSpeed;
			stepY = abs(stepX) * tan(angle - HALF_PI);
		} else if(angle > (TWO_PI * 0.375) && angle <= (TWO_PI * 0.625)) { // 'down'
			stepY = moveSpeed;
			stepX = abs(stepY) * tan(-angle - PI);
		} else if(angle > (TWO_PI * 0.625) && angle <= (TWO_PI * 0.875)) { // 'left'
			stepX = -moveSpeed;
			stepY = abs(stepX) * tan(-angle - HALF_PI - PI);
		}
		if(jjKey[KEY_W]) {
			// forward
			xNew += stepX;
			yNew += stepY;
		}
		if(jjKey[KEY_S]) {
			// backward
			xNew -= stepX;
			yNew -= stepY;
		}
		
		// only allow movement if it doesn't put the player inside a wall
		if(!jjMaskedPixel(int(xNew), int(yNew))) {
			xMap = xNew;
			yMap = yNew;
		}
	}

	
	// toggle minimap
	if(jjKey[KEY_M] && keyDecay == 0) {
		showMinimap = !showMinimap;
		keyDecay = 25;
	}
}

// in onDrawAmmo, we do the rendering
// this is pretty arbitrary, we just need a jjCANVAS handle
bool onDrawAmmo(jjPLAYER@ player, jjCANVAS@ screen) {
	if(!levelInit) {
		// wait for set-up in onMain to complete
		return false;
	}
	
	// ceiling
	screen.drawRectangle(0, 0, jjResolutionWidth, jjResolutionHeight / 2, 32);
	// floor
	screen.drawRectangle(0, jjResolutionHeight / 2, jjResolutionWidth, jjResolutionHeight / 2, 64);
	
	// get 'empty' minimap to draw current vision cone on
	jjPIXELMAP@ rayMap = jjPIXELMAP(jjAnimFrames[jjAnimations[jjAnimSets[ANIM::CUSTOM[0]].firstAnim].firstFrame]);

	
	// cast some rays
	// the ray will be at a different angle for each 'slice' of the wall - we
	// use the configured field of view to calculate by how much that angle
	// increases for each subsequent slice (i.e. vertical line of pixels)
	float fovStep = fov / float(jjResolutionWidth);
	float localAngle = angle - (fov / 2) - fovStep; // start on the left
	
	// for each pixel of horizontal resolution, determine if a wall slice 
	// should be drawn and if yes of what height
	for(int x = 0; x < jjResolutionWidth; x += 1) {
		localAngle += fovStep;
		
		// normalize angle (does AS have fmod?)
		if(localAngle < 0) {
			localAngle += TWO_PI;
		}
		
		if(localAngle > TWO_PI) {
			localAngle -= TWO_PI;
		}
		
		float stepX, stepY;
		float calcAngle = localAngle + (HALF_PI / 2);
		
		// we cast the ray by determining a horizontal and vertical delta/step, 
		// and then checking pixels along a path by starting at the player 
		// position and adjusting the position by the calculated stepX and
		// stepY. if performance becomes an issue, increasing the step sizes
		// is one way to speed things up - as it is we never increment by more
		// than a single pixel for pixel-perfect mapping, but that is probably 
		// overkill
		if(localAngle > (TWO_PI * 0.875) || localAngle <= (TWO_PI * 0.125)) {
			// facing 'up'
			stepY = -stepPrecision;
			stepX = abs(stepY) * tan(localAngle);
		} else if(localAngle > (TWO_PI * 0.125) && localAngle <= (TWO_PI * 0.375)) {
			// facing 'right'
			stepX = stepPrecision;
			stepY = abs(stepX) * tan(localAngle - HALF_PI);
		} else if(localAngle > (TWO_PI * 0.375) && localAngle <= (TWO_PI * 0.625)) {
			// facing 'down'
			stepY = stepPrecision;
			stepX = abs(stepY) * tan(-localAngle - PI);
		} else if(localAngle > (TWO_PI * 0.625) && localAngle <= (TWO_PI * 0.875)) {
			// facing 'left'
			stepX = -stepPrecision;
			stepY = abs(stepX) * tan(-localAngle - HALF_PI - PI);
		}
		
		// traverse the ray until we hit the edges of the map or a masked pixel
		// traditional raycasters often don't check every pixel but instead use
		// an underlying lower-resolution map of 'blocks' to check against - this
		// would work well with JJ2's tile system but we have the computing power
		// to just check every pixel and it allows using e.g. sloped tiles for
		// different wall shapes
		float xRay = xMap;
		float yRay = yMap;
		float distance = 0.0;
		
		// what we want to find out by casting the ray is the distance to the wall
		// the distance for each step can thus be determined through pythagoras'
		// theorem, since the x and y step sizes form two sides of a triangle and
		// the traversed distance is the third side
		float stepLength = sqrt(pow(abs(stepX), 2) + pow(abs(stepY), 2)); 
	
		// default colour
		int colour = 24;
		while(distance < maxDistance) {
			if(xRay < 0 || xRay > wMap || yRay < 0 || yRay > hMap) {
				// out of bounds
				break;
			}
			
			if(jjMaskedPixel(int(xRay), int(yRay))) {
				// masked pixel, draw wall
				// assume colors are from the first half of the palette - use 
				// the first color of the relevant gradient so we can use the 
				// others for hue later
				// texture mapping could be implemented here
				jjPIXELMAP tile(jjLayers[4].tileGet(int(xRay / 32), int(yRay / 32)));
				colour = int(tile[xRay % 32, yRay % 32] / 8) * 8;
				break;
			} else if(showMinimap) {
				// draw vision cone on minimap
				rayMap[int(xRay / minimapScale), int(yRay / minimapScale)] = 66;
			}
			
			distance += stepLength;
			xRay += stepX;
			yRay += stepY;
		}
		
		if(distance >= maxDistance) {
			// nothing within the scanning distance, assume no wall
			continue;
		}
				
		// correct fisheye effect and determine rendered wall height
		// https://www.permadi.com/tutorial/raycast/rayc8.html
		distance *= cos(localAngle - angle);
		distance = max(0.1, distance); // avoid divide by zero
		int wallHeight = int(maxWallHeight / distance * planeDistance);
		
		if(wallHeight > 0) {
			// draw the wall slice! actually just a rectangle of the calculated
			// height and colour - the 750 is arbitrary here and determines how
			// far away something needs to be to be the 'darkest' hue possible
			int hue = int(float(min(distance, 750.0) / 750) * 7.0);
			screen.drawRectangle(x, (jjResolutionHeight / 2) - (wallHeight / 2), 1, wallHeight, colour + hue);
		}
	}
	
	// minimap
	if(showMinimap) {
		// 3x3 rectangle to mark player position
		int mmX = int(xMap / minimapScale);
		int mmY = int(yMap / minimapScale);
		rayMap[mmX - 1, mmY - 1] = 64;
		rayMap[mmX - 1, mmY] = 64;
		rayMap[mmX - 1, mmY + 1] = 64;
		rayMap[mmX, mmY - 1] = 64;
		rayMap[mmX, mmY] = 64;
		rayMap[mmX, mmY + 1] = 64;
		rayMap[mmX + 1, mmY - 1] = 64;
		rayMap[mmX + 1, mmY] = 64;
		rayMap[mmX + 1, mmY + 1] = 64;
		
		// display as sprite
		rayMap.save(jjAnimFrames[jjAnimations[jjAnimSets[ANIM::CUSTOM[0]].firstAnim].firstFrame + 1]);
		screen.drawSprite(25, 25, ANIM::CUSTOM[0], 1, 0);
	}


	return false;
}