LÖVE

Code: Select all

-- raycaster.lua
sin = math.sin
cos = math.cos
tan = math.tan
rad = math.rad

Newcaster = {}

Newcaster.map = {{1, 1, 1, 1, 1},
		 {1, 0, 0, 0, 1},
		 {1, 0, 1, 0, 1},
		 {1, 0, 0, 0, 1},
		 {1, 1, 1, 1, 1}}

Newcaster.player = {angle = 360, x = 2, y = 2}
Newcaster.highlightRay = 1
Newcaster.displayRay = true -- horizontal intercepts
--[[ ANGLES 

  /- 090 -\
 /    |    \
180 --+-- 360
 \    |    /
  \- 270 -/

360 is EAST
360 -> 1 instead of 359 -> 0

Blocks are 100 wide
]]

-- center of projection plane: 250, 150
screenWidth = 500
screenHeight = 300

FOV = 120

function Newcaster:raycast()
	distToPlane = math.floor((screenWidth / 2) / tan(rad( FOV / 2 )))
	subAngle = FOV / screenWidth -- angle of subsequent rays

	rayAngle = self.player.angle + FOV / 2
	rayAngle = rayAngle + subAngle -- Because we subtract from it once the loop starts

	if self.player.angle > 360 then self.player.angle = 1 end
	if self.player.angle < 1 then self.player.angle = 360 end

	if self.highlightRay > 500 then self.highlightRay = 1 end
	if self.highlightRay < 1 then self.highlightRay = 500 end

	for ray=1, screenWidth do
		rayAngle = rayAngle - subAngle
		if rayAngle < 1 then rayAngle = rayAngle + 360 end
		if rayAngle > 360 then rayAngle = rayAngle - 360 end

		startCoords = {x = (self.player.x-1)*100+50, 
					   y = (self.player.y-1)*100+50}

		dx = 100 / tan(rad(rayAngle)) -- The amount that x changes for every horizontal intercept
		dy = 100 * tan(rad(rayAngle)) -- The amount that y changes for every vertical intercept

		-- If the ray shoots straight up or straight down, dx will be infinite
		if rayAngle == 360 or rayAngle == 180 then
			dx = math.huge
		-- If the ray shoots directly left or right, dy will be infinite
		elseif rayAngle == 90 or rayAngle == 270 then
			dy = math.huge
		end

		-- Find Horizontal Intercepts ------------------------------
		local upOrDown = 100

		if rayAngle < 180 then upOrDown = -100 end

		if rayAngle > 180 and rayAngle < 360 then
			dx = -dx
		end

		curPointHoriz = {x = startCoords.x + dx/2,
						 y = startCoords.y + upOrDown/2}
		
		local findHorizIntercepts = true

		for intercept=1, 7 do -- Range of 7 blocks
			testRow = curPointHoriz.y / 100
			testCol = 1 + ((curPointHoriz.x - (curPointHoriz.x % 100)) / 100)

			
			if curPointHoriz.y <= 0 or curPointHoriz.y >= #self.map*100 or
			   curPointHoriz.x <= 0 or curPointHoriz.x >= #self.map[1]*100 then -- It's outta da map!
				findHorizIntercepts = false
			end

			if findHorizIntercepts then
				if self.map[testRow][testCol] > 0 then
					findHorizIntercepts = false
				elseif self.map[testRow+1][testCol] > 0 then
					findHorizIntercepts = false
				else -- Increment them, we didn't hit nothin'!
					curPointHoriz.x = curPointHoriz.x + dx
					curPointHoriz.y = curPointHoriz.y + upOrDown
				end
			end

		end



		-- Find Vertical Intercepts ------------------------------
		local leftOrRight = 100
		if rayAngle < 270 and rayAngle > 90 then leftOrRight = -100 end

		if rayAngle > 270 or rayAngle < 90 then dy = -dy end

		curPointVert = {x = startCoords.x + leftOrRight/2,
						y = startCoords.y + dy/2 }

		local findVertIntercepts = true

		for intercept=1, 7 do -- Range of 7 blocks
			testRow = 1 + ((curPointVert.y - (curPointVert.y % 100)) / 100)
			testCol = curPointVert.x / 100

			
			if curPointVert.y <= 0 or curPointVert.y >= #self.map*100 or
			   curPointVert.x <= 0 or curPointVert.x >= #self.map[1]*100 then -- It's outta da map!
				findVertIntercepts = false
			end

			if findVertIntercepts then
				if self.map[testRow][testCol] > 0 then
					findVertIntercepts = false
				elseif self.map[testRow][testCol+1] > 0 then
					findVertIntercepts = false
				else -- Increment them, we didn't hit nothin' (again)!
					curPointVert.x = curPointVert.x + leftOrRight
					curPointVert.y = curPointVert.y + dy
				end
			end

		end

		-- Find the shortest line
		horizLineDist = math.sqrt( (startCoords.x - curPointHoriz.x)^2 + (startCoords.y - curPointHoriz.y)^2 )
		vertLineDist = math.sqrt( (startCoords.x - curPointVert.x)^2 + (startCoords.y - curPointVert.y)^2 )
		
		drawAngle = self.player.angle - rayAngle
		if horizLineDist < vertLineDist then
			correctedDistance = math.abs(horizLineDist * cos(rad(drawAngle)))
		else
			correctedDistance = math.abs(vertLineDist * cos(rad(drawAngle)))
		end

		local drawHeight = math.floor((100 / correctedDistance * distToPlane))
		love.graphics.setColor(1, 1, 1)
		if self.highlightRay == ray then 
			if love.keyboard.isDown('l') then
				print(drawAngle)
			end
			love.graphics.setColor(0, 1, 0)
		end

		love.graphics.rectangle('fill', ray+50, love.graphics.getHeight()/2 - drawHeight/2, 1, drawHeight) 

		--[[ Draw the rays, infinitely helpful for debugging ------------------------------]
		love.graphics.setColor(1, 0, 0) -- Horizontal Intercept Lines
		if self.highlightRay == ray then highlightCoords = {x = curPointHoriz.x, y = curPointHoriz.y} end
		love.graphics.line(startCoords.x, startCoords.y, curPointHoriz.x, curPointHoriz.y)

		love.graphics.setColor(0, 0, 1)
		if self.highlightRay == ray then highlightCoords = {x = curPointVert.x, y = curPointVert.y} end
		love.graphics.line(startCoords.x, startCoords.y, curPointVert.x, curPointVert.y)
		--]]



		if self.highlightRay == ray then
			if love.keyboard.isDown('p') then
				print('Ray: '..ray..'\tRayangle: '..rayAngle)
			end
		end

	end
	-- Print some easy debug information
	love.graphics.setColor(0, 1, 0)
	love.graphics.print(self.highlightRay, 0, 12)
	love.graphics.setColor(1, 1, 1)
	love.graphics.print(self.player.angle, 0, 0)




end

return Newcaster

Code: Select all

--raycaster.lua (subsection)

drawAngle = self.player.angle - rayAngle
		if horizLineDist < vertLineDist then
			correctedDistance = math.abs(horizLineDist * cos(rad(drawAngle)))
		else
			correctedDistance = math.abs(vertLineDist * cos(rad(drawAngle)))
		end

		local drawHeight = math.floor((100 / correctedDistance * distToPlane))
		
		love.graphics.setColor(1, 1, 1)
		love.graphics.rectangle('fill', ray+50, love.graphics.getHeight()/2 - drawHeight/2, 1, drawHeight) 

Code: Select all

subAngle = FOV / screenWidth -- angle of subsequent rays

rayAngle = self.player.angle + FOV / 2
rayAngle = rayAngle + subAngle -- Because we subtract from it once the loop starts

Code: Select all

		rayAngle = rayAngle - subAngle

Code: Select all

		rayAngle = math.deg(math.atan2(screenWidth/2 - (ray - 0.5), distToPlane)) + self.player.angle