main.py

import pygame
import sys
import math

MAP = [
    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,1,0,0,0,0,1,1,1,1,0,1,
    1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,1,0,0,1,
    1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,1,0,0,1,
    1,0,0,0,0,0,0,1,0,0,0,0,0,1,1,0,0,0,1,1,
    1,0,0,0,0,0,0,1,0,0,0,1,1,1,1,1,0,0,1,1,
    1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
    1,0,0,0,1,1,1,1,0,0,0,0,0,1,1,1,0,0,0,1,
    1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,
    1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,1,0,0,1,
    1,0,0,1,1,0,0,0,0,0,1,0,0,0,0,1,1,0,0,1,
    1,0,0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,1,
    1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,
    1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,1,1,0,0,1,
    1,1,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,
    1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,
    1,1,0,0,0,0,0,0,1,1,1,1,1,0,1,1,1,1,0,1,
    1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,
    1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,
    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
]

screen_height = 480
screen_width = screen_height * 2 
map_size = 20
block_size = screen_height / map_size
max_depth = int(map_size * block_size)
FOV = math.pi / 3
half_FOV = FOV / 2
casted_rays = 120
angle = FOV / casted_rays
scale = (screen_width / 2) / casted_rays
moving_forward = True

player_coordenate_x = screen_height / 4
player_coordenate_y = screen_height / 4
player_angle = 2 * math.pi


pygame.init()
screen = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption('Raycaster 2D')
clock = pygame.time.Clock()

# exibe o FPS na tela
def display_FPS():
    FPS = str(int(clock.get_fps()))
    # puxa a fonte padrão do sistema
    font = pygame.font.SysFont('Monospace Regular', 60)
    textsurface = font.render(FPS, False, (255, 255, 255))
    # o blit serve para colocar uma superfície por cima da outra. Nesse caso, os FPS por cima do mapa
    screen.blit(textsurface, (480, 0))

def map_draw():
    for row in range(map_size):
        for col in range(map_size):
            square = row * map_size + col
            if MAP[square] == 1:
                # desenha o bloco com a borda de 1 pixel caso identifique uma parede
                pygame.draw.rect(
                    screen,
                    (200, 200, 200),
                    (col * block_size, row * block_size, block_size - 1, block_size - 1)
                )
            else:
                # desenha o bloco completo para o chão ser "liso" caso não tenha parede
                pygame.draw.rect(
                    screen,
                    (126, 112, 113),
                    (col * block_size, row * block_size, block_size, block_size)
                )
    pygame.draw.circle(screen, (255, 255, 0), (int(player_coordenate_x), int(player_coordenate_y)), 10) 

    # desenha na tela a direção na qual o player vai estar virado
    pygame.draw.line(screen, (190, 0, 0), (player_coordenate_x, player_coordenate_y), 
                                          (player_coordenate_x - math.sin(player_angle) * 50, 
                                           player_coordenate_y + math.cos(player_angle) * 50), 3)
    
    # desenha na tela o FOV do player
    pygame.draw.line(screen, (190, 0, 0), (player_coordenate_x, player_coordenate_y), 
                                          (player_coordenate_x - math.sin(player_angle - half_FOV) * 50, 
                                           player_coordenate_y + math.cos(player_angle - half_FOV) * 50), 3)
    
    pygame.draw.line(screen, (190, 0, 0), (player_coordenate_x, player_coordenate_y), 
                                          (player_coordenate_x - math.sin(player_angle + half_FOV) * 50, 
                                           player_coordenate_y + math.cos(player_angle + half_FOV) * 50), 3)

# função responsável pelo algoritmo do ray casting
def raycaster():
    starter_angle = player_angle - half_FOV

    # loop para alongar o tamanho de cada raio
    for ray in range(casted_rays):
        for depth in range(max_depth):
            # Pega as coordenadas do raio através da coordenada do player
            target_x = player_coordenate_x - math.sin(starter_angle) * depth
            target_y = player_coordenate_y + math.cos(starter_angle) * depth

            col = int(target_x / block_size)
            row = int(target_y / block_size)

            if 0 <= col < map_size and 0 <= row < map_size:
                square = row * map_size + col
                
                # responsável por identificar os blocos sendo "vistos" pelo ray emitido do jogador e os pintar como verde
                if MAP[square] == 1:
                    pygame.draw.rect(screen, (0, 255, 0), (col * block_size, row * block_size, block_size - 1, block_size - 1))

                    # desenha o ray na tela
                    pygame.draw.line(screen, (255, 0, 0), (player_coordenate_x, player_coordenate_y), (target_x, target_y))


                    # deetermina a cor das paredes pela distância do jogador a cada uma delas
                    color_by_depth = 255 / (1 + depth * depth * 0.0001)

                    # conserta a distorção visual
                    depth *= math.cos(player_angle - starter_angle)

                    # calcula o tamanho dos blocos/paredes que serão exibidos no mapa em 3D
                    block_height = 21000 / (depth + 0.0001)

                    # resolve caso fique preso na parede. O problema surge quando a altura do bloco (block_height) é maior que a altura da tela
                    if block_height > screen_height: block_height = screen_height


                    # vai desenhar a projeção 3D na tela
                    pygame.draw.rect(screen, (color_by_depth, color_by_depth, color_by_depth), (
                        screen_height + ray * scale, 
                        (screen_height / 2) - block_height / 2,
                        scale, block_height))

                    break

        # aumenta o ângulo por pequenos segmentos
        starter_angle += angle

while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit(0)

    # responsável por adicionar colisões
    col = int(player_coordenate_x / block_size)
    row = int(player_coordenate_y / block_size)

    square = row * map_size + col
            
    # se o player acertar a parede, não pode mais se mover para frente. Gerando uma "colisão" de certa forma
    if MAP[square] == 1:
        if moving_forward:
            player_coordenate_x -= -math.sin(player_angle)
            player_coordenate_y -= math.cos(player_angle)
        else:
            player_coordenate_x += -math.sin(player_angle)
            player_coordenate_y += math.cos(player_angle)


    # atualiza o mapa 2D
    pygame.draw.rect(screen, (0, 0, 0), (0, 0, screen_height, screen_height))
    # atualiza o mapa 3D
    pygame.draw.rect(screen, (100, 100, 100), (480, screen_height / 2, screen_height, screen_height))
    pygame.draw.rect(screen, (200, 200, 200), (480, -screen_height / 2, screen_height, screen_height))

    map_draw()

    raycaster()

    keys = pygame.key.get_pressed()

    if keys[pygame.K_LEFT]: player_angle -= 0.1
    if keys[pygame.K_RIGHT]: player_angle += 0.1
    if keys[pygame.K_UP]: 
        moving_forward = True
        player_coordenate_x += -math.sin(player_angle)
        player_coordenate_y += math.cos(player_angle)
    if keys[pygame.K_DOWN]: 
        moving_forward = False
        player_coordenate_x -= -math.sin(player_angle)
        player_coordenate_y -= math.cos(player_angle)

    clock.tick(60)
    display_FPS()

    pygame.display.flip()