game.py

@@ -1,126 +1,11 @@
 import pygame
-import maze
+import math
 
-def draw_map(
+def draw_map(screen, player_pos, player_dir):
-    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(
+    pygame.draw.rect(screen, "blue", pygame.Rect(player_pos-(2.5,2.5),(5,5)))
-        (player_pos/cell_size)-(2.5,2.5) + (pygame.Vector2(screen.size) // 2),(5,5)))
+    pygame.draw.line(screen, "blue", player_pos, player_pos+(player_dir))
-    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():
 
@@ -137,19 +22,17 @@ def game_loop():
     running = True
     dt = 0
 
-    player_pos = pygame.Vector2(10, 10)
+    player_pos = pygame.Vector2(200, 200)
-    player_dir = pygame.Vector2(-10, 0)
+    player_dir = pygame.Vector2(-100, 0)
-
-    world_map = maze.RecursiveBacktracker(15)
-    world_map.run()
 
     while running:
         for event in pygame.event.get():
             if event.type == pygame.QUIT:
                 running = False
 
-        draw_map(top_view, player_pos, player_dir, world_map)
+        game_view.fill(pygame.Color(0,0,0))
-        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,11 +25,6 @@ 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