initial commit

blokus.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python
+import numpy as np
+import random
+
+BOARD_SIZE = 14
+
+def make_board():
+    a = np.array([[0 for i in range(BOARD_SIZE)] for j in range(BOARD_SIZE)])
+    a[4,4] = -1
+    a[9,9] = -1
+    return a
+
+tiles = [
+    np.array([[1]]),
+    np.array([[1],[1]]),
+    np.array([[1],[1],[1]]),
+    np.array([[1,0],[1,1]]),
+    np.array([[1],[1],[1],[1]]),
+    np.array([[1,0],[1,0],[1,1]]),
+    np.array([[1,0],[1,1],[1,0]]),
+    np.array([[1,1],[1,1]]),
+    np.array([[1,1,0],[0,1,1]]),
+    np.array([[1],[1],[1],[1],[1]]),
+    np.array([[1,0],[1,0],[1,0],[1,1]]),
+    np.array([[1,0],[1,0],[1,1],[0,1]]),
+    np.array([[1,0],[1,1],[1,1]]),
+    np.array([[1,1],[1,0],[1,1]]),
+    np.array([[1,0],[1,1],[1,0],[1,0]]),
+    np.array([[0,1,0],[0,1,0],[1,1,1]]),
+    np.array([[1,0,0],[1,0,0],[1,1,1]]),
+    np.array([[1,1,0],[0,1,1],[0,0,1]]),
+    np.array([[1,0,0],[1,1,1],[0,0,1]]),
+    np.array([[1,0,0],[1,1,1],[0,1,0]]),
+    np.array([[0,1,0],[1,1,1],[0,1,0]]),
+]
+
+
+def get_permutations(which_tiles: list[tuple[int,int]]):
+    permutations = []
+    for i,tile in enumerate(tiles):
+        if i not in which_tiles:
+            continue
+        permutations.append((i,tile))
+        permutations.append((i,np.rot90(tile)))
+        permutations.append((i,np.rot90(np.rot90(tile))))
+        permutations.append((i,np.rot90(np.rot90(np.rot90(tile)))))
+        permutations.append((i,np.flip(tile)))
+        permutations.append((i,np.flip(np.rot90(tile))))
+        permutations.append((i,np.flip(np.rot90(np.rot90(tile)))))
+        permutations.append((i,np.flip(np.rot90(np.rot90(np.rot90(tile))))))
+
+    unique_arrays = []
+    for arr in permutations:
+        if not any(np.array_equal(arr, u) for u in unique_arrays):
+            unique_arrays.append(arr)
+
+    return unique_arrays
+
+def can_place(board, tile, player):
+    placements = []
+    has_minus_one = False
+    for x in range(BOARD_SIZE):
+        for y in range(BOARD_SIZE):
+            if board[x,y] == -1:
+                has_minus_one = True
+            with np.nditer(tile, flags=['multi_index']) as it:
+                for v in it:
+                    if v == 1:
+                        (i,j) = it.multi_index
+                        if x + i >= BOARD_SIZE:
+                            break
+                        if y + j >= BOARD_SIZE:
+                            break
+                        if board[x + i][y + j] > 0:
+                            break
+                        if x + i - 1 >= 0 and board[x + i - 1][y+j] == player:
+                            break
+                        if y + j - 1 >= 0 and board[x + i][y + j - 1] == player:
+                            break
+                        if x + i + 1 < BOARD_SIZE and board[x + i + 1][y+j] == player:
+                            break
+                        if y + j + 1 < BOARD_SIZE and board[x + i][y+j+1] == player:
+                            break
+                else:
+                    placements.append((x,y))
+    final = []
+    if has_minus_one:
+        for (x,y) in placements:
+            with np.nditer(tile, flags=['multi_index']) as it:
+                for v in it:
+                    (i,j) = it.multi_index
+                    if v == 1 and board[x+i,y+j] == -1:
+                        final.append((x,y))
+                        break
+    else:
+        for (x,y) in placements:
+            with np.nditer(tile, flags=['multi_index']) as it:
+                for v in it:
+                    (i,j) = it.multi_index
+                    if x+i+1 < BOARD_SIZE and y+j+1 < BOARD_SIZE and board[x+i+1][y+j+1] == player:
+                        final.append((x,y))
+                        break
+                    if x+i+1 < BOARD_SIZE and y+j-1 >= 0 and board[x+i+1][y+j-1] == player:
+                        final.append((x,y))
+                        break
+                    if x+i-1 >= 0 and y+j+1 < BOARD_SIZE and board[x+i-1][y+j+1] == player:
+                        final.append((x,y))
+                        break
+                    if x+i-1 >= 0 and y+j-1 >= 0 and board[x+i-1][y+j-1] == player:
+                        final.append((x,y))
+                        break
+    return final
+
+def do_placement(tidx, tile, placement, game_state, player):
+    (x,y) = placement
+    with np.nditer(tile, flags=['multi_index']) as it:
+        for v in it:
+            (i,j) = it.multi_index
+            if v == 1:
+                game_state[0][x+i,y+j] = player
+    game_state[player].remove(tidx)
+
+def print_game_state(game_state):
+    (board, p1tiles, p2tiles) = game_state
+
+    for row in board:
+        print("".join([" " if x == 0 else "X" if x == 1 else "O" if x == 2 else "S" for x in row]))
+
+    print("")
+    print(f"Player 1 tiles left: {p1tiles}")
+    print(f"Player 2 tiles left: {p2tiles}")
+
+game_state = (
+    make_board(),
+    [i for i in range(21)],
+    [i for i in range(21)],
+)
+
+
+playing = True
+player = 1
+while playing:
+    moves = []
+    for (tidx, tile) in get_permutations(game_state[player]):
+        for placement in can_place(game_state[0], tile, player):
+            moves.append((tidx, tile, placement))
+
+    print_game_state(game_state)
+    print(f"player {player} has {len(moves)} options")
+
+    if len(moves) == 0:
+        print(f"No moves left, player {player} lost")
+        playing = False
+        continue
+
+    (tidx, tile, placement) = random.choice(moves)
+    do_placement(tidx, tile, placement, game_state, player)
+
+
+    if player == 1:
+        player = 2
+    elif player == 2:
+        player = 1
+
+