ai-snake-lab 0.1.0__py3-none-any.whl

ai_snake_lab/constants/DDef.py

@@ -0,0 +1,18 @@
+"""
+constants/DDef.py
+
+    AI Snake Game Simulator
+    Author: Nadim-Daniel Ghaznavi
+    Copyright: (c) 2024-2025 Nadim-Daniel Ghaznavi
+    GitHub: https://github.com/NadimGhaznavi/ai
+    License: GPL 3.0
+"""
+
+from utils.ConstGroup import ConstGroup
+
+
+class DDef(ConstGroup):
+    """Defaults"""
+
+    APP_TITLE: str = "AI Snake Game Simulator"
+    MOVE_DELAY: float = 0.0

ai_snake_lab/constants/DDir.py

@@ -0,0 +1,16 @@
+"""
+constants/DDir.py
+
+    AI Snake Game Simulator
+    Author: Nadim-Daniel Ghaznavi
+    Copyright: (c) 2024-2025 Nadim-Daniel Ghaznavi
+    GitHub: https://github.com/NadimGhaznavi/ai
+    License: GPL 3.0
+"""
+
+from utils.ConstGroup import ConstGroup
+
+
+class DDir(ConstGroup):
+    """Directories"""
+    UTILS : str = "utils"

ai_snake_lab/constants/DEpsilon.py

@@ -0,0 +1,19 @@
+"""
+constants/DEpsilon.py
+
+    AI Snake Game Simulator
+    Author: Nadim-Daniel Ghaznavi
+    Copyright: (c) 2024-2025 Nadim-Daniel Ghaznavi
+    GitHub: https://github.com/NadimGhaznavi/ai
+    License: GPL 3.0
+"""
+
+from utils.ConstGroup import ConstGroup
+
+
+class DEpsilon(ConstGroup):
+    """Epsilon Defaults"""
+
+    EPSILON_INITIAL: float = 0.99
+    EPSILON_MIN: float = 0.0
+    EPSILON_DECAY: float = 0.95

ai_snake_lab/constants/DFields.py

@@ -0,0 +1,18 @@
+"""
+constants/DFields.py
+
+    AI Snake Game Simulator
+    Author: Nadim-Daniel Ghaznavi
+    Copyright: (c) 2024-2025 Nadim-Daniel Ghaznavi
+    GitHub: https://github.com/NadimGhaznavi/ai
+    License: GPL 3.0
+"""
+
+from utils.ConstGroup import ConstGroup
+
+
+class DField(ConstGroup):
+    """Fields"""
+
+    RUNNING: str = "running"
+    STOPPED: str = "stopped"

ai_snake_lab/constants/DFile.py

@@ -0,0 +1,17 @@
+"""
+constants/DFile.py
+
+    AI Snake Game Simulator
+    Author: Nadim-Daniel Ghaznavi
+    Copyright: (c) 2024-2025 Nadim-Daniel Ghaznavi
+    GitHub: https://github.com/NadimGhaznavi/ai
+    License: GPL 3.0
+"""
+
+from utils.ConstGroup import ConstGroup
+
+
+class DFile(ConstGroup):
+    """Files"""
+
+    CSS_PATH: str = "AISim.tcss"

ai_snake_lab/constants/DLabels.py

@@ -0,0 +1,34 @@
+"""
+constants/DLabels.py
+
+    AI Snake Game Simulator
+    Author: Nadim-Daniel Ghaznavi
+    Copyright: (c) 2024-2025 Nadim-Daniel Ghaznavi
+    GitHub: https://github.com/NadimGhaznavi/ai
+    License: GPL 3.0
+"""
+
+from utils.ConstGroup import ConstGroup
+
+
+class DLabel(ConstGroup):
+    """Labels"""
+
+    EPSILON: str = "Epsilon"
+    EPSILON_DECAY: str = "Epsilon Decay"
+    EPSILON_INITIAL: str = "Initial Epsilon"
+    EPSILON_MIN: str = "Minimum Epsilon"
+    GAME: str = "Game"
+    HIGHSCORE: str = "Highscore"
+    MEM_TYPE: str = "Memory Type"
+    MEMORIES: str = "Memories"
+    MIN_EPSILON: str = "Minimum Epsilon"
+    MOVE_DELAY: str = "Move Delay"
+    PAUSE: str = "Pause"
+    QUIT: str = "Quit"
+    RUNTIME: str = "Runtime Values"
+    SCORE: str = "Score"
+    SETTINGS: str = "Configuration Settings"
+    START: str = "Start"
+    RESET: str = "Reset"
+    UPDATE: str = "Update"

ai_snake_lab/constants/DLayout.py

@@ -0,0 +1,39 @@
+"""
+constants/DLayout.py
+
+    AI Snake Game Simulator
+    Author: Nadim-Daniel Ghaznavi
+    Copyright: (c) 2024-2025 Nadim-Daniel Ghaznavi
+    GitHub: https://github.com/NadimGhaznavi/ai
+    License: GPL 3.0
+"""
+
+from utils.ConstGroup import ConstGroup
+
+
+class DLayout(ConstGroup):
+    """Layout"""
+
+    BUTTON_PAUSE: str = "button_pause"
+    BUTTON_QUIT: str = "button_quit"
+    BUTTON_ROW: str = "button_row"
+    BUTTON_START: str = "button_start"
+    BUTTON_RESET: str = "button_reset"
+    BUTTON_UPDATE: str = "button_update"
+    CUR_EPSILON: str = "cur_epsilon"
+    CUR_MEM_TYPE: str = "cur_mem_type"
+    GAME_BOARD: str = "game_board"
+    GAME_BOX: str = "game_box"
+    EPSILON_DECAY: str = "epsilon_decay"
+    EPSILON_INITIAL: str = "initial_epsilon"
+    EPSILON_MIN: str = "epsilon_min"
+    INPUT_10: str = "input_10"
+    LABEL: str = "label"
+    LABEL_SETTINGS: str = "label_settings"
+    MOVE_DELAY: str = "move_delay"
+    NUM_MEMORIES: str = "num_memories"
+    RUNTIME_BOX: str = "runtime_box"
+    SCORE: str = "score"
+    SETTINGS_BOX: str = "settings_box"
+    TITLE: str = "title"
+    VARIABLE: str = "variable"

ai_snake_lab/constants/DModelL.py

@@ -0,0 +1,17 @@
+"""
+constants/DModelL.py
+
+    AI Snake Game Simulator
+    Author: Nadim-Daniel Ghaznavi
+    Copyright: (c) 2024-2025 Nadim-Daniel Ghaznavi
+    GitHub: https://github.com/NadimGhaznavi/ai
+    License: GPL 3.0
+"""
+
+from utils.ConstGroup import ConstGroup
+
+
+class DModelL(ConstGroup):
+    """Linear Model Defaults"""
+
+    LEARNING_RATE: float = 0.000009

ai_snake_lab/constants/DModelLRNN.py

@@ -0,0 +1,20 @@
+"""
+constants/DModelRNN.py
+
+    AI Snake Game Simulator
+    Author: Nadim-Daniel Ghaznavi
+    Copyright: (c) 2024-2025 Nadim-Daniel Ghaznavi
+    GitHub: https://github.com/NadimGhaznavi/ai
+    License: GPL 3.0
+"""
+
+from utils.ConstGroup import ConstGroup
+
+
+class DModelRNN(ConstGroup):
+    """RNN Model Defaults"""
+
+    LEARNING_RATE: float = 0.0007
+    INPUT_SIZE: int = 400
+    MAX_MEMORIES: int = 20
+    MAX_MEMORY: int = 100000

ai_snake_lab/constants/DReplayMemory.py

@@ -0,0 +1,25 @@
+"""
+constants/DReplayMemory.py
+
+    AI Snake Game Simulator
+    Author: Nadim-Daniel Ghaznavi
+    Copyright: (c) 2024-2025 Nadim-Daniel Ghaznavi
+    GitHub: https://github.com/NadimGhaznavi/ai
+    License: GPL 3.0
+"""
+
+from utils.ConstGroup import ConstGroup
+
+
+class MEM_TYPE(ConstGroup):
+    """Replay Memory Type"""
+
+    SHUFFLE: str = "shuffle"
+    SHUFFLE_LABEL: str = "Shuffled set"
+    RANDOM_GAME: str = "random_game"
+    RANDOM_GAME_LABEL: str = "Random game"
+
+    MEM_TYPE_TABLE: dict = {
+        SHUFFLE: SHUFFLE_LABEL,
+        RANDOM_GAME: RANDOM_GAME_LABEL,
+    }

ai_snake_lab/game/GameBoard.py

@@ -0,0 +1,221 @@
+"""
+game/AISim.py
+
+    AI Snake Game Simulator
+    Author: Nadim-Daniel Ghaznavi
+    Copyright: (c) 2024-2025 Nadim-Daniel Ghaznavi
+    GitHub: https://github.com/NadimGhaznavi/ai
+    License: GPL 3.0
+"""
+
+import numpy as np
+
+from textual.scroll_view import ScrollView
+from textual.geometry import Offset, Region, Size
+from textual.strip import Strip
+from textual.reactive import var
+
+from rich.segment import Segment
+from rich.style import Style
+
+from game.GameElements import Direction
+
+emptyA = "#111111"
+emptyB = "#000000"
+food = "#940101"
+snake = "#025b02"
+snake_head = "#16e116"
+
+
+class GameBoard(ScrollView):
+    COMPONENT_CLASSES = {
+        "gameboard--emptyA-square",
+        "gameboard--emptyB-square",
+        "gameboard--food-square",
+        "gameboard--snake-square",
+        "gameboard--snake-head-square",
+    }
+
+    DEFAULT_CSS = """
+    GameBoard > .gameboard--emptyA-square {
+        background: #111111;
+    }
+    GameBoard > .gameboard--emptyB-square {
+        background: #000000;
+    }
+    GameBoard > .gameboard--food-square {
+        background: #940101;
+    }
+    GameBoard > .gameboard--snake-square {
+        background: #025b02;
+    }
+    GameBoard > .gameboard--snake-head-square {
+        background: #0ca30c;
+    }
+    """
+
+    food = var(Offset(0, 0))
+    snake_head = var(Offset(0, 0))
+    snake_body = var([])
+    direction = Direction.RIGHT
+    last_dirs = [0, 0, 1, 0]
+
+    def __init__(self, board_size: int, id=None) -> None:
+        super().__init__(id=id)
+        self._board_size = board_size
+        self.virtual_size = Size(board_size * 2, board_size)
+
+    def board_size(self) -> int:
+        return self._board_size
+
+    def get_state(self):
+
+        head = self.snake_head
+        direction = self.direction
+        point_l = Offset(head.x - 1, head.y)
+        point_r = Offset(head.x + 1, head.y)
+        point_u = Offset(head.x, head.y - 1)
+        point_d = Offset(head.x, head.y + 1)
+        dir_l = direction == Direction.LEFT
+        dir_r = direction == Direction.RIGHT
+        dir_u = direction == Direction.UP
+        dir_d = direction == Direction.DOWN
+
+        state = [
+            # 1. Snake collision straight ahead
+            (dir_r and self.is_snake_collision(point_r))
+            or (dir_l and self.is_snake_collision(point_l))
+            or (dir_u and self.is_snake_collision(point_u))
+            or (dir_d and self.is_snake_collision(point_d)),
+            # 2. Snake collision to the right
+            (dir_u and self.is_snake_collision(point_r))
+            or (dir_d and self.is_snake_collision(point_l))
+            or (dir_l and self.is_snake_collision(point_u))
+            or (dir_r and self.is_snake_collision(point_d)),
+            # 3. Snake collision to the left
+            (dir_d and self.is_snake_collision(point_r))
+            or (dir_u and self.is_snake_collision(point_l))
+            or (dir_r and self.is_snake_collision(point_u))
+            or (dir_l and self.is_snake_collision(point_d)),
+            # 4. divider
+            0,
+            # 5. Wall collision straight ahead
+            (dir_r and self.is_wall_collision(point_r))
+            or (dir_l and self.is_wall_collision(point_l))
+            or (dir_u and self.is_wall_collision(point_u))
+            or (dir_d and self.is_wall_collision(point_d)),
+            # 6. Wall collision to the right
+            (dir_u and self.is_wall_collision(point_r))
+            or (dir_d and self.is_wall_collision(point_l))
+            or (dir_l and self.is_wall_collision(point_u))
+            or (dir_r and self.is_wall_collision(point_d)),
+            # 7. Wall collision to the left
+            (dir_d and self.is_wall_collision(point_r))
+            or (dir_u and self.is_wall_collision(point_l))
+            or (dir_r and self.is_wall_collision(point_u))
+            or (dir_l and self.is_wall_collision(point_d)),
+            # 8. divider
+            0,
+            # 9, 10, 11, 12. Last move direction
+            dir_l,
+            dir_r,
+            dir_u,
+            dir_d,
+            # 13. divider
+            0,
+            # 14 - 23. Food location
+            self.food.x < self.snake_head.x,  # Food left
+            self.food.x > self.snake_head.x,  # Food right
+            self.food.y < self.snake_head.y,  # Food up
+            self.food.y > self.snake_head.y,  # Food down
+            self.food.x == self.snake_head.x,
+            self.food.x == self.snake_head.x
+            and self.food.y > self.snake_head.y,  # Food ahead
+            self.food.x == self.snake_head.x
+            and self.food.y < self.snake_head.y,  # Food behind
+            self.food.y == self.snake_head.y,
+            self.food.y == self.snake_head.y
+            and self.food.x > self.snake_head.x,  # Food above
+            self.food.y == self.snake_head.y
+            and self.food.x < self.snake_head.x,  # Food below
+        ]
+
+        # 24, 25, 26 and 27. Previous direction of the snake
+        for aDir in self.last_dirs:
+            state.append(int(aDir))
+        self.last_dirs = [dir_l, dir_r, dir_u, dir_d]
+
+        return np.array(state, dtype="int8")
+
+    def is_snake_collision(self, pt: Offset) -> bool:
+        if pt in self.snake_body:
+            return True
+        return False
+
+    def is_wall_collision(self, pt: Offset) -> bool:
+        if pt.x >= self._board_size or pt.x < 0 or pt.y >= self._board_size or pt.y < 0:
+            return True
+        return False
+
+    def render_line(self, y: int) -> Strip:
+        scroll_x, scroll_y = self.scroll_offset
+        y += scroll_y
+        row_index = y
+
+        emptyA = self.get_component_rich_style("gameboard--emptyA-square")
+        emptyB = self.get_component_rich_style("gameboard--emptyB-square")
+        food = self.get_component_rich_style("gameboard--food-square")
+        snake = self.get_component_rich_style("gameboard--snake-square")
+        snake_head = self.get_component_rich_style("gameboard--snake-head-square")
+
+        if row_index >= self._board_size:
+            return Strip.blank(self.size.width)
+
+        is_odd = row_index % 2
+
+        def get_square_style(column: int, row: int) -> Style:
+            if self.food == Offset(column, row):
+                square_style = food
+            elif self.snake_head == Offset(column, row):
+                square_style = snake_head
+            elif Offset(column, row) in self.snake_body:
+                square_style = snake
+            else:
+                square_style = emptyA if (column + is_odd) % 2 else emptyB
+            return square_style
+
+        segments = [
+            Segment(" " * 2, get_square_style(column, row_index))
+            for column in range(self._board_size)
+        ]
+        strip = Strip(segments, self._board_size * 2)
+        # Crop the strip so that is covers the visible area
+        strip = strip.crop(scroll_x, scroll_x + self.size.width)
+        return strip
+
+    def watch_food(self, previous_food: Offset, food: Offset) -> None:
+        """Called when the food square changes."""
+
+        def get_square_region(square_offset: Offset) -> Region:
+            """Get region relative to widget from square coordinate."""
+            x, y = square_offset
+            region = Region(x * 2, y, 2, 1)
+            # Move the region into the widgets frame of reference
+            region = region.translate(-self.scroll_offset)
+            return region
+
+        # Refresh the previous food square
+        self.refresh(get_square_region(previous_food))
+
+        # Refresh the new food square
+        self.refresh(get_square_region(food))
+
+    def update_food(self, food: Offset) -> None:
+        self.food = food
+        self.refresh()
+
+    def update_snake(self, snake: list[Offset], direction: Direction) -> None:
+        self.direction = direction
+        self.snake_head = snake[0]
+        self.snake_body = snake[1:]
+        self.refresh()

ai_snake_lab/game/GameElements.py

@@ -0,0 +1,27 @@
+"""
+game/GameElements.py
+
+    AI Snake Game Simulator
+    Author: Nadim-Daniel Ghaznavi
+    Copyright: (c) 2024-2025 Nadim-Daniel Ghaznavi
+    GitHub: https://github.com/NadimGhaznavi/ai
+    License: GPL 3.0
+"""
+
+from enum import Enum
+
+
+class Direction(Enum):
+    """
+    A simple Enum class that represents a direction in the
+    Snake game. It has four values:
+    1. RIGHT
+    2. LEFT
+    3. UP
+    4. DOWN
+    """
+
+    RIGHT = 1
+    LEFT = 2
+    UP = 3
+    DOWN = 4

ai_snake_lab/game/SnakeGame.py

@@ -0,0 +1,178 @@
+"""
+game/SnakeGame.py
+
+    AI Snake Game Simulator
+    Author: Nadim-Daniel Ghaznavi
+    Copyright: (c) 2024-2025 Nadim-Daniel Ghaznavi
+    GitHub: https://github.com/NadimGhaznavi/ai
+    License: GPL 3.0
+"""
+
+import time
+import random
+import numpy as np
+
+from textual.geometry import Offset
+
+from game.GameBoard import GameBoard
+from game.GameElements import Direction
+
+# Maximum number of moves. This is multiplied by the length of the snake. The game
+# ends if game moves > MAX_MOVES * length-of-snake. This avoids enless AI looping behavior.
+MAX_MOVES = 100
+
+
+class SnakeGame:
+
+    def __init__(self, game_board: GameBoard, id=None):
+        # Make multiple runs predictable
+        random.seed(1970)
+
+        # Get an instance of the game board and it's dimensions
+        self.game_board = game_board
+        board_size = self.game_board.board_size()
+
+        # Track the number of moves
+        self.moves = 0
+
+        # Track the reward within a given game
+        self.game_reward = 0
+
+        # Set the initial snake direction and position
+        self.direction = Direction.RIGHT
+        self.head = Offset(board_size // 2, board_size // 2)
+        self.snake = [
+            self.head,
+            Offset(self.head.x - 1, self.head.y),
+            Offset(self.head.x - 2, self.head.y),
+        ]
+
+        # Place a food in a random location (not occupied by the snake)
+        self.food = self.place_food()
+
+        # Update the game board
+        self.game_board.update_snake(snake=self.snake, direction=self.direction)
+        self.game_board.update_food(food=self.food)
+
+        # The current game score
+        self.game_score = 0
+
+    def get_direction(self):
+        return self.direction
+
+    def move(self, action):
+        clock_wise = [Direction.RIGHT, Direction.DOWN, Direction.LEFT, Direction.UP]
+        idx = clock_wise.index(self.direction)
+        if np.array_equal(action, [1, 0, 0]):
+            new_dir = clock_wise[idx]  # no change
+        elif np.array_equal(action, [0, 1, 0]):
+            next_idx = (idx + 1) % 4  # Mod 4 to avoid out of index error
+            new_dir = clock_wise[next_idx]  # right turn r -> d -> l -> u
+        else:  # [0, 0, 1] ... there are only 3 actions
+            next_idx = (idx - 1) % 4  # Again, MOD 4 to avoid out of index error
+            new_dir = clock_wise[next_idx]  # left turn r -> u -> l -> d
+        self.direction = new_dir
+
+        old_head = self.head
+
+        if self.direction == Direction.RIGHT:
+            self.head = Offset(self.head.x + 1, self.head.y)
+        elif self.direction == Direction.LEFT:
+            self.head = Offset(self.head.x - 1, self.head.y)
+        elif self.direction == Direction.DOWN:
+            self.head = Offset(self.head.x, self.head.y + 1)
+        elif self.direction == Direction.UP:
+            self.head = Offset(self.head.x, self.head.y - 1)
+
+        # self.snake.insert(0, self.head)
+
+    def place_food(self):
+        board_size = self.game_board.board_size()
+        x = random.randint(0, board_size - 1)
+        y = random.randint(0, board_size - 1)
+        self.food = Offset(x, y)
+        if self.food in self.snake:
+            self.place_food()
+        return self.food
+
+    def play_step(self, action):
+        ## 1. Move
+        self.move(action)
+        self.snake.insert(0, self.head)
+        self.game_board.update_snake(snake=self.snake, direction=self.direction)
+        snake_length = len(self.snake)
+        max_moves = 100
+
+        ## 2. Check if the game is over
+        reward = 0
+        game_over = False
+        board_size = self.game_board.board_size()
+
+        ## 3. Check for "game over" states
+
+        # Wall collision
+        if self.game_board.is_wall_collision(self.head):
+            # Wall collision
+            game_over = True
+            reward = -10
+
+        # Snake collision
+        elif self.game_board.is_snake_collision(self.head):
+            game_over = True
+            reward = -10
+
+        # Exceeded max moves
+        if self.moves > max_moves * snake_length:
+            game_over = True
+            reward = -10
+
+        if game_over == True:
+            # Game is over: Snake or wall collision or exceeded max moves
+            self.game_reward += reward
+            return reward, game_over, self.game_score
+
+        ## 4. Game is not over, lets see what else is going on
+
+        if self.head == self.food:
+            # We found food!!
+            self.game_reward += 10
+            self.place_food()
+            self.game_score += 1
+
+        else:
+            self.snake.pop()
+
+        self.game_reward += reward
+        self.game_board.update_snake(snake=self.snake, direction=self.direction)
+        self.game_board.update_food(food=self.food)
+        self.moves += 1
+        return reward, game_over, self.game_score
+
+    def reset(self):
+        # Reset the game reward
+        self.game_reward = 0
+
+        # Get the board size
+        board_size = self.game_board.board_size()
+
+        # Reset the number of moves
+        self.moves = 0
+
+        # Set the initial snake direction and position
+        self.direction = Direction.RIGHT
+        self.head = Offset(board_size // 2, board_size // 2)
+        self.snake = [
+            self.head,
+            Offset(self.head.x - 1, self.head.y),
+            Offset(self.head.x - 2, self.head.y),
+        ]
+
+        # Place a food in a random location (not occupied by the snake)
+        self.food = self.place_food()
+
+        # Update the game board
+        self.game_board.update_snake(snake=self.snake, direction=self.direction)
+        self.game_board.update_food(food=self.food)
+
+        # The current game score
+        self.game_score = 0