multi-puzzle-solver 0.8.7__py3-none-any.whl → 0.9.1__py3-none-any.whl

{multi_puzzle_solver-0.8.7.dist-info → multi_puzzle_solver-0.9.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multi-puzzle-solver
-Version: 0.8.7
+Version: 0.9.1
 Summary: Efficient solvers for numerous popular and esoteric logic puzzles using CP-SAT
 Author: Ar-Kareem
 Project-URL: Homepage, https://github.com/Ar-Kareem/puzzle_solver
@@ -210,8 +210,16 @@ These are all the puzzles that are implemented in this repo. <br> Click on any o
       <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/chess_range_unsolved.png" alt="Chess range" height="120">
     </a>
   </td>
-  
-  </td><td></td><td></td>
+  <td align="center">
+    <a href="#chess-solo-puzzle-type-24"><b>Chess Solo</b><br><br>
+      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/chess_solo_unsolved.png" alt="Chess solo" height="120">
+    </a>
+  </td>
+  <td align="center">
+    <a href="#chess-melee-puzzle-type-25"><b>Chess Melee</b><br><br>
+      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/chess_melee_unsolved.png" alt="Chess melee" height="120">
+    </a>
+  </td>
 </tr>
 </table>
 
@@ -249,9 +257,10 @@ These are all the puzzles that are implemented in this repo. <br> Click on any o
   - [Bridges (Puzzle Type #20)](#bridges-puzzle-type-20)
   - [Inertia (Puzzle Type #21)](#inertia-puzzle-type-21)
   - [Guess (Puzzle Type #22)](#guess-puzzle-type-22)
-  - [Chess Range(Puzzle Type #23)](#chess-rangepuzzle-type-23)
+  - [Chess Range (Puzzle Type #23)](#chess-range-puzzle-type-23)
+  - [Chess Solo (Puzzle Type #24)](#chess-solo-puzzle-type-24)
+  - [Chess Melee (Puzzle Type #25)](#chess-melee-puzzle-type-25)
   - [Why SAT / CP-SAT?](#why-sat--cp-sat)
-  - [What’s Inside](#whats-inside)
   - [Testing](#testing)
   - [Contributing](#contributing)
     - [Build and push to PyPI](#build-and-push-to-pypi)
@@ -1935,7 +1944,7 @@ In the case when there's only one possible choice left, the solver will inform y
 
 ---
 
-## Chess Range(Puzzle Type #23)
+## Chess Range (Puzzle Type #23)
 
 * [**Play online**](https://www.puzzle-chess.com/chess-ranger-11/)
 
@@ -1944,7 +1953,7 @@ In the case when there's only one possible choice left, the solver will inform y
 <details>
   <summary><strong>Rules</strong></summary>
 
-You are given a chess board with $N$ pieces distributed on it. Your aim is to make $N-1$ range of moves where each move is a legal chess move and captures another piece.
+You are given a chess board with $N$ pieces distributed on it. Your aim is to make $N-1$ sequence of moves where each move is a legal chess move and captures another piece.
 
 - Pieces move as standard chess pieces.
 - You can perform only capture moves. A move that does not capture another piece is not allowed.
@@ -1977,7 +1986,7 @@ Solution found
 ['Rg2->Pc2', 'Rc2->Bc3', 'Rc3->Pd3', 'Kb6->Pb5', 'Pg4->Nf5', 'Rd3->Rb3', 'Rb3->Kb5', 'Nc6->Qe7', 'Ne7->Pf5', 'Rb5->Nf5']
 Solutions found: 1
 status: FEASIBLE
-Time taken: 6.27 seconds
+Time taken: 1.16 seconds
 ```
 
 **Solved puzzle**
@@ -1986,6 +1995,108 @@ Time taken: 6.27 seconds
 
 ---
 
+## Chess Solo (Puzzle Type #24)
+
+* [**Play online**](https://www.puzzle-chess.com/solo-chess-11/)
+
+* [**Solver Code**][24]
+
+<details>
+  <summary><strong>Rules</strong></summary>
+
+You are given a chess board with $N$ pieces distributed on it. Your aim is to make $N-1$ sequence of moves where each move is a legal chess move and captures another piece and end up with the king as the only piece on the board. You are not allowed to move a piece more than twice.
+
+- Pieces move as standard chess pieces.
+- You can perform only capture moves. A move that does not capture another piece is not allowed.
+- You can move a piece only twice.
+- You are NOT allowed to capture the king.
+- The goal is to end up with one single piece (the king) on the board. 
+
+</details>
+
+**Unsolved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/chess_solo_unsolved.png" alt="Chess solo unsolved" width="500">
+
+Code to utilize this package and solve the puzzle:
+
+(Note that this puzzle does not typically have a unique solution. Thus, we specify here that we only want the first valid solution that the solver finds.)
+
+```python
+# algebraic notation
+board = ['Kc6', 'Rc5', 'Rc4', 'Pb3', 'Bd3', 'Pd2', 'Pe3', 'Nf2', 'Ng2', 'Qg3', 'Pg6']
+binst = solver.Board(board)
+solutions = binst.solve_and_print(max_solutions=1)
+```
+**Script Output**
+
+The output is in the form of "pos -> pos" where "pos" is the algebraic notation of the position.
+
+```python
+Solution found
+['Qg3->Pg6', 'Qg6->Bd3', 'Pd2->Pe3', 'Ng2->Pe3', 'Nf2->Qd3', 'Ne3->Rc4', 'Pb3->Nc4', 'Nd3->Rc5', 'Kc6->Nc5', 'Kc5->Pc4']
+Solutions found: 1
+status: FEASIBLE
+Time taken: 0.47 seconds
+```
+
+**Solved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/chess_solo_solved.png" alt="Chess solo solved" width="500">
+
+---
+
+## Chess Melee (Puzzle Type #25)
+
+* [**Play online**](https://www.puzzle-chess.com/chess-melee-13/)
+
+* [**Solver Code**][25]
+
+<details>
+  <summary><strong>Rules</strong></summary>
+
+You are given a chess board with $N$ pieces distributed on it (equal white and black pieces, one more black if $N$ is odd). Your aim is to make $N-1$ sequence of moves where each move is a legal chess move and captures another piece of the opposite color and end up with a single piece on the board. White starts and colors alternate as usual.
+
+- Pieces move as standard chess pieces.
+- White moves first.
+- You can perform only capture moves. A move that does not capture another piece of the opposite color is not allowed.
+- The goal is to end up with one single piece on the board. 
+
+</details>
+
+**Unsolved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/chess_melee_unsolved.png" alt="Chess melee unsolved" width="500">
+
+Code to utilize this package and solve the puzzle:
+
+(Note that this puzzle does not typically have a unique solution. Thus, we specify here that we only want the first valid solution that the solver finds.)
+
+```python
+# algebraic notation
+board = ['Pb7', 'Nc7', 'Bc6', 'Ne6', 'Pb5', 'Rc4', 'Qb3', 'Rf7', 'Rb6', 'Pe5', 'Nc3', 'Pd3', 'Nf3']
+colors = ['B', 'B', 'B', 'B', 'B', 'B', 'B', 'W', 'W', 'W', 'W', 'W', 'W']
+binst = solver.Board(board, colors)
+solutions = binst.solve_and_print()
+```
+**Script Output**
+
+The output is in the form of "pos -> pos" where "pos" is the algebraic notation of the position.
+
+```python
+Solution found
+['Rf7->Nc7', 'Ne6->Rc7', 'Pd3->Rc4', 'Qb3->Nc3', 'Pc4->Pb5', 'Qc3->Pe5', 'Nf3->Qe5', 'Nc7->Pb5', 'Ne5->Bc6', 'Pb7->Nc6', 'Rb6->Nb5', 'Pc6->Rb5']
+Solutions found: 1
+status: OPTIMAL
+Time taken: 6.24 seconds
+```
+
+**Solved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/chess_melee_solved.png" alt="Chess melee solved" width="500">
+
+---
+
 ---
 
 ## Why SAT / CP-SAT?
@@ -2000,36 +2111,6 @@ This repo builds those constraints in Python and uses SAT/CP-SAT (e.g., OR-Tools
 
 ---
 
-## What’s Inside
-
-Each sub directory in `src/puzzle_solver/puzzles/` targets a different puzzle type. The following are the sub directories:
-
-* `nonograms` — Picross/Griddlers (run-length constraints). ([Chapter 10][1])
-* `sudoku` — Sudoku (rows/cols/blocks all-different). ([Chapter 11][2])
-* `minesweeper` — Minesweeper (mines + counts). ([Chapter 12][3])
-* `guess` — Guess (similar to wordle, guess the colored circles). ([Chapter 15][22])
-* `dominosa` — Dominosa (dominoes + counts). ([Chapter 17][4])
-* `light_up` — *Akari* / Light Up (lighting & adjacency). ([Chapter 21][5])
-* `map` — Map (region coloring). ([Chapter 22][18])
-* `inertia` — Inertia (collect all gems without dying (with least number of moves; my addition)). ([Chapter 24][21])
-* `tents` — Tents (tree-tent matching). ([Chapter 25][6])
-* `bridges` — Bridges (island connections). ([Chapter 26][20])
-* `filling` — Filling (Fillomino-style), region sizes. ([Chapter 29][7])
-* `keen` — Keen (arithmetic operations). ([Chapter 30][8])
-* `towers` — Skyscrapers (permutation + visibility). ([Chapter 31][9])
-* `singles` — Singles (hiding numbers). ([Chapter 32][10])
-* `magnets` — Magnets (polarized dominoes + counts). ([Chapter 33][11])
-* `signpost` — Signpost (visible dominoes + counts). ([Chapter 34][12])
-* `range` — Range (rays & totals). ([Chapter 35][13])
-* `pearl` — Pearl (pearl game). ([Chapter 36][19])
-* `undead` — UnDead (Vampires/Zombies/Ghosts). ([Chapter 37][14])
-* `unruly` — Unruly (no triples + balance). ([Chapter 38][15])
-* `tracks` — Tracks (connected components). ([Chapter 40][16])
-* `mosaic` — Mosaic (Tapa-like tiling). ([Chapter 42][17])
-* `chess_range` — Chess Range (chess moves). ([Puzzle-Chess][23])
-
----
-
 ## Testing
 
 To run the tests, simply run the following (to create a fresh conda environment and install the dev dependencies):
@@ -2090,3 +2171,5 @@ Issues and PRs welcome!
 [16]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/tracks "puzzle_solver/src/puzzle_solver/puzzles/tracks at master · Ar-Kareem/puzzle_solver · GitHub"
 [17]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/mosaic "puzzle_solver/src/puzzle_solver/puzzles/mosaic at master · Ar-Kareem/puzzle_solver · GitHub"
 [23]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/chess_range "puzzle_solver/src/puzzle_solver/puzzles/chess_range at master · Ar-Kareem/puzzle_solver · GitHub"
+[24]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/chess_range#chess-solo-puzzle-type-24 "puzzle_solver/src/puzzle_solver/puzzles/chess_range at master · Ar-Kareem/puzzle_solver · GitHub"
+[25]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/chess_range#chess-melee-puzzle-type-25 "puzzle_solver/src/puzzle_solver/puzzles/chess_range at master · Ar-Kareem/puzzle_solver · GitHub"

{multi_puzzle_solver-0.8.7.dist-info → multi_puzzle_solver-0.9.1.dist-info}/RECORD

@@ -1,15 +1,17 @@
-puzzle_solver/__init__.py,sha256=E6zLTG4lv93Tr8Emb5LBfzRLNJOSe7AfTrW4LT7DTak,1655
+puzzle_solver/__init__.py,sha256=SnID9DFBEgsMeeEJlk9ielo5xbMxM55Ce_4ZGQnA55s,1813
 puzzle_solver/core/utils.py,sha256=3LlBDuie_G0uSlzibpQS2ULmEYSZmpJXh1kawj7rjkg,3396
 puzzle_solver/core/utils_ortools.py,sha256=qLTIzmITqmgGZvg8XpYAZ4c-lhD5sEDQfS8ECdQ_dkM,3005
 puzzle_solver/puzzles/bridges/bridges.py,sha256=zUT0TMIu8l982fqDMJfsTnTgqm48nG0iH8flsGT45_E,5489
-puzzle_solver/puzzles/chess_range/chess_range.py,sha256=6ap3Wouf2PxHV4P56B9ol1QT98Ym6VHaxorQZWl6LnY,13692
+puzzle_solver/puzzles/chess_range/chess_melee.py,sha256=KnfD_Sxd8bso46eQYpIemp4MIqOUNoonyRVe6soK8kc,231
+puzzle_solver/puzzles/chess_range/chess_range.py,sha256=IaldwJR4d0VAUxME2QyvtJdUNzGzDV0FGs1iq9KqsRU,21072
+puzzle_solver/puzzles/chess_range/chess_solo.py,sha256=U3v766UsZHx_dC3gxqU90VbjAXn-OlYhtrnnvJYFvrQ,401
 puzzle_solver/puzzles/chess_sequence/chess_sequence.py,sha256=6ap3Wouf2PxHV4P56B9ol1QT98Ym6VHaxorQZWl6LnY,13692
 puzzle_solver/puzzles/dominosa/dominosa.py,sha256=uh2vsba9HdSHGnYiYE8R_TZzQh5kge51Y1TMRyQlwek,7246
 puzzle_solver/puzzles/filling/filling.py,sha256=UAkNYjlfxOrYGrRVmuElhWPeW10xD6kiWuB8oELzy3w,9141
 puzzle_solver/puzzles/guess/guess.py,sha256=w8ZE-0MswR1_e7_MX622OiCJ8fGTloRHblYFvSA4yHc,10812
 puzzle_solver/puzzles/inertia/inertia.py,sha256=xHtQ09sI7hqPcs20foz6YVMuYCsw59TZQxTumAKJuBs,5658
 puzzle_solver/puzzles/inertia/tsp.py,sha256=qMyT_W5vBmmaFUB7Cl9rC5xJNdAdQvIJEx6yxlbG9hw,15240
-puzzle_solver/puzzles/inertia/parse_map/parse_map.py,sha256=DCV8oI4lAp4CbRVrxeki51t_uJCx1hcCxxpdka1J8AA,8382
+puzzle_solver/puzzles/inertia/parse_map/parse_map.py,sha256=A9JQTNqamUdzlwqks0XQp3Hge3mzyTIVK6YtDJvqpL4,8422
 puzzle_solver/puzzles/keen/keen.py,sha256=tDb6C5S3Q0JAKPsdw-84WQ6PxRADELZHr_BK8FDH-NA,5039
 puzzle_solver/puzzles/light_up/light_up.py,sha256=iSA1rjZMFsnI0V0Nxivxox4qZkB7PvUrROSHXcoUXds,4541
 puzzle_solver/puzzles/magnets/magnets.py,sha256=-Wl49JD_PKeq735zQVMQ3XSQX6gdHiY-7PKw-Sh16jw,6474
@@ -27,7 +29,7 @@ puzzle_solver/puzzles/towers/towers.py,sha256=QvL0Pp-Z2ewCeq9ZkNrh8MShKOh-Y52sFB
 puzzle_solver/puzzles/tracks/tracks.py,sha256=VnAtxBkuUTHJYNXr1JGg0yYzJj3kRMBi8Nz7NHKS94A,9089
 puzzle_solver/puzzles/undead/undead.py,sha256=ygNugW5SOlYLy6d740gZ2IW9UJQ3SAr9vuMm0ZFr2nY,6630
 puzzle_solver/puzzles/unruly/unruly.py,sha256=sDF0oKT50G-NshyW2DYrvAgD9q9Ku9ANUyNhGSAu7cQ,3827
-multi_puzzle_solver-0.8.7.dist-info/METADATA,sha256=WEFmdDkVqTMuKK1rDqX5r378UpPvtA8SriZ6ZZcFGJ4,101834
-multi_puzzle_solver-0.8.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-multi_puzzle_solver-0.8.7.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
-multi_puzzle_solver-0.8.7.dist-info/RECORD,,
+multi_puzzle_solver-0.9.1.dist-info/METADATA,sha256=LmgK-1usuWuTNzO1ffTSVqtZQbeiD8ZKwg6zD81KEtw,104983
+multi_puzzle_solver-0.9.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+multi_puzzle_solver-0.9.1.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
+multi_puzzle_solver-0.9.1.dist-info/RECORD,,

puzzle_solver/__init__.py

@@ -1,5 +1,7 @@
 from puzzle_solver.puzzles.bridges import bridges as bridges_solver
 from puzzle_solver.puzzles.chess_range import chess_range as chess_range_solver
+from puzzle_solver.puzzles.chess_range import chess_solo as chess_solo_solver
+from puzzle_solver.puzzles.chess_range import chess_melee as chess_melee_solver
 from puzzle_solver.puzzles.dominosa import dominosa as dominosa_solver
 from puzzle_solver.puzzles.filling import filling as filling_solver
 from puzzle_solver.puzzles.guess import guess as guess_solver
@@ -24,4 +26,4 @@ from puzzle_solver.puzzles.unruly import unruly as unruly_solver
 
 from puzzle_solver.puzzles.inertia.parse_map.parse_map import main as inertia_image_parser
 
-__version__ = '0.8.7'
+__version__ = '0.9.1'

puzzle_solver/puzzles/chess_range/chess_melee.py

@@ -0,0 +1,7 @@
+from .chess_range import Board as RangeBoard
+from .chess_range import PieceType
+
+class Board(RangeBoard):
+    def __init__(self, pieces: list[str], colors: list[str]):
+        super().__init__(pieces=pieces, colors=colors)
+

puzzle_solver/puzzles/chess_range/chess_range.py

@@ -3,10 +3,9 @@ from dataclasses import dataclass
 from typing import Union
 from enum import Enum
 
-import numpy as np
 from ortools.sat.python import cp_model
 
-from puzzle_solver.core.utils import Pos, get_pos, get_all_pos, get_char, set_char, get_row_pos, get_col_pos, Direction, get_next_pos, in_bounds
+from puzzle_solver.core.utils import Pos, get_pos
 from puzzle_solver.core.utils_ortools import and_constraint, generic_solve_all, or_constraint
 
 
@@ -22,6 +21,7 @@ class PieceType(Enum):
 @dataclass(frozen=True)
 class SingleSolution:
     assignment: dict[int, tuple[str, Pos, Pos, str]]  # every time step a single piece moves from one position to another and eats another piece
+    position_occupied: dict[Pos, int]
     # pos_assignment: dict[tuple[int, int, Union[Pos, str]], int]
     # mover: dict[int, tuple[int, PieceType]]
     # victim: dict[int, tuple[int, PieceType]]
@@ -37,6 +37,7 @@ class SingleSolution:
 
 
 def parse_algebraic_notation(algebraic: str) -> tuple[PieceType, Pos]:
+    assert isinstance(algebraic, str), f'algebraic notation must be a string, got {type(algebraic)}'
     assert len(algebraic) == 3, 'algebraic notation must be 3 characters'
     p = {'K': PieceType.KING, 'Q': PieceType.QUEEN, 'R': PieceType.ROOK, 'B': PieceType.BISHOP, 'N': PieceType.KNIGHT, 'P': PieceType.PAWN}
     assert algebraic[0] in p, 'invalid piece type'
@@ -49,6 +50,7 @@ def parse_algebraic_notation(algebraic: str) -> tuple[PieceType, Pos]:
     pos = get_pos(x=file, y=rank)
     return (piece_type, pos)
 
+
 def to_algebraic_notation_single_move(piece_type: str, from_pos: Pos, to_pos: Pos, victim_type: str) -> str:
     letter = {PieceType.KING.name: 'K', PieceType.QUEEN.name: 'Q', PieceType.ROOK.name: 'R', PieceType.BISHOP.name: 'B', PieceType.KNIGHT.name: 'N', PieceType.PAWN.name: 'P'}
     from_file_letter = chr(from_pos.x + ord('a'))
@@ -57,7 +59,9 @@ def to_algebraic_notation_single_move(piece_type: str, from_pos: Pos, to_pos: Po
     to_rank_letter = str(to_pos.y + 1)
     return f'{letter[piece_type]}{from_file_letter}{from_rank_letter}->{letter[victim_type]}{to_file_letter}{to_rank_letter}'
 
-def to_algebraic_notation(move_sequence: dict[int, tuple[str, Pos, Pos, str]]) -> list[str]:
+
+def to_algebraic_notation(single_solution: SingleSolution) -> list[str]:
+    move_sequence = single_solution.assignment
     move_sequence = sorted(move_sequence.items(), key=lambda x: x[0])
     move_sequence = [x[1] for x in move_sequence]
     return [to_algebraic_notation_single_move(piece_type, from_pos, to_pos, victim_type) for piece_type, from_pos, to_pos, victim_type in move_sequence]
@@ -66,50 +70,123 @@ def to_algebraic_notation(move_sequence: dict[int, tuple[str, Pos, Pos, str]]) -
 def is_same_row_col(from_pos: Pos, to_pos: Pos) -> bool:
     return from_pos.x == to_pos.x or from_pos.y == to_pos.y
 
+
 def is_diagonal(from_pos: Pos, to_pos: Pos) -> bool:
     return abs(from_pos.x - to_pos.x) == abs(from_pos.y - to_pos.y)
 
-def is_move_valid(from_pos: Pos, to_pos: Pos, piece_type: PieceType) -> bool:
+
+def squares_between_rook(from_pos: Pos, to_pos: Pos) -> list[Pos]:
+    if not is_same_row_col(from_pos, to_pos):
+        return []
+    if abs(from_pos.x - to_pos.x) <= 1 and abs(from_pos.y - to_pos.y) <= 1:  # within 2x2 thus no intermediate squares
+        return []
+    squares: list[Pos] = []
+    if from_pos.x == to_pos.x:
+        x = from_pos.x
+        step = 1 if to_pos.y > from_pos.y else -1
+        for y in range(from_pos.y + step, to_pos.y, step):
+            squares.append(get_pos(x=x, y=y))
+    else:
+        y = from_pos.y
+        step = 1 if to_pos.x > from_pos.x else -1
+        for x in range(from_pos.x + step, to_pos.x, step):
+            squares.append(get_pos(x=x, y=y))
+    return squares
+
+
+def squares_between_bishop(from_pos: Pos, to_pos: Pos) -> list[Pos]:
+    if not is_diagonal(from_pos, to_pos):
+        return []
+    if abs(from_pos.x - to_pos.x) <= 1 and abs(from_pos.y - to_pos.y) <= 1:  # within 2x2 thus no intermediate squares
+        return []
+    squares: list[Pos] = []
+    step_x = 1 if to_pos.x > from_pos.x else -1
+    step_y = 1 if to_pos.y > from_pos.y else -1
+    x = from_pos.x + step_x
+    y = from_pos.y + step_y
+    while x != to_pos.x and y != to_pos.y:
+        squares.append(get_pos(x=x, y=y))
+        x += step_x
+        y += step_y
+    return squares
+
+
+
+def is_move_valid(from_pos: Pos, to_pos: Pos, piece_type: PieceType, color=None) -> tuple[bool, list[Pos]]:
+    """Returns: (is_valid, list of positions that must be empty for the move to be valid)
+    For Kings, Pawns, and Knights, no positions must be empty for the move to be valid.
+    A Queen is equivalent to a Rook and a Bishop.
+    A Rook needs all positions directly between the from and to position to be empty for the move to be valid.
+    Similarly, a Bishop needs all positions diagonally between the from and to position to be empty for the move to be valid.
+
+    Args:
+        from_pos (Pos): from position
+        to_pos (Pos): to position
+        piece_type (PieceType): piece type
+        color (str, optional): color of the piece (default: None, all pieces are assumed white)
+
+    Returns:
+        tuple[bool, list[Pos]]: (is_valid, list of positions that must be empty for the move to be valid)
+    """
     if piece_type == PieceType.KING:
         dx = abs(from_pos.x - to_pos.x)
         dy = abs(from_pos.y - to_pos.y)
-        return dx <= 1 and dy <= 1
-    elif piece_type == PieceType.QUEEN:
-        return is_same_row_col(from_pos, to_pos) or is_diagonal(from_pos, to_pos)
+        is_valid = dx <= 1 and dy <= 1
+        return is_valid, []
+    elif piece_type == PieceType.QUEEN:  # rook + bishop
+        rook_valid = is_move_valid(from_pos, to_pos, PieceType.ROOK, color)
+        if rook_valid[0]:
+            return rook_valid
+        return is_move_valid(from_pos, to_pos, PieceType.BISHOP, color)
     elif piece_type == PieceType.ROOK:
-        return is_same_row_col(from_pos, to_pos)
+        return is_same_row_col(from_pos, to_pos), squares_between_rook(from_pos, to_pos)
     elif piece_type == PieceType.BISHOP:
-        return is_diagonal(from_pos, to_pos)
+        return is_diagonal(from_pos, to_pos), squares_between_bishop(from_pos, to_pos)
     elif piece_type == PieceType.KNIGHT:
         dx = abs(from_pos.x - to_pos.x)
         dy = abs(from_pos.y - to_pos.y)
-        return (dx == 2 and dy == 1) or (dx == 1 and dy == 2)
+        is_valid = (dx == 2 and dy == 1) or (dx == 1 and dy == 2)
+        return is_valid, []
     elif piece_type == PieceType.PAWN:  # will always eat because the this is how the puzzle works
         dx = to_pos.x - from_pos.x
         dy = to_pos.y - from_pos.y
-        return abs(dx) == 1 and dy == 1
+        is_valid = abs(dx) == 1 and dy == (1 if color != 'B' else -1)
+        return is_valid, []
 
 
 class Board:
-    def __init__(self, pieces: list[str]):
+    def __init__(self, pieces: list[str], colors: list[str] = None, max_moves_per_piece: int = None, last_piece_alive: Union[PieceType, str] = None):
+        """
+        Args:
+            pieces: list of algebraic notation of the pieces
+            colors: list of colors of the pieces (default: None, all pieces are assumed white (i.e. all pieces are the same except for pawns move only up))
+            max_moves_per_piece: maximum number of moves per piece (default: None, no limit)
+            last_piece_alive: force the last piece alive to be of this type (default: None, any piece can be last man standing)
+        """
         self.pieces: dict[int, tuple[PieceType, Pos]] = {i: parse_algebraic_notation(p) for i, p in enumerate(pieces)}
+        assert colors is None or (len(colors) == len(self.pieces) and all(c in ['B', 'W'] for c in colors)), f'if provided, colors must be a list of length {len(self.pieces)} with elements B or W, got {colors}'
+        self.colors = colors
         self.N = len(self.pieces)  # number of pieces
         self.T = self.N  # (N-1) moves + 1 initial state
-        
+        self.max_moves_per_piece = max_moves_per_piece
+        self.last_piece_alive = last_piece_alive
         self.V = 8  # board size
         self.H = 8  # board size
-        self.num_positions = self.V * self.H  # 8x8 board
+        # the puzzle rules mean the only legal positions are the starting positions of the pieces
+        self.all_legal_positions: set[Pos] = {pos for _, pos in self.pieces.values()}
+        assert len(self.all_legal_positions) == len(self.pieces), f'positions are not unique'
 
         self.model = cp_model.CpModel()
-        # Input numbers: N is number of piece, T is number of time steps (=N here), B is board size (=64 here):
+        # Input numbers: N is number of piece, T is number of time steps (=N here), B is board size (=N here because the only legal positions are the starting positions of the pieces):
         # Number of variables 
         # piece_positions: O(NTB)
         # is_dead: O(NT)
         # mover: O(NT)
         # victim: O(NT)
+        # position_occupied: O(TB)
         # dies_this_timestep: O(NT)
         # pos_is_p_star: O(NTB)
-        # Total: ~ (2*64)N^2 + 5N^2 = 132N^2
+        # Total: ~ (2*N)N^2 + 6N^2 = 2N^3 + 6N^2
 
         # (piece_index, time_step, position) -> boolean variable (possible all false if i'm dead)
         self.piece_positions: dict[tuple[int, int, Pos], cp_model.IntVar] = {}
@@ -119,13 +196,24 @@ class Board:
         self.mover: dict[tuple[int, int], cp_model.IntVar] = {}  # did i move this timestep?
         self.victim: dict[tuple[int, int], cp_model.IntVar] = {}  # did i die this timestep?
 
+        # (time_step, position) -> boolean variable indicating if the position is occupied by any piece at this timestep
+        self.position_occupied: dict[tuple[int, Pos], cp_model.IntVar] = {}
+
         self.create_vars()
         self.add_all_constraints()
-    
+
+    def can_move(self, p: int, t: int) -> bool:
+        c = self.colors[p]
+        return (c == 'W' and t % 2 == 0) or (c == 'B' and t % 2 == 1)
+
+    def can_be_victim(self, p: int, t: int) -> bool:
+        c = self.colors[p]
+        return (c == 'W' and t % 2 == 1) or (c == 'B' and t % 2 == 0)
+
     def create_vars(self):
         for p in range(self.N):
             for t in range(self.T):
-                for pos in get_all_pos(self.V, self.H):
+                for pos in self.all_legal_positions:
                     self.piece_positions[(p, t, pos)] = self.model.NewBoolVar(f'piece_positions[{p},{t},{pos}]')
                 self.is_dead[(p, t)] = self.model.NewBoolVar(f'is_dead[{p},{t}]')
         for p in range(self.N):
@@ -133,10 +221,15 @@ class Board:
                 self.mover[(p, t)] = self.model.NewIntVar(0, 1, f'mover[{p},{t}]')
                 self.victim[(p, t)] = self.model.NewIntVar(0, 1, f'victim[{p},{t}]')
 
+        for t in range(self.T):
+            for pos in self.all_legal_positions:
+                self.position_occupied[(t, pos)] = self.model.NewBoolVar(f'position_occupied[{t},{pos}]')
+
     def add_all_constraints(self):
         self.enforce_initial_state()
         self.enforce_board_state_constraints()
         self.enforce_mover_victim_constraints()
+        self.enforce_position_occupied_constraints()
 
     def enforce_initial_state(self):
         # initial state
@@ -145,7 +238,7 @@ class Board:
             # cant be initially dead
             self.model.Add(self.is_dead[(p, 0)] == 0)
             # all others are blank
-            for pos in get_all_pos(self.V, self.H):
+            for pos in self.all_legal_positions:
                 if pos == initial_pos:
                     continue
                 self.model.Add(self.piece_positions[(p, 0, pos)] == 0)
@@ -154,7 +247,7 @@ class Board:
         # at each timestep and each piece, it can only be at exactly one position or dead
         for p in range(self.N):
             for t in range(self.T):
-                pos_vars = [self.piece_positions[(p, t, pos)] for pos in get_all_pos(self.V, self.H)]
+                pos_vars = [self.piece_positions[(p, t, pos)] for pos in self.all_legal_positions]
                 pos_vars.append(self.is_dead[(p, t)])
                 self.model.AddExactlyOne(pos_vars)
         # if im dead this timestep then im also dead next timestep
@@ -163,22 +256,55 @@ class Board:
                 self.model.Add(self.is_dead[(p, t + 1)] == 1).OnlyEnforceIf(self.is_dead[(p, t)])
         # every move must be legal chess move
         for p in range(self.N):
+            color = self.colors[p] if self.colors is not None else None
             for t in range(self.T - 1):
-                for from_pos in get_all_pos(self.V, self.H):
-                    for to_pos in get_all_pos(self.V, self.H):
+                for from_pos in self.all_legal_positions:
+                    for to_pos in self.all_legal_positions:
                         if from_pos == to_pos:
                             continue
-                        if not is_move_valid(from_pos, to_pos, self.pieces[p][0]):
+                        is_valid, need_to_be_empty = is_move_valid(from_pos, to_pos, self.pieces[p][0], color=color)
+                        # remove non legal moves
+                        need_to_be_empty = set(need_to_be_empty) & self.all_legal_positions
+                        if not is_valid:
                             self.model.Add(self.piece_positions[(p, t + 1, to_pos)] == 0).OnlyEnforceIf([self.piece_positions[(p, t, from_pos)]])
+                        elif len(need_to_be_empty) > 0:
+                            occupied_between = self.model.NewBoolVar(f'occupied_between[{from_pos},{to_pos},{t},{p}]')
+                            or_constraint(self.model, occupied_between, [self.position_occupied[(t, pos)] for pos in need_to_be_empty])
+                            self.model.Add(self.piece_positions[(p, t + 1, to_pos)] == 0).OnlyEnforceIf([self.piece_positions[(p, t, from_pos)], occupied_between])
+
         # if mover is i and victim is j then i HAS to be at the position of j at the next timestep
         for p_mover in range(self.N):
             for p_victim in range(self.N):
                 if p_mover == p_victim:
                     continue
                 for t in range(self.T - 1):
-                    for pos in get_all_pos(self.V, self.H):
+                    for pos in self.all_legal_positions:
                         self.model.Add(self.piece_positions[(p_mover, t + 1, pos)] == self.piece_positions[(p_victim, t, pos)]).OnlyEnforceIf([self.mover[(p_mover, t)], self.victim[(p_victim, t)]])
 
+        # optional parameter to force last piece alive
+        if self.last_piece_alive is not None:
+            target_ps = [p for p in range(self.N) if self.pieces[p][0] == self.last_piece_alive]
+            assert len(target_ps) == 1, f'multiple pieces of type {self.last_piece_alive} found'
+            target_p = target_ps[0]
+            # target piece is force to be last man standing
+            self.model.Add(self.is_dead[(target_p, self.T - 1)] == 0)
+            for p in range(self.N):
+                if p == target_p:
+                    continue
+                self.model.Add(self.is_dead[(p, self.T - 1)] == 1)
+
+        if self.colors is not None:
+            # t=0 and even timesteps are white, odd timesteps are black
+            for p in range(self.N):
+                for t in range(self.T - 1):
+                    if not self.can_move(p, t):
+                        self.model.Add(self.mover[(p, t)] == 0)
+            # t=0 and even timesteps only black victims, odd timesteps only white victims
+            for p in range(self.N):
+                for t in range(self.T - 1):
+                    if not self.can_be_victim(p, t):
+                        self.model.Add(self.victim[(p, t)] == 0)
+
     def enforce_mover_victim_constraints(self):
         for p in range(self.N):
             for t in range(self.T - 1):
@@ -201,7 +327,7 @@ class Board:
                 # if next timestep im somewhere else then i was the mover
                 # i.e. there exists a position p* s.t. (piece_positions[p, t + 1, p*] AND NOT piece_positions[p, t, p*])
                 pos_is_p_star = []
-                for pos in get_all_pos(self.V, self.H):
+                for pos in self.all_legal_positions:
                     v = self.model.NewBoolVar(f'pos_is_p_star[{p},{t},{pos}]')
                     self.model.Add(v == 1).OnlyEnforceIf([self.piece_positions[(p, t + 1, pos)], self.piece_positions[(p, t, pos)].Not()])
                     self.model.Add(v == 0).OnlyEnforceIf([self.piece_positions[(p, t + 1, pos)].Not()])
@@ -216,13 +342,23 @@ class Board:
         for t in range(self.T - 1):
             self.model.AddExactlyOne([self.victim[(p, t)] for p in range(self.N)])
 
+        # optional parameter to force 
+        if self.max_moves_per_piece is not None:
+            for p in range(self.N):
+                self.model.Add(sum([self.mover[(p, t)] for t in range(self.T - 1)]) <= self.max_moves_per_piece)
+
+    def enforce_position_occupied_constraints(self):
+        for t in range(self.T):
+            for pos in self.all_legal_positions:
+                self.model.Add(self.position_occupied[(t, pos)] == sum([self.piece_positions[(p, t, pos)] for p in range(self.N)]))
+
 
     def solve_and_print(self, verbose: bool = True, max_solutions: int = None):
         def board_to_solution(board: "Board", solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
             pos_assignment: dict[tuple[int, int, Union[Pos, str]], int] = {}
             for t in range(board.T):
                 for i in range(board.N):
-                    for pos in get_all_pos(board.V, board.H):
+                    for pos in board.all_legal_positions:
                         pos_assignment[(i, t, pos)] = solver.Value(board.piece_positions[(i, t, pos)])
                     pos_assignment[(i, t, 'DEAD')] = solver.Value(board.is_dead[(i, t)])
             mover = {}
@@ -240,11 +376,12 @@ class Board:
             for t in range(board.T - 1):
                 mover_i = mover[t][0]
                 victim_i = victim[t][0]
-                from_pos = next(pos for pos in get_all_pos(board.V, board.H) if pos_assignment[(mover_i, t, pos)])
-                to_pos = next(pos for pos in get_all_pos(board.V, board.H) if pos_assignment[(mover_i, t + 1, pos)])
+                from_pos = next(pos for pos in board.all_legal_positions if pos_assignment[(mover_i, t, pos)])
+                to_pos = next(pos for pos in board.all_legal_positions if pos_assignment[(mover_i, t + 1, pos)])
                 assignment[t] = (board.pieces[mover_i][0].name, from_pos, to_pos, board.pieces[victim_i][0].name)
             # return SingleSolution(assignment=assignment, pos_assignment=pos_assignment, mover=mover, victim=victim)
-            return SingleSolution(assignment=assignment)
+            position_occupied = {(t, pos): int(solver.Value(board.position_occupied[(t, pos)])) for t in range(board.T) for pos in board.all_legal_positions}
+            return SingleSolution(assignment=assignment, position_occupied=position_occupied)
 
         def callback(single_res: SingleSolution):
             print("Solution found")
@@ -257,6 +394,8 @@ class Board:
             # print('victims:', single_res.victim)
             # print('movers:', single_res.mover)
             # print()
-            move_sequence = to_algebraic_notation(single_res.assignment)
+            # for t in range(self.T):
+            #     print('at timestep', t, 'the following positions are occupied', [pos for pos in self.all_legal_positions if single_res.position_occupied[(t, pos)] == 1])
+            move_sequence = to_algebraic_notation(single_res)
             print(move_sequence)
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose, max_solutions=max_solutions)

puzzle_solver/puzzles/chess_range/chess_solo.py

@@ -0,0 +1,9 @@
+from .chess_range import Board as RangeBoard
+from .chess_range import PieceType
+
+class Board(RangeBoard):
+    def __init__(self, pieces: list[str]):
+        king_pieces = [p for p in range(len(pieces)) if pieces[p][0] == 'K']
+        assert len(king_pieces) == 1, f'exactly one king piece is required'
+        super().__init__(pieces, max_moves_per_piece=2, last_piece_alive=PieceType.KING)
+

puzzle_solver/puzzles/inertia/parse_map/parse_map.py

@@ -6,14 +6,8 @@
 from pathlib import Path
 import numpy as np
 import numpy as np
-try:
-    import cv2 as cv
-except ImportError:
-    cv = None
-try:
-    from PIL import Image
-except ImportError:
-    Image = None
+cv = None
+Image = None
 
 def load_cell_templates(p: Path) -> dict[str, dict]:
     img = Image.open(p)
@@ -137,6 +131,12 @@ def show_wait_destroy(winname, img):
 
 
 def main(image):
+    global Image
+    global cv
+    from PIL import Image as Image_module
+    import cv2 as cv_module
+    Image = Image_module
+    cv = cv_module
     CELL_BLANK = load_cell_templates(Path(__file__).parent / 'cells' / 'cell_blank.png')
     CELL_WALL = load_cell_templates(Path(__file__).parent / 'cells' / 'cell_wall.png')
     CELL_GEM = load_cell_templates(Path(__file__).parent / 'cells' / 'cell_gem.png')