multi-puzzle-solver 0.1.0__py3-none-any.whl

puzzle_solver/puzzles/tents/tents.py

@@ -0,0 +1,110 @@
+from collections import defaultdict
+
+import numpy as np
+from ortools.sat.python import cp_model
+from ortools.sat.python.cp_model import LinearExpr as lxp
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, set_char, get_neighbors8, get_next_pos, Direction, get_row_pos, get_col_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+
+
+class Board:
+    def __init__(self, board: np.array, sides: dict[str, np.array]):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert board.shape[0] == board.shape[1], 'board must be square'
+        assert len(sides) == 2, '2 sides must be provided'
+        assert set(sides.keys()) == set(['top', 'side'])
+        assert all(s.ndim == 1 and s.shape[0] == board.shape[0] for s in sides.values()), 'all sides must be equal to board size'
+        assert all(c.item() in ['*', 'T'] for c in np.nditer(board)), 'board must contain only * or T'
+        self.board = board
+        self.N = board.shape[0]
+        self.star_positions: set[Pos] = {pos for pos in get_all_pos(self.N) if get_char(self.board, pos) == '*'}
+        self.tree_positions: set[Pos] = {pos for pos in get_all_pos(self.N) if get_char(self.board, pos) == 'T'}
+        self.model = cp_model.CpModel()
+        self.is_tent = defaultdict(int)
+        self.tent_direction = defaultdict(int)
+        self.sides = sides
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in self.star_positions:
+            is_tent = self.model.NewBoolVar(f'{pos}:is_tent')
+            tent_direction = self.model.NewIntVar(0, 4, f'{pos}:tent_direction')
+            self.model.Add(tent_direction == 0).OnlyEnforceIf(is_tent.Not())
+            self.model.Add(tent_direction > 0).OnlyEnforceIf(is_tent)
+            self.is_tent[pos] = is_tent
+            self.tent_direction[pos] = tent_direction
+
+    def add_all_constraints(self):
+        # - There are exactly as many tents as trees.
+        self.model.Add(lxp.sum([self.is_tent[pos] for pos in self.star_positions]) == len(self.tree_positions))
+        # - no two tents are adjacent horizontally, vertically or diagonally
+        for pos in self.star_positions:
+            for neighbour in get_neighbors8(pos, V=self.N, H=self.N, include_self=False):
+                if get_char(self.board, neighbour) != '*':
+                    continue
+                self.model.Add(self.is_tent[neighbour] == 0).OnlyEnforceIf(self.is_tent[pos])
+        # - the number of tents in each row and column matches the numbers around the edge of the grid 
+        for row in range(self.N):
+            row_vars = [self.is_tent[pos] for pos in get_row_pos(row, self.N)]
+            self.model.Add(lxp.sum(row_vars) == self.sides['side'][row])
+        for col in range(self.N):
+            col_vars = [self.is_tent[pos] for pos in get_col_pos(col, self.N)]
+            self.model.Add(lxp.sum(col_vars) == self.sides['top'][col])
+        # - it is possible to match tents to trees so that each tree is orthogonally adjacent to its own tent (but may also be adjacent to other tents). 
+        # for each tree, one of the following must be true:
+        # a tent on its left has direction RIGHT
+        # a tent on its right has direction LEFT
+        # a tent on its top has direction DOWN
+        # a tent on its bottom has direction UP
+        for tree in self.tree_positions:
+            self.add_tree_constraints(tree)
+
+    def add_tree_constraints(self, tree_pos: Pos):
+        left_pos = get_next_pos(tree_pos, Direction.LEFT)
+        right_pos = get_next_pos(tree_pos, Direction.RIGHT)
+        top_pos = get_next_pos(tree_pos, Direction.UP)
+        bottom_pos = get_next_pos(tree_pos, Direction.DOWN)
+        var_list = []
+        if left_pos in self.star_positions:
+            aux = self.model.NewBoolVar(f'{tree_pos}:left')
+            self.model.Add(self.tent_direction[left_pos] == Direction.RIGHT.value).OnlyEnforceIf(aux)
+            self.model.Add(self.tent_direction[left_pos] != Direction.RIGHT.value).OnlyEnforceIf(aux.Not())
+            var_list.append(aux)
+        if right_pos in self.star_positions:
+            aux = self.model.NewBoolVar(f'{tree_pos}:right')
+            self.model.Add(self.tent_direction[right_pos] == Direction.LEFT.value).OnlyEnforceIf(aux)
+            self.model.Add(self.tent_direction[right_pos] != Direction.LEFT.value).OnlyEnforceIf(aux.Not())
+            var_list.append(aux)
+        if top_pos in self.star_positions:
+            aux = self.model.NewBoolVar(f'{tree_pos}:top')
+            self.model.Add(self.tent_direction[top_pos] == Direction.DOWN.value).OnlyEnforceIf(aux)
+            self.model.Add(self.tent_direction[top_pos] != Direction.DOWN.value).OnlyEnforceIf(aux.Not())
+            var_list.append(aux)
+        if bottom_pos in self.star_positions:
+            aux = self.model.NewBoolVar(f'{tree_pos}:bottom')
+            self.model.Add(self.tent_direction[bottom_pos] == Direction.UP.value).OnlyEnforceIf(aux)
+            self.model.Add(self.tent_direction[bottom_pos] != Direction.UP.value).OnlyEnforceIf(aux.Not())
+            var_list.append(aux)
+        self.model.AddBoolOr(var_list)
+
+    def solve_and_print(self):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, int] = {}
+            for pos, var in board.is_tent.items():
+                if isinstance(var, int):
+                    continue
+                assignment[pos] = solver.value(var)
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            res = np.full((self.N, self.N), ' ', dtype=object)
+            for pos in get_all_pos(self.N):
+                c = get_char(self.board, pos)
+                if c == '*':
+                    c = single_res.assignment[pos]
+                    c = 'E' if c == 1 else ' '
+                set_char(res, pos, c)
+            print(res)
+        return generic_solve_all(self, board_to_solution, callback=callback)

puzzle_solver/puzzles/towers/towers.py

@@ -0,0 +1,139 @@
+import numpy as np
+from ortools.sat.python import cp_model
+from ortools.sat.python.cp_model import LinearExpr as lxp
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, set_char, get_pos, get_row_pos, get_col_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+
+
+def bool_from_greater_than(model, a, b, name):
+    res = model.NewBoolVar(name)
+    model.add(a > b).OnlyEnforceIf(res)
+    model.add(a <= b).OnlyEnforceIf(res.Not())
+    return res
+
+
+class Board:
+    def __init__(self, board: np.array, sides: dict[str, np.array]):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert board.shape[0] == board.shape[1], 'board must be square'
+        assert len(sides) == 4, '4 sides must be provided'
+        assert all(s.ndim == 1 and s.shape[0] == board.shape[0] for s in sides.values()), 'all sides must be equal to board size'
+        assert set(sides.keys()) == set(['right', 'left', 'top', 'bottom'])
+        self.board = board
+        self.sides = sides
+        self.N = board.shape[0]
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[Pos, cp_model.IntVar] = {}
+
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.N):
+            self.model_vars[pos] = self.model.NewIntVar(1, self.N, f'{pos}')
+
+    def add_all_constraints(self):
+        # if board has value then force intvar to be that value
+        for pos in get_all_pos(self.N):
+            v = get_char(self.board, pos)
+            if str(v).isdecimal():
+                self.model.Add(self.model_vars[pos] == int(v))
+        # all different for rows
+        for row_i in range(self.N):
+            row_vars = [self.model_vars[pos] for pos in get_row_pos(row_i, self.N)]
+            self.model.AddAllDifferent(row_vars)
+        # all different for cols
+        for col_i in range(self.N):
+            col_vars = [self.model_vars[pos] for pos in get_col_pos(col_i, self.N)]
+            self.model.AddAllDifferent(col_vars)
+        # constrain number of viewable towers
+        # top
+        for x in range(self.N):
+            real = self.sides['top'][x]
+            if real == -1:
+                continue
+            can_see_variables = []
+            previous_towers: list[cp_model.IntVar] = []
+            for y in range(self.N):
+                current_tower = self.model_vars[get_pos(x=x, y=y)]
+                can_see_variables.append(self.can_see_tower(previous_towers, current_tower, f'top:{x}:{y}'))
+                previous_towers.append(current_tower)
+            self.model.add(lxp.sum(can_see_variables) == real)
+        # bottom
+        for x in range(self.N):
+            real = self.sides['bottom'][x]
+            if real == -1:
+                continue
+            can_see_variables = []
+            previous_towers: list[cp_model.IntVar] = []
+            for y in range(self.N-1, -1, -1):
+                current_tower = self.model_vars[get_pos(x=x, y=y)]
+                can_see_variables.append(self.can_see_tower(previous_towers, current_tower, f'bottom:{x}:{y}'))
+                previous_towers.append(current_tower)
+            self.model.add(lxp.sum(can_see_variables) == real)
+        # left
+        for y in range(self.N):
+            real = self.sides['left'][y]
+            if real == -1:
+                continue
+            can_see_variables = []
+            previous_towers: list[cp_model.IntVar] = []
+            for x in range(self.N):
+                current_tower = self.model_vars[get_pos(x=x, y=y)]
+                can_see_variables.append(self.can_see_tower(previous_towers, current_tower, f'left:{x}:{y}'))
+                previous_towers.append(current_tower)
+            self.model.add(lxp.sum(can_see_variables) == real)
+        # right
+        for y in range(self.N):
+            real = self.sides['right'][y]
+            if real == -1:
+                continue
+            can_see_variables = []
+            previous_towers: list[cp_model.IntVar] = []
+            for x in range(self.N-1, -1, -1):
+                current_tower = self.model_vars[get_pos(x=x, y=y)]
+                can_see_variables.append(self.can_see_tower(previous_towers, current_tower, f'right:{x}:{y}'))
+                previous_towers.append(current_tower)
+            self.model.add(lxp.sum(can_see_variables) == real)
+
+    def can_see_tower(self, blocks: list[cp_model.IntVar], tower: cp_model.IntVar, name: str) -> cp_model.IntVar:
+        """
+        Returns a boolean variable of whether a position BEFORE the blocks can see the "tower" parameter.
+        i.e., is the tower taller than all the blocks?
+
+        Args:
+            blocks (list[cp_model.IntVar]): blocks that possibly block the view of the tower
+            tower (cp_model.IntVar): tower to check if can be seen
+            name (str): name of the constraint
+
+        Returns:
+            cp_model.IntVar: boolean variable of whether the tower can be seen
+        """
+        if len(blocks) == 0:
+            return True
+        # I can see "tower" if it's larger that all the blocks
+        # lits is a list of [(tower > b0), (tower > b1), ..., (tower > bi)]
+        lits = [bool_from_greater_than(self.model, tower, block, f'{name}:lits:{i}') for i, block in enumerate(blocks)]
+
+        # create a single bool which decides if I can see it or not
+        res = self.model.NewBoolVar(name)
+        self.model.AddBoolAnd(lits).OnlyEnforceIf(res)
+        self.model.AddBoolOr([res] + [l.Not() for l in lits])
+        return res
+
+    def solve_and_print(self):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, int] = {}
+            for pos, var in board.model_vars.items():
+                assignment[pos] = solver.value(var)
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            res = np.full((self.N, self.N), ' ', dtype=object)
+            for pos in get_all_pos(self.N):
+                c = get_char(self.board, pos)
+                c = single_res.assignment[pos]
+                set_char(res, pos, c)
+            print(res)
+        return generic_solve_all(self, board_to_solution, callback=callback)

puzzle_solver/puzzles/tracks/tracks.py

@@ -0,0 +1,170 @@
+from collections import defaultdict
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, set_char, get_char, get_neighbors4, Direction, in_bounds, get_next_pos, get_row_pos, get_col_pos, get_opposite_direction
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, and_constraint, or_constraint
+
+
+class Board:
+    def __init__(self, board: np.array, side: np.array, top: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all((len(c.item()) == 2) and all(ch in [' ', 'U', 'L', 'D', 'R'] for ch in c.item()) for c in np.nditer(board)), 'board must contain only * or digits'
+        self.board = board
+        self.V = board.shape[0]
+        self.H = board.shape[1]
+        self.side = side
+        self.top = top
+        self.first_col_start_pos = [p for p in get_col_pos(0, self.V) if 'L' in get_char(self.board, p)]
+        assert len(self.first_col_start_pos) == 1, 'first column must have exactly one start position'
+        self.first_col_start_pos = self.first_col_start_pos[0]
+        self.last_row_end_pos = [p for p in get_row_pos(self.V - 1, self.H) if 'D' in get_char(self.board, p)]
+        assert len(self.last_row_end_pos) == 1, 'last row must have exactly one end position'
+        self.last_row_end_pos = self.last_row_end_pos[0]
+
+        self.model = cp_model.CpModel()
+        self.cell_active: dict[Pos, cp_model.IntVar] = {}
+        self.cell_direction: dict[tuple[Pos, Direction], cp_model.IntVar] = {}
+        self.reach_layers: list[dict[Pos, cp_model.IntVar]] = []  # R_t[p] booleans, t = 0..T
+
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            self.cell_active[pos] = self.model.NewBoolVar(f'{pos}')
+            for direction in Direction:
+                self.cell_direction[(pos, direction)] = self.model.NewBoolVar(f'{pos}:{direction}')
+        # Percolation layers R_t (monotone flood fill)
+        for t in range(self.V * self.H + 1):
+            Rt: dict[Pos, cp_model.IntVar] = {}
+            for pos in get_all_pos(self.V, self.H):
+                Rt[pos] = self.model.NewBoolVar(f"R[{t}][{pos}]")
+            self.reach_layers.append(Rt)
+
+    def add_all_constraints(self):
+        self.force_hints()
+        self.force_sides()
+        self.force_0_or_2_active()
+        self.force_direction_constraints()
+        self.force_percolation()
+
+
+    def force_hints(self):
+        # force the already given hints
+        for pos in get_all_pos(self.V, self.H):
+            c = get_char(self.board, pos)
+            if 'U' in c:
+                self.model.Add(self.cell_direction[(pos, Direction.UP)] == 1)
+            if 'L' in c:
+                self.model.Add(self.cell_direction[(pos, Direction.LEFT)] == 1)
+            if 'D' in c:
+                self.model.Add(self.cell_direction[(pos, Direction.DOWN)] == 1)
+            if 'R' in c:
+                self.model.Add(self.cell_direction[(pos, Direction.RIGHT)] == 1)
+
+    def force_sides(self):
+        # force the already given sides
+        for i in range(self.V):
+            self.model.Add(sum([self.cell_active[pos] for pos in get_row_pos(i, self.H)]) == self.side[i])
+        for i in range(self.H):
+            self.model.Add(sum([self.cell_active[pos] for pos in get_col_pos(i, self.V)]) == self.top[i])
+
+    def force_0_or_2_active(self):
+        # cell active means exactly 2 directions are active, cell not active means no directions are active
+        for pos in get_all_pos(self.V, self.H):
+            s = sum([self.cell_direction[(pos, direction)] for direction in Direction])
+            self.model.Add(s == 2).OnlyEnforceIf(self.cell_active[pos])
+            self.model.Add(s == 0).OnlyEnforceIf(self.cell_active[pos].Not())
+
+    def force_direction_constraints(self):
+        # X having right means the cell to its right has left and so on for all directions
+        for pos in get_all_pos(self.V, self.H):
+            right_pos = get_next_pos(pos, Direction.RIGHT)
+            if in_bounds(right_pos, self.V, self.H):
+                self.model.Add(self.cell_direction[(pos, Direction.RIGHT)] == self.cell_direction[(right_pos, Direction.LEFT)])
+            down_pos = get_next_pos(pos, Direction.DOWN)
+            if in_bounds(down_pos, self.V, self.H):
+                self.model.Add(self.cell_direction[(pos, Direction.DOWN)] == self.cell_direction[(down_pos, Direction.UP)])
+            left_pos = get_next_pos(pos, Direction.LEFT)
+            if in_bounds(left_pos, self.V, self.H):
+                self.model.Add(self.cell_direction[(pos, Direction.LEFT)] == self.cell_direction[(left_pos, Direction.RIGHT)])
+            top_pos = get_next_pos(pos, Direction.UP)
+            if in_bounds(top_pos, self.V, self.H):
+                self.model.Add(self.cell_direction[(pos, Direction.UP)] == self.cell_direction[(top_pos, Direction.DOWN)])
+
+        # first column cant have L unless it is the start position
+        for pos in get_col_pos(0, self.V):
+            if pos != self.first_col_start_pos:
+                self.model.Add(self.cell_direction[(pos, Direction.LEFT)] == 0)
+        # last column cant have R
+        for pos in get_col_pos(self.H - 1, self.V):
+            self.model.Add(self.cell_direction[(pos, Direction.RIGHT)] == 0)
+        # last row cant have D unless it is the end position
+        for pos in get_row_pos(self.V - 1, self.H):
+            if pos != self.last_row_end_pos:
+                self.model.Add(self.cell_direction[(pos, Direction.DOWN)] == 0)
+        # first row cant have U
+        for pos in get_row_pos(0, self.H):
+            self.model.Add(self.cell_direction[(pos, Direction.UP)] == 0)
+
+    def force_percolation(self):
+        """
+        Layered percolation:
+          - root is exactly the first cell in the first column
+          - R_t is monotone nondecreasing in t (R_t+1 >= R_t)
+          - A cell can 'turn on' at layer t+1 iff it's active and has a neighbor on AND pointing to it at layer t
+          - Final layer is equal to the active mask: R_T[p] == active[p]  => all active cells are connected to the unique root
+        """
+        # only the start position is a root
+        self.model.Add(self.reach_layers[0][self.first_col_start_pos] == 1)
+        for pos in get_all_pos(self.V, self.H):
+            if pos != self.first_col_start_pos:
+                self.model.Add(self.reach_layers[0][pos] == 0)
+
+        for t in range(1, len(self.reach_layers)):
+            Rt_prev = self.reach_layers[t - 1]
+            Rt = self.reach_layers[t]
+            for p in get_all_pos(self.V, self.H):
+                # Rt[p] = Rt_prev[p] | (active[p] & Rt_prev[neighbour #1]) | (active[p] & Rt_prev[neighbour #2]) | ...
+                # Create helper (active[p] & Rt_prev[neighbour #X]) for each neighbor q
+                neigh_helpers: list[cp_model.IntVar] = []
+                for direction in Direction:
+                    q = get_next_pos(p, direction)
+                    if not in_bounds(q, self.V, self.H):
+                        continue
+                    a = self.model.NewBoolVar(f"A[{t}][{p}]<-({q})")
+                    and_constraint(self.model, target=a, cs=[self.cell_active[p], Rt_prev[q], self.cell_direction[(q, get_opposite_direction(direction))]])
+                    neigh_helpers.append(a)
+                or_constraint(self.model, target=Rt[p], cs=[Rt_prev[p]] + neigh_helpers)
+        # every avtive track must be reachible -> single connected component
+        for pos in get_all_pos(self.V, self.H):
+            self.model.Add(self.reach_layers[-1][pos] == 1).OnlyEnforceIf(self.cell_active[pos])
+
+
+
+
+
+    def solve_and_print(self):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, str] = defaultdict(str)
+            for (pos, direction), var in board.cell_direction.items():
+                assignment[pos] += direction.name[0] if solver.BooleanValue(var) else ''
+            for pos in get_all_pos(self.V, self.H):
+                if len(assignment[pos]) == 0:
+                    assignment[pos] = '  '
+                else:
+                    assignment[pos] = ''.join(sorted(assignment[pos]))
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(single_res.assignment)
+            res = np.full((self.V, self.H), ' ', dtype=object)
+            pretty_dict = {'DU': '┃ ', 'LR': '━━', 'DL': '━┒', 'DR': '┏━', 'RU': '┗━', 'LU': '━┛', '  ': '  '}
+            for pos in get_all_pos(self.V, self.H):
+                c = get_char(self.board, pos)
+                c = single_res.assignment[pos]
+                c = pretty_dict[c]
+                set_char(res, pos, c)
+            print(res)
+        return generic_solve_all(self, board_to_solution, callback=callback, max_solutions=20)

puzzle_solver/puzzles/undead/undead.py

@@ -0,0 +1,168 @@
+from typing import Iterable, Optional
+from enum import Enum
+from dataclasses import dataclass
+
+import numpy as np
+from ortools.sat.python import cp_model
+from ortools.sat.python.cp_model import LinearExpr as lxp
+
+from puzzle_solver.core.utils import Pos, get_all_pos, set_char, get_pos, get_next_pos, in_bounds, get_char, Direction, get_row_pos, get_col_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+
+
+class Monster(Enum):
+    VAMPIRE = "VA"
+    ZOMBIE = "ZO"
+    GHOST = "GH"
+
+
+@dataclass
+class SingleBeamResult:
+    position: Pos
+    reflect_count: int
+
+
+def get_all_monster_types() -> Iterable[tuple[str, str]]:
+    for monster in Monster:
+        yield monster, monster.value
+
+
+def can_see(reflect_count: int, monster: Monster) -> bool:
+    if monster == Monster.ZOMBIE:
+        return True
+    elif monster == Monster.VAMPIRE:
+        return reflect_count == 0
+    elif monster == Monster.GHOST:
+        return reflect_count > 0
+    else:
+        raise ValueError
+
+
+def beam(board, start_pos: Pos, direction: Direction) -> list[SingleBeamResult]:
+    N = board.shape[0]
+    cur_result: list[SingleBeamResult] = []
+    reflect_count = 0
+    cur_pos = start_pos
+    while True:
+        if not in_bounds(cur_pos, N):
+            break
+        cur_pos_char = get_char(board, cur_pos)
+        if cur_pos_char == '//':
+            direction = {
+                Direction.RIGHT: Direction.UP,
+                Direction.UP: Direction.RIGHT,
+                Direction.DOWN: Direction.LEFT,
+                Direction.LEFT: Direction.DOWN
+            }[direction]
+            reflect_count += 1
+        elif cur_pos_char == '\\':
+            direction = {
+                Direction.RIGHT: Direction.DOWN,
+                Direction.DOWN: Direction.RIGHT,
+                Direction.UP: Direction.LEFT,
+                Direction.LEFT: Direction.UP
+            }[direction]
+            reflect_count += 1
+        else:
+            # not a mirror
+            cur_result.append(SingleBeamResult(cur_pos, reflect_count))
+        cur_pos = get_next_pos(cur_pos, direction)
+    return cur_result
+
+
+class Board:
+    def __init__(self, board: np.array, sides: dict[str, np.array], monster_count: Optional[dict[Monster, int]] = None):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert board.shape[0] == board.shape[1], 'board must be square'
+        assert len(sides) == 4, '4 sides must be provided'
+        assert all(s.ndim == 1 and s.shape[0] == board.shape[0] for s in sides.values()), 'all sides must be equal to board size'
+        assert set(sides.keys()) == set(['right', 'left', 'top', 'bottom'])
+        self.board = board
+        self.sides = sides
+        self.N = board.shape[0]
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[tuple[Pos, str], cp_model.IntVar] = {}
+        self.star_positions: set[Pos] = {pos for pos in get_all_pos(self.N) if get_char(self.board, pos) == '**'}
+        self.monster_count = monster_count
+
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in self.star_positions:
+            c = get_char(self.board, pos)
+            assert c == '**', f'star position {pos} has character {c}'
+            monster_vars = []
+            for _, monster_name in get_all_monster_types():
+                v = self.model.NewBoolVar(f"{pos}_is_{monster_name}")
+                self.model_vars[(pos, monster_name)] = v
+                monster_vars.append(v)
+            self.model.add_exactly_one(*monster_vars)
+
+    def add_all_constraints(self):
+        # top edge
+        for i, ground in zip(range(self.N), self.sides['top']):
+            if ground == -1:
+                continue
+            pos = get_pos(x=i, y=0)
+            beam_result = beam(self.board, pos, Direction.DOWN)
+            self.model.add(self.get_var(beam_result) == ground)
+
+        # left edge
+        for i, ground in zip(range(self.N), self.sides['left']):
+            if ground == -1:
+                continue
+            pos = get_pos(x=0, y=i)
+            beam_result = beam(self.board, pos, Direction.RIGHT)
+            self.model.add(self.get_var(beam_result) == ground)
+
+        # right edge
+        for i, ground in zip(range(self.N), self.sides['right']):
+            if ground == -1:
+                continue
+            pos = get_pos(x=self.N-1, y=i)
+            beam_result = beam(self.board, pos, Direction.LEFT)
+            self.model.add(self.get_var(beam_result) == ground)
+
+        # bottom edge
+        for i, ground in zip(range(self.N), self.sides['bottom']):
+            if ground == -1:
+                continue
+            pos = get_pos(x=i, y=self.N-1)
+            beam_result = beam(self.board, pos, Direction.UP)
+            self.model.add(self.get_var(beam_result) == ground)
+        
+        if self.monster_count is not None:
+            for monster, count in self.monster_count.items():
+                if count == -1:
+                    continue
+                monster_name = monster.value
+                monster_vars = [self.model_vars[(pos, monster_name)] for pos in self.star_positions]
+                self.model.add(lxp.Sum(monster_vars) == count)
+
+    def get_var(self, path: list[SingleBeamResult]) -> lxp:
+        path_vars = []
+        for square in path:
+            assert square.position in self.star_positions, f'square {square.position} is not a star position'
+            for monster, monster_name in get_all_monster_types():
+                if can_see(square.reflect_count, monster):
+                    path_vars.append(self.model_vars[(square.position, monster_name)])
+        return lxp.Sum(path_vars) if path_vars else 0
+
+    def solve_and_print(self):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, str] = {}
+            for (pos, monster_name), var in board.model_vars.items():
+                if solver.BooleanValue(var):
+                    assignment[pos] = monster_name
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            res = np.full((self.N, self.N), ' ', dtype=object)
+            for pos in get_all_pos(self.N):
+                c = get_char(self.board, pos)
+                if c == '**':
+                    c = single_res.assignment[pos]
+                set_char(res, pos, c)
+            print(res)
+        return generic_solve_all(self, board_to_solution, callback=callback)

puzzle_solver/puzzles/unruly/unruly.py

@@ -0,0 +1,86 @@
+import numpy as np
+from ortools.sat.python import cp_model
+from ortools.sat.python.cp_model import LinearExpr as lxp
+
+from puzzle_solver.core.utils import Pos, get_all_pos, set_char, get_char, get_row_pos, get_col_pos, in_bounds, Direction, get_next_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+
+
+def get_3_consecutive_horiz_and_vert(pos: Pos, V: int, H: int) -> tuple[list[Pos], list[Pos]]:
+    """Get 3 consecutive squares, horizontally and vertically, from the given position."""
+    horiz = []
+    vert = []
+    cur_pos = pos
+    for _ in range(3):
+        if in_bounds(cur_pos, V, H):
+            horiz.append(cur_pos)
+        cur_pos = get_next_pos(cur_pos, Direction.RIGHT)
+    cur_pos = pos
+    for _ in range(3):
+        if in_bounds(cur_pos, V, H):
+            vert.append(cur_pos)
+        cur_pos = get_next_pos(cur_pos, Direction.DOWN)
+    return horiz, vert
+
+
+class Board:
+    def __init__(self, board: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert board.shape[0] % 2 == 0, 'board must have even number of rows'
+        assert board.shape[1] % 2 == 0, 'board must have even number of columns'
+        self.board = board
+        self.V = board.shape[0]
+        self.H = board.shape[1]
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[Pos, cp_model.IntVar] = {}
+
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            self.model_vars[pos] = self.model.NewBoolVar(f'{pos}')
+
+    def add_all_constraints(self):
+        # some cells are already filled
+        for pos in get_all_pos(self.V, self.H):
+            c = get_char(self.board, pos)
+            if c == '*':
+                continue
+            v = 1 if c == 'B' else 0
+            self.model.Add(self.model_vars[pos] == v)
+        # no three consecutive squares, horizontally or vertically, are the same colour 
+        for pos in get_all_pos(self.V, self.H):
+            horiz, vert = get_3_consecutive_horiz_and_vert(pos, self.V, self.H)
+            if len(horiz) == 3:
+                horiz = [self.model_vars[h] for h in horiz]
+                self.model.Add(lxp.Sum(horiz) != 0)
+                self.model.Add(lxp.Sum(horiz) != 3)
+            if len(vert) == 3:
+                vert = [self.model_vars[v] for v in vert]
+                self.model.Add(lxp.Sum(vert) != 0)
+                self.model.Add(lxp.Sum(vert) != 3)
+        # each row and column contains the same number of black and white squares.
+        for col in range(self.H):
+            var_list = [self.model_vars[pos] for pos in get_col_pos(col, self.V)]
+            self.model.Add(lxp.Sum(var_list) == self.V // 2)
+        for row in range(self.V):
+            var_list = [self.model_vars[pos] for pos in get_row_pos(row, self.H)]
+            self.model.Add(lxp.Sum(var_list) == self.H // 2)
+
+    def solve_and_print(self):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, int] = {}
+            for pos, var in board.model_vars.items():
+                assignment[pos] = solver.Value(var)
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            res = np.full((self.V, self.H), ' ', dtype=object)
+            for pos in get_all_pos(self.V, self.H):
+                c = get_char(self.board, pos)
+                if c == '*':
+                    c = 'B' if single_res.assignment[pos] == 1 else 'W'
+                set_char(res, pos, c)
+            print(res)
+        return generic_solve_all(self, board_to_solution, callback=callback)