Worked on game.py

game.py

@@ -1,11 +1,126 @@
 import pygame
-import math
+import maze
 
-def draw_map(screen, player_pos, player_dir):
+def draw_map(
+    screen: pygame.Surface,
+    player_pos: pygame.Vector2,
+    player_dir: pygame.Vector2,
+    world_map: maze.Maze,
+):
+    cell_size = 10
     screen.fill(pygame.Color(64,64,64))
 
-    pygame.draw.rect(screen, "blue", pygame.Rect(player_pos-(2.5,2.5),(5,5)))
+    pygame.draw.rect(screen, "blue", pygame.Rect(
-    pygame.draw.line(screen, "blue", player_pos, player_pos+(player_dir))
+        (player_pos/cell_size)-(2.5,2.5) + (pygame.Vector2(screen.size) // 2),(5,5)))
+    pygame.draw.line(
+        screen,
+        "blue",
+        (player_pos/cell_size) + (pygame.Vector2(screen.size) // 2),
+        (player_pos/cell_size) + (player_dir) + (pygame.Vector2(screen.size) // 2),
+    )
+
+    plane = pygame.Vector2(0,0.66)
+
+    for x in range(0, screen.width, 50):
+        camera = 2 * x / screen.width - 1
+        ray_dir = player_dir.normalize() + (plane * camera)
+
+        wall_dist, side = ray(player_pos, ray_dir, world_map)
+        pygame.draw.line(
+            screen,
+            pygame.Color(192,192,192) if side else pygame.Color(255,255,255),
+            (player_pos/cell_size) + (pygame.Vector2(screen.size) // 2),
+            (player_pos/cell_size) + (ray_dir * wall_dist) + (pygame.Vector2(screen.size) // 2),
+        )
+
+    for y in range(world_map.height):
+        for x in range(world_map.width):
+            if not world_map[x, y]:
+                pygame.draw.rect(screen, pygame.Color(255,255,255), pygame.Rect(
+                    (pygame.Vector2(x, y) * cell_size) +
+                        (pygame.Vector2(screen.size) // 2),
+                    (cell_size, cell_size),
+                ))
+
+def draw_game(
+    screen: pygame.Surface,
+    player_pos: pygame.Vector2,
+    player_dir: pygame.Vector2,
+    world_map: maze.Maze,
+):
+    screen.fill(pygame.Color(0,0,0))
+
+    plane = pygame.Vector2(0,0.66)
+
+    for x in range(screen.width):
+        camera = 2 * x / screen.width - 1
+        ray_dir = player_dir.normalize() + (plane * camera)
+
+        wall_dist, side = ray(player_pos, ray_dir, world_map)
+
+        lineHeight = int(screen.height / wall_dist)
+
+        draw_start = -lineHeight / 2 + screen.height / 2
+        if draw_start < 0: draw_start = 0
+        draw_end = lineHeight / 2 + screen.height / 2
+        if draw_end >= screen.height: draw_end = screen.height - 1
+
+        pygame.draw.line(
+            screen,
+            pygame.Color(192,192,192) if side else pygame.Color(255,255,255),
+            (x, draw_start),
+            (x, draw_end),
+        )
+
+def ray(
+    ray_pos: pygame.Vector2,
+    ray_dir: pygame.Vector2,
+    world_map: maze.Maze,
+    max_dis_squared: int = 100,
+) -> tuple[float, int]:
+    delta = pygame.Vector2(1/max(abs(ray_dir.x),1e-3),1/max(abs(ray_dir.y),1e-3))
+    map_pos = pygame.Vector2(int(ray_dir.x),int(ray_dir.y))
+    step = pygame.Vector2(0,0)
+    side_dis = pygame.Vector2(0,0)
+
+    if ray_dir.x < 0:
+        step.x = -1
+        side_dis.x = (ray_pos.x - map_pos.x) * delta.x
+    else:
+        step.x = 1
+        side_dis.x = (map_pos.x + 1.0 - ray_pos.x) * delta.x
+    if ray_dir.y < 0:
+        step.y = -1
+        side_dis.y = (ray_pos.y - map_pos.y) * delta.y
+    else:
+        step.y = 1
+        side_dis.y = (map_pos.y + 1.0 - ray_pos.y) * delta.y
+
+    side = 0
+
+    while True:
+        if side_dis.x < side_dis.y:
+            side_dis.x += delta.x
+            map_pos.x += step.x
+            side = 0
+        else:
+            side_dis.y += delta.y
+            map_pos.y += step.y
+            side = 1
+
+        if not (
+            map_pos.x >= 0 and
+            map_pos.y >= 0 and
+            map_pos.x < world_map.width and
+            map_pos.y < world_map.height and
+            world_map[int(map_pos.x),int(map_pos.y)]
+        ) or side_dis.length_squared() > max_dis_squared:
+            break
+
+    if side == 0: perp_wall_dist = side_dis.x - delta.x
+    else: perp_wall_dist = side_dis.y - delta.y
+
+    return perp_wall_dist, side
 
 def game_loop():
 
@@ -22,17 +137,19 @@ def game_loop():
     running = True
     dt = 0
 
-    player_pos = pygame.Vector2(200, 200)
+    player_pos = pygame.Vector2(10, 10)
-    player_dir = pygame.Vector2(-100, 0)
+    player_dir = pygame.Vector2(-10, 0)
+
+    world_map = maze.RecursiveBacktracker(15)
+    world_map.run()
 
     while running:
         for event in pygame.event.get():
             if event.type == pygame.QUIT:
                 running = False
 
-        game_view.fill(pygame.Color(0,0,0))
+        draw_map(top_view, player_pos, player_dir, world_map)
-
+        draw_game(game_view, player_pos, player_dir, world_map)
-        draw_map(top_view, player_pos, player_dir)
 
         keys = pygame.key.get_pressed()
         if keys[pygame.K_w]:

maze.py

@@ -25,6 +25,11 @@ class Maze(abc.ABC):
     def step(self) -> bool: # returns False when algorithm is done
         pass
 
+    def run(self, i=1_000_000) -> bool:
+        for _ in range(i):
+            if not self.step(): return True
+        return False
+
     def secondary(self, index: tuple[int,int]) -> bool:
         return False