[Python] DRI3, libEGL, and MESA errors in Pygame

When running my Pygame 3d maze, I encountered a new error when loading it up.

Here is my error:

 Environment updated. Reloading shell...
pygame 2.6.1 (SDL 2.28.4, Python 3.11.10)
Hello from the pygame community. https://www.pygame.org/contribute.html
libEGL warning: DRI3: Screen seems not DRI3 capable
libEGL warning: DRI3: Screen seems not DRI3 capable
MESA: error: ZINK: vkCreateInstance failed (VK_ERROR_INCOMPATIBLE_DRIVER)
libEGL warning: egl: failed to create dri2 screen


Here are all of my dependencies that are in my code:

requires-python = ">=3.11"
dependencies = [
"panda3d>=1.10.15",
"pygame>=2.6.1",
]


I have spent time researching what this means, but it only comes up as a Windows failure, and my PC is fine. These are related to my graphics card and my PC's bandwidth. I have run this on every computer I have used without problem.

I am using Python on replit. So this shouldn't even be pulling this error from what I know

Can anyone please tell me what this means?

Here is my main.py:

import pygame
import math
from maze import Maze

# Constants
SCREEN_WIDTH, SCREEN_HEIGHT = 800, 600
MAZE_WIDTH, MAZE_HEIGHT = 41, 41
BLOCK_SIZE = 40
SPEED = 0.1
FOV = math.pi / 3 # Field of view
RAY_COUNT = 500 # Number of rays to cast for rendering
MAX_DEPTH = 20 # Rendering distance
MOUSE_SENSITIVITY = 0.0002 # Reduced sensitivity


class Game:

def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("3D Maze Game")
self.clock = pygame.time.Clock()
self.maze = Maze(MAZE_WIDTH, MAZE_HEIGHT).generate()
self.player_x, self.player_y = 1.5, 1.5
self.angle = math.pi / 4 # Player facing direction

# # Load wall texture
# self.wall_texture = pygame.image.load("wall.png")
# #self.wall_texture = pygame.transform.scale(self.wall_texture, (100, 100))

# Mouse control settings
pygame.mouse.set_visible(False)
pygame.event.set_grab(True)

def cast_rays(self):
""" Raycasting with proper fade-to-black shading and textures """
for ray in range(RAY_COUNT):
ray_angle = self.angle - (FOV / 2) + (FOV * ray / RAY_COUNT)
depth = 0

while depth < MAX_DEPTH:
test_x = int(self.player_x + math.cos(ray_angle) * depth)
test_y = int(self.player_y + math.sin(ray_angle) * depth)

if self.maze[test_y][test_x] == 1:
break # Stop at walls

depth += 0.05

# Fade into black instead of gray
line_height = min(SCREEN_HEIGHT, int(SCREEN_HEIGHT / (depth)))
shade = max(0, 255 - min(255, depth * 20)) # DARKER FADE

pygame.draw.rect(
self.screen, (shade, shade, shade),
(ray * (SCREEN_WIDTH // RAY_COUNT), SCREEN_HEIGHT // 2 -
line_height // 2, SCREEN_WIDTH // RAY_COUNT, line_height))

# self.screen.blit(
# pygame.transform.scale(
# self.wall_texture,
# (SCREEN_WIDTH // RAY_COUNT, line_height)),
# (ray * (SCREEN_WIDTH // RAY_COUNT),
# SCREEN_HEIGHT // 2 - line_height // 2))

def handle_input(self):
keys = pygame.key.get_pressed()
if keys[pygame.K_w]: # Move forward
new_x = self.player_x + math.cos(self.angle) * SPEED
new_y = self.player_y + math.sin(self.angle) * SPEED
if self.maze[int(new_y)][int(new_x)] == 0:
self.player_x, self.player_y = new_x, new_y

if keys[pygame.K_s]: # Move backward
new_x = self.player_x - math.cos(self.angle) * SPEED
new_y = self.player_y - math.sin(self.angle) * SPEED
if self.maze[int(new_y)][int(new_x)] == 0:
self.player_x, self.player_y = new_x, new_y

if keys[pygame.K_a]: # Strafe left
new_x = self.player_x - math.sin(self.angle) * SPEED
new_y = self.player_y + math.cos(self.angle) * SPEED
if self.maze[int(new_y)][int(new_x)] == 0:
self.player_x, self.player_y = new_x, new_y

if keys[pygame.K_d]: # Strafe right
new_x = self.player_x + math.sin(self.angle) * SPEED
new_y = self.player_y - math.cos(self.angle) * SPEED
if self.maze[int(new_y)][int(new_x)] == 0:
self.player_x, self.player_y = new_x, new_y

def handle_events(self):
lookleft = False
lookright = False
for event in pygame.event.get():
if event.type == pygame.QUIT:
return False

elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_e:
lookleft = True
elif event.key == pygame.K_q:
lookright = True
elif event.type == pygame.KEYUP:
if event.key == pygame.K_e:
lookleft = False
elif event.key == pygame.K_q:
lookright = False
if lookleft:
self.angle -= 0.1
if lookright:
self.angle += 0.1
return True

def run(self):
while self.handle_events():
self.clock.tick(60)
self.handle_input()
self.screen.fill((0, 0, 0))
self.cast_rays()
pygame.display.flip()

pygame.quit()


if __name__ == "__main__":
Game().run()


Here is my maze.py:

import random

class Maze:
def __init__(self, width, height):
self.width = width
self.height = height
self.grid = [[1] * width for _ in range(height)] # Walls everywhere initially

def generate(self):
def carve_maze(x, y):
""" Recursive maze generation with branching paths """
directions = [(0,1), (1,0), (0,-1), (-1,0)]
random.shuffle(directions)

for dx, dy in directions:
nx, ny = x + dx * 2, y + dy * 2
if 1 <= nx < self.width - 1 and 1 <= ny < self.height - 1 and self.grid[ny][nx] == 1:
self.grid[y + dy][x + dx] = 0
self.grid[ny][nx] = 0
carve_maze(nx, ny)

# Ensure proper maze size for complexity
self.grid[10][10] = 0
carve_maze(1, 1)

return self.grid

if __name__ == "__main__":
maze = Maze(41, 41) # Larger maze size for a full experience
maze_map = maze.generate()
for row in maze_map:
print("".join(['#' if cell else ' ' for cell in row]))

Continue reading...