Ascii FPS Ratracing

From https://www.youtube.com/watch?v=xW8skO7MFYw

This example will use an ascii terminal to render the ratracing algorithm for 2D projected into 3D.

I studied this (Wolfenstein) logic while trying to recreate the Doom engine in Python.

I have removed the portions for how to render to a console directly, cell by cell.

pX = 8
pY = 8
pAngle = 0
pFoV = pi/4

mapW = 16
mapH = 16
map = [...] # walls are hashes '#', and floor is '.'

screenW = 120
screenH = 40

maxDepth = 16

while gameLoop

    # pseudo input stuff i can do later
    if turnLeft
        pAngle -= turnAngle
    if turnRight
    ...

    foreach xcol on screen:

        # - half fov on left + half vov on right
        rayAngle = (pAngle - pFoV / 2) + (xcol / screenW) * pFoV

        # this is expensive and where the raytacing occurs
        distToWall = 0

        # unit vector to repesent way player is looking
        eyeX = sin(rayAngle)
        eyeY = cos(rayAngle)

        while !hitwall and distToWall < maxDepth:
            distToWall += .01

            testX = pX + eyeX * distToWall # you can cast these to int to test against a tile in world space
            testY = pY + eyeY * distToWall # ..

            # test ray is out of bounds of map
            if testX < 0 or testX > mapW or testY < 0 or testY > mapH:
                hitWall = true
                distToWAll = depth

            # ray in bounds test to see if at wall
            else
                # if our cell is a wall
                if map[ testY * mapW + testX] == '#':
                    hitWall = true

        # calculate distance to ceiling and floor (vertical scren height)
        # as distance get larger, subtraction gets smaller so it gets taller
        #
        # using screenH / distToWall means that when the distance is equal
        # to screenHeight it will be on unit (pixel or character depending
        # on how you display)
        # This is a bit arbitrary but I would think we would want to define
        # a different vanishing point and get our ratio of wallDistance to
        # vanishingPoint, then set that ratio against the screenHeight
        ceiling = (screenH / 2) - screenH / distToWall
        floor = screenH - ceiling

        # draw into screen column
        for y in screenH

            # if we are above our ceiling draw nothing
            if y < ceiling
                draw(xCol, y, ' ')
            # if we are between ciling and floor draw wall
            else if y < ceiling and y > floor

                # draw the wall
                draw(xCol, y, 'W')

                # VERSION 2 - shade based on distance
                shadeChar = getShadeBasedOnDist(distToWall) # basically if elses based on rules on how far
                draw(xCol, y, shadeChar)

            # if below floor so draw nothing
            else
                draw(xCol, y, ' ')

In regards to our Doom engine we are not raytracing from screen X coords to distant walls

Instead we have divided the game into lines and use a BSP to figure out which walls to render

Those walls are chosen based on your position and don't care about camera rotation or FoV etc

Because of this we need to be able to determine if a wall is within the view of the camera

If it is then we need to determine where our view intersects with that wall and render it

If we know we are rendering a wall facing the camera

• We get the left intersection
• This intersection point will render at some X coordinate on the screen based on the X and Y of the position in the camra
• This is also where I get tripped up because that X coord wants to be projected with linear algebra
• Because in this raytracing example we already know which X coord we are rendering and finding the wall segment with a ray
• In the doom one we are trying to reverse this by taking a wall position and reverse finding the X coord
• If the camera was facing directly up or down (in 2d) then it would be a straight X world to X screen coord
• But as the camera rotates the Y and X must be combined to map to a screen X coord

I think this tutorial can span that knowledge gap: https://medium.com/@btco_code/writing-a-retro-3d-fps-engine-from-scratch-b2a9723e6b06

It talks about projection of wall coords to screen coords and I think it can be redone