hns-maze 0.0.1__tar.gz

hns_maze-0.0.1/.gitignore

@@ -0,0 +1,4 @@
+__pycache__/
+*.pyc
+*.pyo
+.vscode/

hns_maze-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zico Diego
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

hns_maze-0.0.1/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: hns-maze
+Version: 0.0.1
+Summary: A maze-based hide-and-seek game with a model-based reflex agent as a seeker and a player as the hider.
+Project-URL: Homepage, https://github.com/ZicoDiegoRR/AI-Concept-Course-Final-Project
+Project-URL: Bug Tracker, https://github.com/ZicoDiegoRR/AI-Concept-Course-Final-Project/issues
+Author-email: Zico Diego <itzb4pakku1@gmail.com>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: pygame>=2.6
+Description-Content-Type: text/markdown
+
+# HnS: Don't Get Caught By It!
+A maze-based hide-and-seek game with a model-based reflex agent as a seeker and a player as the hider.

hns_maze-0.0.1/README.md

@@ -0,0 +1,2 @@
+# HnS: Don't Get Caught By It!
+A maze-based hide-and-seek game with a model-based reflex agent as a seeker and a player as the hider.

hns_maze-0.0.1/hns_maze/__init__.py

@@ -0,0 +1,4 @@
+from .algorithm import *
+from .game import *
+from .generation import *
+from .play import main

hns_maze-0.0.1/hns_maze/algorithm/__init__.py

@@ -0,0 +1,2 @@
+from .a_star import solve as a_star_solve
+from .bfs import solve as bfs_solve

hns_maze-0.0.1/hns_maze/algorithm/a_star.py

@@ -0,0 +1,88 @@
+import heapq
+from typing import Callable
+
+def solve(
+    grid: list[list[dict[str, int]]],
+    start: tuple[int, int],
+    goal: tuple[int, int],
+    h_func: Callable,
+) -> list[tuple[int, int]]:
+    if not grid or not grid[0]:
+        return []
+    
+    rows = len(grid)
+    cols = len(grid[0])
+
+    if not (0 <= start[0] < rows and 0 <= start[1] < cols):
+        return []
+    if not (0 <= goal[0] < rows and 0 <= goal[1] < cols):
+        return []
+    if start == goal:
+        return [start]
+    
+    
+    q = [[0, 0, start, [start]]]
+    visited = set()
+    moves = (
+        ((-1, 0), "up", "down"),
+        ((1, 0), "down", "up"),
+        ((0, -1), "left", "right"),
+        ((0, 1), "right", "left")
+    )
+    
+    while q:
+        _, curr_g, curr_pos, curr_path = heapq.heappop(q)
+        
+        if curr_pos == goal:
+            return curr_path
+        
+        if curr_pos in visited:
+            continue
+        
+        visited.add(curr_pos)
+        curr_x, curr_y = curr_pos
+        for (dx, dy), wall, opposite_wall in moves:
+            nxt_x, nxt_y = curr_x + dx, curr_y + dy
+
+            if not (0 <= nxt_x < rows and 0 <= nxt_y < cols):
+                continue
+            if (nxt_x, nxt_y) in visited:
+                continue
+            if grid[curr_x][curr_y].get(wall, 1) == 1:
+                continue
+            if grid[nxt_x][nxt_y].get(opposite_wall, 1) == 1:
+                continue
+            
+            new_path = curr_path + [(nxt_x, nxt_y)]
+            new_g = curr_g + 1
+            new_f = new_g + h_func(curr_pos, goal)
+            
+            heapq.heappush(q, [new_f, new_g, (nxt_x, nxt_y), new_path])
+            
+    return curr_path
+
+if __name__ == "__main__":
+    import heuristics.euclidean as euclidean
+    
+    def print_maze(grid: list[list[dict[str, int]]]) -> None:
+        for row in grid:
+            for col in row:
+                print("|" if col["left"] else " ", end="")
+                if col["up"] and col["down"]:
+                    print("ニ", end="")
+                elif col["up"]:
+                    print("‾", end="")
+                elif col["down"]:
+                    print("_", end="")
+                else:
+                    print(" ", end="")
+                print("|" if col["right"] else " ", end="")
+            print()
+    
+    grid = [[{'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 1, 'down': 1, 'left': 0, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 1}, {'up': 1, 'down': 0, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 1, 'down': 0, 'left': 0, 'right': 0}, {'up': 1, 'down': 0, 'left': 0, 'right': 1}], [{'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 1, 'down': 1, 'left': 0, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 1}, {'up': 0, 'down': 1, 'left': 1, 'right': 0}, {'up': 1, 'down': 0, 'left': 0, 'right': 0}, {'up': 0, 'down': 0, 'left': 0, 'right': 1}, {'up': 0, 'down': 0, 'left': 1, 'right': 1}], [{'up': 1, 'down': 0, 'left': 1, 'right': 1}, {'up': 1, 'down': 0, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 1, 'down': 0, 'left': 0, 'right': 0}, {'up': 0, 'down': 1, 'left': 0, 'right': 0}, {'up': 0, 'down': 0, 'left': 0, 'right': 1}, {'up': 0, 'down': 0, 'left': 1, 'right': 1}], [{'up': 0, 'down': 1, 'left': 1, 'right': 1}, {'up': 0, 'down': 1, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 0, 'down': 1, 'left': 0, 'right': 0}, {'up': 1, 'down': 0, 'left': 0, 'right': 0}, {'up': 0, 'down': 1, 'left': 0, 'right': 1}, {'up': 0, 'down': 1, 'left': 1, 'right': 0}], [{'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 1, 'down': 1, 'left': 0, 'right': 0}, {'up': 1, 'down': 1, 'left': 0, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 1}, {'up': 0, 'down': 0, 'left': 1, 'right': 0}, {'up': 1, 'down': 1, 'left': 0, 'right': 1}, {'up': 1, 'down': 0, 'left': 1, 'right': 1}], [{'up': 1, 'down': 0, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 0, 'down': 1, 'left': 0, 'right': 0}, {'up': 1, 'down': 0, 'left': 0, 'right': 1}, {'up': 0, 'down': 0, 'left': 1, 'right': 1}], [{'up': 0, 'down': 1, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 1, 'down': 1, 'left': 0, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 1}, {'up': 0, 'down': 1, 'left': 1, 'right': 1}, {'up': 0, 'down': 1, 'left': 1, 'right': 1}]]
+    print_maze(grid)  
+    print()
+    
+    start = (4, 4)
+    goal = (3, 6)
+    print(solve(grid, start, goal, euclidean.compute))

hns_maze-0.0.1/hns_maze/algorithm/bfs.py

@@ -0,0 +1,87 @@
+from collections import deque
+import random
+
+def solve(
+    grid: list[list[dict[str, int]]],
+    visited: list[list[tuple[int, int]]],
+    start: tuple[int, int],
+    hiding_cell_reduction: float,
+) -> list[tuple[int, int]]:
+    if not grid or not grid[0]:
+        return []
+    
+    rows = len(grid)
+    cols = len(grid[0])
+
+    if not (0 <= start[0] < rows and 0 <= start[1] < cols):
+        return []
+    
+    q = deque([[start, [start]]])
+    seen = set()
+    moves = (
+        ((-1, 0), "up", "down"),
+        ((1, 0), "down", "up"),
+        ((0, -1), "left", "right"),
+        ((0, 1), "right", "left")
+    )
+    
+    while q:
+        curr_pos, curr_path = q.popleft()
+        curr_x, curr_y = curr_pos
+        
+        if (
+            grid[curr_x][curr_y]["hiding"] == 1 
+            and random.random() <= hiding_cell_reduction
+            and curr_pos != start
+        ):
+            if curr_pos not in visited: visited.append(curr_pos)
+            if curr_pos not in seen: seen.add(curr_pos)
+            continue
+        
+        if curr_pos not in visited:
+            return curr_path
+        
+        if curr_pos in seen:
+            continue
+
+        seen.add(curr_pos)
+        for (dx, dy), wall, opposite_wall in moves:
+            nxt_x, nxt_y = curr_x + dx, curr_y + dy
+
+            if not (0 <= nxt_x < rows and 0 <= nxt_y < cols):
+                continue
+            if (nxt_x, nxt_y) in seen:
+                continue
+            if grid[curr_x][curr_y].get(wall, 1) == 1:
+                continue
+            if grid[nxt_x][nxt_y].get(opposite_wall, 1) == 1:
+                continue
+            
+            new_path = curr_path + [(nxt_x, nxt_y)]
+            q.append([(nxt_x, nxt_y), new_path])
+            
+    return []
+
+if __name__ == "__main__":
+    def print_maze(grid: list[list[dict[str, int]]]) -> None:
+        for row in grid:
+            for col in row:
+                print("|" if col["left"] else " ", end="")
+                if col["up"] and col["down"]:
+                    print("ニ", end="")
+                elif col["up"]:
+                    print("‾", end="")
+                elif col["down"]:
+                    print("_", end="")
+                else:
+                    print(" ", end="")
+                print("|" if col["right"] else " ", end="")
+            print()
+    
+    grid = [[{'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 1, 'down': 1, 'left': 0, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 1}, {'up': 1, 'down': 0, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 1, 'down': 0, 'left': 0, 'right': 0}, {'up': 1, 'down': 0, 'left': 0, 'right': 1}], [{'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 1, 'down': 1, 'left': 0, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 1}, {'up': 0, 'down': 1, 'left': 1, 'right': 0}, {'up': 1, 'down': 0, 'left': 0, 'right': 0}, {'up': 0, 'down': 0, 'left': 0, 'right': 1}, {'up': 0, 'down': 0, 'left': 1, 'right': 1}], [{'up': 1, 'down': 0, 'left': 1, 'right': 1}, {'up': 1, 'down': 0, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 1, 'down': 0, 'left': 0, 'right': 0}, {'up': 0, 'down': 1, 'left': 0, 'right': 0}, {'up': 0, 'down': 0, 'left': 0, 'right': 1}, {'up': 0, 'down': 0, 'left': 1, 'right': 1}], [{'up': 0, 'down': 1, 'left': 1, 'right': 1}, {'up': 0, 'down': 1, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 0, 'down': 1, 'left': 0, 'right': 0}, {'up': 1, 'down': 0, 'left': 0, 'right': 0}, {'up': 0, 'down': 1, 'left': 0, 'right': 1}, {'up': 0, 'down': 1, 'left': 1, 'right': 0}], [{'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 1, 'down': 1, 'left': 0, 'right': 0}, {'up': 1, 'down': 1, 'left': 0, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 1}, {'up': 0, 'down': 0, 'left': 1, 'right': 0}, {'up': 1, 'down': 1, 'left': 0, 'right': 1}, {'up': 1, 'down': 0, 'left': 1, 'right': 1}], [{'up': 1, 'down': 0, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 0, 'down': 1, 'left': 0, 'right': 0}, {'up': 1, 'down': 0, 'left': 0, 'right': 1}, {'up': 0, 'down': 0, 'left': 1, 'right': 1}], [{'up': 0, 'down': 1, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 1, 'down': 1, 'left': 0, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 1}, {'up': 0, 'down': 1, 'left': 1, 'right': 1}, {'up': 0, 'down': 1, 'left': 1, 'right': 1}]]
+    print_maze(grid)  
+    print()
+    
+    start = (4, 4)
+    visited = [(4, 4), (3, 4), (5, 4), (4, 5), (3, 3), (3, 5), (5, 3), (5, 5)]
+    print(solve(grid, visited, start))

hns_maze-0.0.1/hns_maze/algorithm/bidirectional_bfs.py

@@ -0,0 +1,112 @@
+from collections import deque
+
+def solve(
+    grid: list[list[dict[str, int]]],
+    start: tuple[int, int],
+    goal: tuple[int, int],
+    max_steps: int = 500,
+) -> list[tuple[int, int]]: # Code modified from GeeksforGeeks and corrected by Copilot AI
+    if not grid or not grid[0]:
+        return []
+    
+    rows = len(grid)
+    cols = len(grid[0])
+
+    if not (0 <= start[0] < rows and 0 <= start[1] < cols):
+        return []
+    if not (0 <= goal[0] < rows and 0 <= goal[1] < cols):
+        return []
+    if start == goal:
+        return [start]
+    
+    if not max_steps:
+        max_steps = float("inf")
+        
+    queue_start = deque([[start, 0]])
+    queue_goal = deque([[goal, 0]])
+    visited_start = set()
+    visited_goal = set()
+    parent_start = {start: None}
+    parent_goal = {goal: None}
+    
+    moves = (
+        ((-1, 0), "up", "down"),
+        ((1, 0), "down", "up"),
+        ((0, -1), "left", "right"),
+        ((0, 1), "right", "left")
+    )
+    
+    while queue_start and queue_goal:
+        for q, visited, parent in zip(
+            [queue_start, queue_goal], 
+            [visited_start, visited_goal],
+            [parent_start, parent_goal],
+        ):
+            curr_pos, curr_step = q.popleft()
+        
+            if curr_pos in visited or curr_step >= max_steps:
+                continue
+            
+            visited.add(curr_pos)
+            curr_x, curr_y = curr_pos
+            for (dx, dy), wall, opposite_wall in moves:
+                nxt_x, nxt_y = curr_x + dx, curr_y + dy
+
+                if not (0 <= nxt_x < rows and 0 <= nxt_y < cols):
+                    continue
+                if (nxt_x, nxt_y) in visited:
+                    continue
+                if grid[curr_x][curr_y].get(wall, 1) == 1:
+                    continue
+                if grid[nxt_x][nxt_y].get(opposite_wall, 1) == 1:
+                    continue
+                
+                q.append([(nxt_x, nxt_y), curr_step + 1])
+                parent[(nxt_x, nxt_y)] = curr_pos
+                
+        intersect = None
+        for node in visited_start:
+            if node in visited_goal:
+                intersect = node
+                break
+
+        if intersect is not None:
+            path = []
+            step = intersect
+            while step is not None:
+                path.append(step)
+                step = parent_start.get(step)
+            path.reverse()
+            
+            step = parent_goal[intersect]
+            while step is not None:
+                path.append(step)
+                step = parent_goal.get(step)
+                
+            return path
+        
+    return []
+
+if __name__ == "__main__":
+    def print_maze(grid: list[list[dict[str, int]]]) -> None:
+        for row in grid:
+            for col in row:
+                print("|" if col["left"] else " ", end="")
+                if col["up"] and col["down"]:
+                    print("ニ", end="")
+                elif col["up"]:
+                    print("‾", end="")
+                elif col["down"]:
+                    print("_", end="")
+                else:
+                    print(" ", end="")
+                print("|" if col["right"] else " ", end="")
+            print()
+    
+    grid = [[{'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 1, 'down': 1, 'left': 0, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 1}, {'up': 1, 'down': 0, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 1, 'down': 0, 'left': 0, 'right': 0}, {'up': 1, 'down': 0, 'left': 0, 'right': 1}], [{'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 1, 'down': 1, 'left': 0, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 1}, {'up': 0, 'down': 1, 'left': 1, 'right': 0}, {'up': 1, 'down': 0, 'left': 0, 'right': 0}, {'up': 0, 'down': 0, 'left': 0, 'right': 1}, {'up': 0, 'down': 0, 'left': 1, 'right': 1}], [{'up': 1, 'down': 0, 'left': 1, 'right': 1}, {'up': 1, 'down': 0, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 1, 'down': 0, 'left': 0, 'right': 0}, {'up': 0, 'down': 1, 'left': 0, 'right': 0}, {'up': 0, 'down': 0, 'left': 0, 'right': 1}, {'up': 0, 'down': 0, 'left': 1, 'right': 1}], [{'up': 0, 'down': 1, 'left': 1, 'right': 1}, {'up': 0, 'down': 1, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 0, 'down': 1, 'left': 0, 'right': 0}, {'up': 1, 'down': 0, 'left': 0, 'right': 0}, {'up': 0, 'down': 1, 'left': 0, 'right': 1}, {'up': 0, 'down': 1, 'left': 1, 'right': 0}], [{'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 1, 'down': 1, 'left': 0, 'right': 0}, {'up': 1, 'down': 1, 'left': 0, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 1}, {'up': 0, 'down': 0, 'left': 1, 'right': 0}, {'up': 1, 'down': 1, 'left': 0, 'right': 1}, {'up': 1, 'down': 0, 'left': 1, 'right': 1}], [{'up': 1, 'down': 0, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 0, 'down': 1, 'left': 0, 'right': 0}, {'up': 1, 'down': 0, 'left': 0, 'right': 1}, {'up': 0, 'down': 0, 'left': 1, 'right': 1}], [{'up': 0, 'down': 1, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 1, 'down': 1, 'left': 0, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 1}, {'up': 0, 'down': 1, 'left': 1, 'right': 1}, {'up': 0, 'down': 1, 'left': 1, 'right': 1}]]
+    print_maze(grid)  
+    print()
+    
+    start = (4, 4)
+    goal = (3, 6)
+    print(solve(grid, start, goal))

hns_maze-0.0.1/hns_maze/algorithm/dfs.py

@@ -0,0 +1,68 @@
+def solve(
+    grid: list[list[dict[str, int]]],
+    start: tuple[int, int],
+    goal: tuple[int, int],
+    max_steps: int = 500,
+) -> list[tuple[int, int]]: # Code by Copilot AI
+    """Solve the maze using recursive depth-first search.
+
+    Each cell in `grid` contains wall flags for `up`, `down`, `left`, and `right`.
+    A value of `1` indicates a wall, and `0` indicates an open passage.
+    """
+
+    if not grid or not grid[0]:
+        return []
+
+    rows = len(grid)
+    cols = len(grid[0])
+    start_x, start_y = start
+    goal_x, goal_y = goal
+
+    if not (0 <= start_x < rows and 0 <= start_y < cols):
+        return []
+    if not (0 <= goal_x < rows and 0 <= goal_y < cols):
+        return []
+    if start == goal:
+        return [start]
+    
+    if not max_steps:
+        max_steps = float("inf")
+
+    visited: set[tuple[int, int]] = set()
+    directions = [
+        (-1, 0, "up", "down"),
+        (1, 0, "down", "up"),
+        (0, -1, "left", "right"),
+        (0, 1, "right", "left"),
+    ]
+
+    def dfs(x: int, y: int, step: int) -> list[tuple[int, int]] | None:
+        if step == max_steps:
+            return None
+
+        visited.add((x, y))
+        if (x, y) == goal:
+            return [(x, y)]
+
+        for dx, dy, wall, opposite_wall in directions:
+            next_x = x + dx
+            next_y = y + dy
+
+            if not (0 <= next_x < rows and 0 <= next_y < cols):
+                continue
+            if (next_x, next_y) in visited:
+                continue
+            if grid[x][y].get(wall, 1) == 1:
+                continue
+            if grid[next_x][next_y].get(opposite_wall, 1) == 1:
+                continue
+
+            result = dfs(next_x, next_y, step + 1)
+            if result is not None:
+                return [(x, y)] + result
+
+        return None
+
+    path = dfs(start_x, start_y, 0)
+    return path if path is not None else []
+        

hns_maze-0.0.1/hns_maze/algorithm/gbfs.py

@@ -0,0 +1,89 @@
+import heapq
+from typing import Callable
+
+def solve(
+    grid: list[list[dict[str, int]]],
+    start: tuple[int, int],
+    goal: tuple[int, int],
+    h_func: Callable,
+    max_steps: int = 500,
+) -> list[tuple[int, int]]:
+    if not grid or not grid[0]:
+        return []
+    
+    rows = len(grid)
+    cols = len(grid[0])
+
+    if not (0 <= start[0] < rows and 0 <= start[1] < cols):
+        return []
+    if not (0 <= goal[0] < rows and 0 <= goal[1] < cols):
+        return []
+    if start == goal:
+        return [start]
+    
+    if not max_steps:
+        max_steps = float("inf")
+    
+    q = [[0, 0, start, [start]]]
+    visited = set()
+    moves = (
+        ((-1, 0), "up", "down"),
+        ((1, 0), "down", "up"),
+        ((0, -1), "left", "right"),
+        ((0, 1), "right", "left")
+    )
+    
+    while q:
+        _, curr_step, curr_pos, curr_path = heapq.heappop(q)
+        
+        if curr_pos in visited or curr_step >= max_steps:
+            continue
+        
+        if curr_pos == goal:
+            return curr_path
+        
+        visited.add(curr_pos)
+        curr_x, curr_y = curr_pos
+        for (dx, dy), wall, opposite_wall in moves:
+            nxt_x, nxt_y = curr_x + dx, curr_y + dy
+
+            if not (0 <= nxt_x < rows and 0 <= nxt_y < cols):
+                continue
+            if (nxt_x, nxt_y) in visited:
+                continue
+            if grid[curr_x][curr_y].get(wall, 1) == 1:
+                continue
+            if grid[nxt_x][nxt_y].get(opposite_wall, 1) == 1:
+                continue
+            
+            new_h = h_func(start, goal)
+            new_path = curr_path + [(nxt_x, nxt_y)]
+            heapq.heappush(q, [new_h, curr_step+1, (nxt_x, nxt_y), new_path])
+            
+    return curr_path
+
+if __name__ == "__main__":
+    import heuristics.euclidean as euclidean
+    
+    def print_maze(grid: list[list[dict[str, int]]]) -> None:
+        for row in grid:
+            for col in row:
+                print("|" if col["left"] else " ", end="")
+                if col["up"] and col["down"]:
+                    print("ニ", end="")
+                elif col["up"]:
+                    print("‾", end="")
+                elif col["down"]:
+                    print("_", end="")
+                else:
+                    print(" ", end="")
+                print("|" if col["right"] else " ", end="")
+            print()
+    
+    grid = [[{'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 1, 'down': 1, 'left': 0, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 1}, {'up': 1, 'down': 0, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 1, 'down': 0, 'left': 0, 'right': 0}, {'up': 1, 'down': 0, 'left': 0, 'right': 1}], [{'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 1, 'down': 1, 'left': 0, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 1}, {'up': 0, 'down': 1, 'left': 1, 'right': 0}, {'up': 1, 'down': 0, 'left': 0, 'right': 0}, {'up': 0, 'down': 0, 'left': 0, 'right': 1}, {'up': 0, 'down': 0, 'left': 1, 'right': 1}], [{'up': 1, 'down': 0, 'left': 1, 'right': 1}, {'up': 1, 'down': 0, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 1, 'down': 0, 'left': 0, 'right': 0}, {'up': 0, 'down': 1, 'left': 0, 'right': 0}, {'up': 0, 'down': 0, 'left': 0, 'right': 1}, {'up': 0, 'down': 0, 'left': 1, 'right': 1}], [{'up': 0, 'down': 1, 'left': 1, 'right': 1}, {'up': 0, 'down': 1, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 0, 'down': 1, 'left': 0, 'right': 0}, {'up': 1, 'down': 0, 'left': 0, 'right': 0}, {'up': 0, 'down': 1, 'left': 0, 'right': 1}, {'up': 0, 'down': 1, 'left': 1, 'right': 0}], [{'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 1, 'down': 1, 'left': 0, 'right': 0}, {'up': 1, 'down': 1, 'left': 0, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 1}, {'up': 0, 'down': 0, 'left': 1, 'right': 0}, {'up': 1, 'down': 1, 'left': 0, 'right': 1}, {'up': 1, 'down': 0, 'left': 1, 'right': 1}], [{'up': 1, 'down': 0, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 0, 'down': 1, 'left': 0, 'right': 0}, {'up': 1, 'down': 0, 'left': 0, 'right': 1}, {'up': 0, 'down': 0, 'left': 1, 'right': 1}], [{'up': 0, 'down': 1, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 0}, {'up': 1, 'down': 1, 'left': 0, 'right': 1}, {'up': 1, 'down': 1, 'left': 1, 'right': 1}, {'up': 0, 'down': 1, 'left': 1, 'right': 1}, {'up': 0, 'down': 1, 'left': 1, 'right': 1}]]
+    print_maze(grid)  
+    print()
+    
+    start = (4, 4)
+    goal = (3, 6)
+    print(solve(grid, start, goal, euclidean.compute))

hns_maze-0.0.1/hns_maze/algorithm/heuristics/__init__.py

@@ -0,0 +1,2 @@
+from .euclidean import compute as euclidean_distance
+from .manhattan import compute as manhattan_distance

hns_maze-0.0.1/hns_maze/algorithm/heuristics/euclidean.py

@@ -0,0 +1,8 @@
+def compute(
+    curr_pos: tuple[int, int], 
+    goal: tuple[int, int]
+) -> int:
+    x1, y1 = curr_pos
+    x2, y2 = goal
+
+    return ((x2 - x1)**2 + (y2 - y1)**2)**0.5

hns_maze-0.0.1/hns_maze/algorithm/heuristics/manhattan.py

@@ -0,0 +1,8 @@
+def compute(
+    curr_pos: tuple[int, int], 
+    goal: tuple[int, int]
+) -> int:
+    x1, y1 = curr_pos
+    x2, y2 = goal
+
+    return abs(x2 - x1) + abs(y2 - y1)

hns_maze-0.0.1/hns_maze/game/__init__.py

@@ -0,0 +1,5 @@
+from .entity_controller import *
+from .entity_spawning import *
+from .entity_state import *
+from .interface import *
+from .managers import *

hns_maze-0.0.1/hns_maze/game/entity_controller/__init__.py

@@ -0,0 +1,2 @@
+from .agent_control import run_agent
+from .player_control import run_player