multi-puzzle-solver 0.8.6__py3-none-any.whl → 0.9.0__py3-none-any.whl

{multi_puzzle_solver-0.8.6.dist-info → multi_puzzle_solver-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multi-puzzle-solver
-Version: 0.8.6
+Version: 0.9.0
 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
@@ -206,12 +206,18 @@ These are all the puzzles that are implemented in this repo. <br> Click on any o
     </a>
   </td>
   <td align="center">
-    <a href="#chess-sequence-puzzle-type-23"><b>Chess Sequence</b><br><br>
-      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/chess_sequence_unsolved.png" alt="Chess sequence" height="120">
+    <a href="#chess-range-puzzle-type-23"><b>Chess Range</b><br><br>
+      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/chess_range_unsolved.png" alt="Chess range" height="120">
     </a>
   </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">
   
-  </td><td></td><td></td>
+  </td>
 </tr>
 </table>
 
@@ -249,9 +255,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 Sequence(Puzzle Type #23)](#chess-sequencepuzzle-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 +1942,7 @@ In the case when there's only one possible choice left, the solver will inform y
 
 ---
 
-## Chess Sequence(Puzzle Type #23)
+## Chess Range (Puzzle Type #23)
 
 * [**Play online**](https://www.puzzle-chess.com/chess-ranger-11/)
 
@@ -1946,22 +1953,23 @@ In the case when there's only one possible choice left, the solver will inform y
 
 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.
 
-This means that at the end of the $N-1$ moves, there is only one piece left alive on the board.
-
-A move that does not capture another piece is not allowed.
+- Pieces move as standard chess pieces.
+- You can perform only capture moves. A move that does not capture another piece is not allowed.
+- You are allowed to capture the king.
+- 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_sequence_unsolved.png" alt="Chess sequence unsolved" width="500">
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/chess_range_unsolved.png" alt="Chess range 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
-from puzzle_solver import chess_sequence_solver as solver
+from puzzle_solver import chess_range_solver as solver
 # algebraic notation
 board = ['Qe7', 'Nc6', 'Kb6', 'Pb5', 'Nf5', 'Pg4', 'Rb3', 'Bc3', 'Pd3', 'Pc2', 'Rg2']
 binst = solver.Board(board)
@@ -1976,12 +1984,114 @@ 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**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/chess_range_solved.png" alt="Chess range solved" width="500">
+
+---
+
+## 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_sequence_solved.png" alt="Chess sequence solved" width="500">
+<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">
 
 ---
 
@@ -1999,36 +2109,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_sequence` — Chess Sequence (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):
@@ -2088,4 +2168,5 @@ Issues and PRs welcome!
 [15]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/unruly "puzzle_solver/src/puzzle_solver/puzzles/unruly at master · Ar-Kareem/puzzle_solver · GitHub"
 [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_sequence "puzzle_solver/src/puzzle_solver/puzzles/chess_sequence 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"

{multi_puzzle_solver-0.8.6.dist-info → multi_puzzle_solver-0.9.0.dist-info}/RECORD

@@ -1,14 +1,17 @@
-puzzle_solver/__init__.py,sha256=uc7Anf6yvOAigUSOX5Rrhq8xnwWlZk9BRJb4EuoL_ew,1664
+puzzle_solver/__init__.py,sha256=bPtr98uTvRDOU7v5H1iXRfEHuZa5qSE3coOgZjT8Ea4,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_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
@@ -26,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.6.dist-info/METADATA,sha256=2dFiJVRUPijxzl7Ie2vpS1S7DXJfQJl7DQpDToFGNVo,101803
-multi_puzzle_solver-0.8.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-multi_puzzle_solver-0.8.6.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
-multi_puzzle_solver-0.8.6.dist-info/RECORD,,
+multi_puzzle_solver-0.9.0.dist-info/METADATA,sha256=vN-LmOU4spC46p31NuuT1stsyR6fGzqm1E77gt8hECc,104532
+multi_puzzle_solver-0.9.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+multi_puzzle_solver-0.9.0.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
+multi_puzzle_solver-0.9.0.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_sequence import chess_sequence as chess_sequence_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.6'
+__version__ = '0.9.0'

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

@@ -0,0 +1,401 @@
+import json
+from dataclasses import dataclass
+from typing import Union
+from enum import Enum
+
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_pos
+from puzzle_solver.core.utils_ortools import and_constraint, generic_solve_all, or_constraint
+
+
+
+class PieceType(Enum):
+    KING   = 1
+    QUEEN  = 2
+    ROOK   = 3
+    BISHOP = 4
+    KNIGHT = 5
+    PAWN   = 6
+
+@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]]
+
+    def get_hashable_solution(self) -> str:
+        # only hash assignment
+        result = []
+        for _, (_, from_pos, to_pos, _) in sorted(self.assignment.items()):
+            result.append((from_pos.x, from_pos.y, to_pos.x, to_pos.y))
+        # order doesnt matter for uniqueness
+        result = sorted(result)
+        return json.dumps(result)
+
+
+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'
+    assert algebraic[1] in 'abcdefgh', f'invalid file: {algebraic[1]}'
+    assert algebraic[2] in '12345678', f'invalid rank: {algebraic[2]}'
+    piece_type = p[algebraic[0]]
+    file, rank = algebraic[1:]
+    file = ord(file) - ord('a')
+    rank = int(rank) - 1
+    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'))
+    from_rank_letter = str(from_pos.y + 1)
+    to_file_letter = chr(to_pos.x + ord('a'))
+    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(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]
+
+
+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 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)
+        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), squares_between_rook(from_pos, to_pos)
+    elif piece_type == PieceType.BISHOP:
+        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)
+        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
+        is_valid = abs(dx) == 1 and dy == (1 if color != 'B' else -1)
+        return is_valid, []
+
+
+class Board:
+    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
+        # 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 (=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*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] = {}
+        self.is_dead: dict[tuple[int, int], cp_model.IntVar] = {}  # Am I currently dead
+
+        # (piece_index, time_step) -> boolean variable indicating if the piece [moved/died]
+        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 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):
+            for t in range(self.T - 1):  # final state does not have a mover or victim
+                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
+        for p, (_, initial_pos) in self.pieces.items():
+            self.model.Add(self.piece_positions[(p, 0, initial_pos)] == 1)
+            # cant be initially dead
+            self.model.Add(self.is_dead[(p, 0)] == 0)
+            # all others are blank
+            for pos in self.all_legal_positions:
+                if pos == initial_pos:
+                    continue
+                self.model.Add(self.piece_positions[(p, 0, pos)] == 0)
+
+    def enforce_board_state_constraints(self):
+        # 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 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
+        for p in range(self.N):
+            for t in range(self.T - 1):
+                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 self.all_legal_positions:
+                    for to_pos in self.all_legal_positions:
+                        if from_pos == to_pos:
+                            continue
+                        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 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):
+                # if i'm dead at time step t then I did not move nor victimized
+                self.model.Add(self.mover[(p, t)] == 0).OnlyEnforceIf(self.is_dead[(p, t)])
+                self.model.Add(self.victim[(p, t)] == 0).OnlyEnforceIf(self.is_dead[(p, t)])
+                # if I was the mover or victim at time step t then I was not dead
+                self.model.Add(self.is_dead[(p, t)] == 0).OnlyEnforceIf(self.mover[(p, t)])
+                self.model.Add(self.is_dead[(p, t)] == 0).OnlyEnforceIf(self.victim[(p, t)])
+                # a victim cannot be the mover and vice versa
+                self.model.Add(self.mover[(p, t)] == 0).OnlyEnforceIf(self.victim[(p, t)])
+                self.model.Add(self.victim[(p, t)] == 0).OnlyEnforceIf(self.mover[(p, t)])
+
+                # if im dead next timestep and i was alive this timestep then im the victim
+                # cant rely on victim var here because the goal it to constrain it
+                dies_this_timestep = self.model.NewBoolVar(f'dies_this_timestep[{p},{t}]')
+                and_constraint(self.model, dies_this_timestep, [self.is_dead[(p, t + 1)], self.is_dead[(p, t)].Not()])
+                self.model.Add(self.victim[(p, t)] == dies_this_timestep)
+
+                # 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 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()])
+                    self.model.Add(v == 0).OnlyEnforceIf([self.piece_positions[(p, t, pos)]])
+                    pos_is_p_star.append(v)
+                or_constraint(self.model, self.mover[(p, t)], pos_is_p_star)
+
+        # at each timestep only one piece can be the mover
+        for t in range(self.T - 1):
+            self.model.AddExactlyOne([self.mover[(p, t)] for p in range(self.N)])
+        # at each timestep only one piece can be victimized
+        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 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 = {}
+            for t in range(board.T - 1):
+                for i in range(board.N):
+                    if solver.Value(board.mover[(i, t)]):
+                        mover[t] = (i, board.pieces[i][0].name)
+            victim = {}
+            for t in range(board.T - 1):
+                for i in range(board.N):
+                    if solver.Value(board.victim[(i, t)]):
+                        victim[t] = (i, board.pieces[i][0].name)
+
+            assignment: dict[int, tuple[int, Pos, Pos]] = {}  # final result
+            for t in range(board.T - 1):
+                mover_i = mover[t][0]
+                victim_i = victim[t][0]
+                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)
+            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")
+            # pieces = sorted(set(i for (i, _, _) in single_res.assignment.keys()))
+            # for piece in pieces:
+            #     print(f"Piece {piece} type: {single_res.piece_types[piece]}")
+            #     # at each timestep a piece can only be in one position
+            #     t_to_pos = {t: pos for (i, t, pos), v in single_res.assignment.items() if i == piece and v == 1}
+            #     print(t_to_pos)
+            # print('victims:', single_res.victim)
+            # print('movers:', single_res.mover)
+            # print()
+            # 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')