reformat: migrated board to cython

Author: lmProgramming

.github/workflows/python-app.yml

@@ -23,13 +23,15 @@ jobs:
         with:
           python-version: "3.10"
           architecture: "x64"
-        env:
-          AGENT_TOOLSDIRECTORY: /opt/hostedtoolcache
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
           pip install flake8 pytest
           if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+      - name: Cython
+        run: |
+          cd lab02
+          python setup.py build_ext --inplace
       #- name: Lint with flake8
       #  run: |
       #    # stop the build if there are Python syntax errors or undefined names
@@ -38,4 +40,5 @@ jobs:
       #    flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
       - name: Test with pytest
         run: |
+          cd lab02
           pytest

lab02/clobber/.gitignore

@@ -0,0 +1 @@
+*.c

lab02/clobber/board.pxd

@@ -0,0 +1,11 @@
+cdef class Board:
+    cdef public int n
+    cdef public int m
+    cdef public int turn
+    cdef public list state
+
+    cpdef get_piece_at(self, tuple position)
+    cpdef replace_piece_at(self, tuple position, object new_piece)
+    cpdef list get_neighbours_positions_filtered(self, tuple position, object piece_filter)
+    cpdef list get_all_pieces(self, object piece)
+    cpdef bint has_moves(self, bint white)

lab02/clobber/board.py

@@ -0,0 +1,41 @@
+from typing import Callable, List, Tuple, Dict, Any
+from clobber.types import piece_type, move
+
+
+class Board:
+    n: int
+    m: int
+    turn: int
+    state: List[str]
+
+    def __init__(self, n: int, m: int,
+                 state: List[str], turn: int = 0) -> None: ...
+
+    @staticmethod
+    def initialize_board(
+        n: int, m: int) -> 'Board': ...
+
+    def copy(self) -> 'Board': ...
+
+    def __str__(self) -> str: ...
+    def pretty(self) -> str: ...
+
+    def get_piece_at(self, position: Tuple[int, int]) -> piece_type: ...
+
+    def replace_piece_at(
+        self, position: Tuple[int, int], new_piece: piece_type) -> piece_type: ...
+
+    def get_neighbours_positions(
+        self, position: Tuple[int, int]) -> List[Tuple[int, int]]: ...
+    def get_neighbours_positions_filtered(self, position: Tuple[int, int], piece_filter: Callable[[
+                                          piece_type], bool]) -> List[Tuple[int, int]]: ...
+
+    def make_move(self, new_color: piece_type, m: move) -> None: ...
+    def move_assuming_correct(
+        self, new_color: piece_type, m: move) -> None: ...
+
+    def get_all_pieces(self, piece: piece_type) -> List[Tuple[int, int]]: ...
+    def generate_moves(
+        self, for_white: bool) -> Dict[Tuple[int, int], List[Tuple[int, int]]]: ...
+
+    def has_moves(self, white: bool) -> bool: ...

lab02/clobber/board.pyi

@@ -0,0 +1,147 @@
+from typing import Callable
+
+from clobber.types cimport move
+
+cdef class Board:
+
+    def __init__(self, int n, int m, list state, int turn=0):
+        self.n = n
+        self.m = m
+        self.state = list(state)
+        self.turn = turn
+
+    @staticmethod
+    def initialize_board(int n, int m):
+        state_py = []
+        cdef int y
+        cdef bint white_py
+
+        for y in range(n):
+            line_py = []
+            white_py = (y % 2 == 0)
+            for _ in range(m):
+                line_py.append("W" if white_py else "B")
+                white_py = not white_py
+            state_py.append(" ".join(line_py))
+
+        board = Board(n, m, state_py)
+        return board
+
+    def copy(self):
+        return Board(self.n, self.m, [row for row in self.state], self.turn)
+
+    def __str__(self):
+        return "\n".join(self.state)
+
+    def pretty(self):
+        result_py = ["  " + " ".join(map(str, range(self.m)))]
+        cdef int y
+        for y in range(self.n):
+            result_py.append(str(y) + " " + str(self.state[y]))
+        return "\n".join(result_py)
+
+    cpdef get_piece_at(self, tuple position):
+        cdef int x, y
+        x, y = position
+
+        if x < 0 or y < 0 or y >= self.n or x >= self.m:
+            return 'outside'
+
+        row_str = <str>self.state[y]
+        pieces = row_str.split(' ')
+        return pieces[x]
+
+
+    cpdef replace_piece_at(self, tuple position, object new_piece):
+        cdef int x, y
+        x, y = position
+
+        if x < 0 or y < 0 or y >= self.n or x >= self.m:
+            return 'outside'
+
+        row_str = <str>self.state[y]
+        pieces = row_str.split(' ')
+        if x < len(pieces):
+            pieces[x] = <str>new_piece
+            self.state[y] = " ".join(pieces)
+            return new_piece
+        else:
+            return 'error_index'
+
+    def get_neighbours_positions(self, tuple position):
+        return self.get_neighbours_positions_filtered(position, lambda p: p in ["B", "W"])
+
+    cpdef list get_neighbours_positions_filtered(self, tuple position, object piece_filter):
+        cdef int x, y
+        cdef list neighbours_positions_py = []
+        cdef tuple check_pos
+        cdef object piece
+
+        x, y = position
+
+        positions_to_check = [(x - 1, y), (x + 1, y), (x, y - 1), (x, y + 1)]
+        for check_pos in positions_to_check:
+            piece = self.get_piece_at(check_pos)
+            if piece_filter(piece):
+                neighbours_positions_py.append(check_pos)
+
+        return neighbours_positions_py
+
+    def make_move(self, object new_color, move m):
+        cdef tuple position_from, position_to
+        position_from, position_to = m
+        if self.get_piece_at(position_from) != new_color:
+            raise Exception("make_move check failed: piece is not player's color")
+        opponent_color = <object>("B" if new_color == 'W' else 'W')
+        if self.get_piece_at(position_to) != opponent_color:
+             raise Exception("make_move check failed: target is not opponent")
+
+        self.replace_piece_at(position_from, '_')
+        self.replace_piece_at(position_to, new_color)
+        self.turn += 1
+
+    def move_assuming_correct(self, object new_color, move m):
+        cdef tuple position_from, position_to
+        position_from, position_to = m
+        self.replace_piece_at(position_from, '_')
+        self.replace_piece_at(position_to, new_color)
+        self.turn += 1
+
+    cpdef list get_all_pieces(self, object piece):
+        cdef list positions_py = []
+        cdef int x, y
+        for y in range(self.n):
+            for x in range(self.m):
+                if self.get_piece_at((x, y)) == piece:
+                    positions_py.append((x, y))
+        return positions_py
+
+    def generate_moves(self, bint for_white):
+        cdef dict possible_moves_py = {}
+        cdef object opponent, current_piece
+        cdef int x, y
+        cdef list neighbouring_opponents_py
+
+        opponent = <object>('B' if for_white else 'W')
+        current_piece = <object>('W' if for_white else 'B')
+
+        for y in range(self.n):
+            for x in range(self.m):
+                if self.get_piece_at((x, y)) != current_piece:
+                    continue
+
+                def opponent_filter(p):
+                    return p == opponent
+
+                neighbouring_opponents_py = self.get_neighbours_positions_filtered(
+                    (x, y), opponent_filter)
+
+                if not neighbouring_opponents_py:
+                    continue
+
+                possible_moves_py[(x, y)] = neighbouring_opponents_py
+
+        return possible_moves_py
+
+    cpdef bint has_moves(self, bint white):
+        return len(self.generate_moves(white)) > 0

lab02/clobber/board.pyx

@@ -5,8 +5,8 @@
 
 @pytest.mark.parametrize(("dimensions", "expected"),
                          [
-    ((5, 6), "W_B_W_B_W_B\nB_W_B_W_B_W\nW_B_W_B_W_B\nB_W_B_W_B_W\nW_B_W_B_W_B"),
-    ((10, 10), "W_B_W_B_W_B_W_B_W_B\nB_W_B_W_B_W_B_W_B_W\nW_B_W_B_W_B_W_B_W_B\nB_W_B_W_B_W_B_W_B_W\nW_B_W_B_W_B_W_B_W_B\nB_W_B_W_B_W_B_W_B_W\nW_B_W_B_W_B_W_B_W_B\nB_W_B_W_B_W_B_W_B_W\nW_B_W_B_W_B_W_B_W_B\nB_W_B_W_B_W_B_W_B_W")
+    ((5, 6), "W B W B W B\nB W B W B W\nW B W B W B\nB W B W B W\nW B W B W B"),
+    ((10, 10), "W B W B W B W B W B\nB W B W B W B W B W\nW B W B W B W B W B\nB W B W B W B W B W\nW B W B W B W B W B\nB W B W B W B W B W\nW B W B W B W B W B\nB W B W B W B W B W\nW B W B W B W B W B\nB W B W B W B W B W")
 ])
 def test_board_generation(dimensions: tuple[int, int], expected: str) -> None:
     board: Board = Board.initialize_board(*dimensions)

lab02/clobber/board_test.py

@@ -0,0 +1 @@
+ctypedef tuple move

lab02/clobber/types.pxd

@@ -0,0 +1,20 @@
+from setuptools import setup, Extension
+from Cython.Build import cythonize  # type: ignore
+import os
+
+extensions = [
+    Extension(
+        "clobber.board",
+        [os.path.join("clobber", "board.pyx")],
+    ),
+]
+
+setup(
+    name="ClobberGame",
+    ext_modules=cythonize(
+        extensions,
+        compiler_directives={'language_level': "3"}
+    ),
+    packages=['clobber'],
+    zip_safe=False,
+)