solver-0h-h1/sources/Square.py

# 0h h1 Solver. Solves grids of 0h h1 game.
# Copyright (C) 2015  Gabriel Augendre <gabriel@augendre.info>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

__author__ = 'gaugendre'


class Square:
    """
    Represents a square in the grid.
    A square can be either Red, Blue, or Nothing, depending on the text
    written in it and displayed ('R', 'B' or ' ').
    """

    def __init__(self, horiz, vert):
        self.horiz = horiz
        self.vert = vert

    def next_horiz(self, width):
        if self.horiz == width - 1:
            return None
        return Square(self.horiz + 1, self.vert)

    def prev_horiz(self):
        if self.horiz == 0:
            return None
        return Square(self.horiz - 1, self.vert)

    def next_vert(self, height):
        if self.vert == height - 1:
            return None
        return Square(self.horiz, self.vert + 1)

    def prev_vert(self):
        if self.vert == 0:
            return None
        return Square(self.horiz, self.vert - 1)

    def __eq__(self, other):
        if other is None or not isinstance(other, Square):
            return False
        else:
            return self.vert == other.vert and self.horiz == other.horiz

    def __hash__(self):
        return hash((self.horiz, self.vert))


def solve(grid):
    y = 0
    while y < len(grid):
        x = 0
        while x < len(grid[0]):
            if grid[x][y] == ' ':
                v_prev_x, v_prev_y = prev_vert(x, y)
                v_p_prev_x, v_p_prev_y = prev_vert(v_prev_x, v_prev_y)
                v_next_x, v_next_y = next_vert(x, y, len(grid))
                v_n_next_x, v_n_next_y = next_vert(v_next_x, v_next_y,
                                                   len(grid))

                h_prev_x, h_prev_y = prev_horiz(x, y)
                h_p_prev_x, h_p_prev_y = prev_horiz(h_prev_x, h_prev_y)
                h_next_x, h_next_y = next_horiz(x, y, len(grid[0]))
                h_n_next_x, h_n_next_y = next_horiz(h_next_x, h_next_y,
                                                    len(grid[0]))

                be_blue = (exists(v_prev_x, v_prev_y) and
                           exists(v_p_prev_x, v_p_prev_y) and
                           grid[v_prev_x][v_prev_y] == 'R' and
                           grid[v_p_prev_x][v_p_prev_y] == 'R') or \
                          (exists(v_next_x, v_next_y) and
                           exists(v_n_next_x, v_n_next_y) and
                           grid[v_next_x][v_next_y] == 'R' and
                           grid[v_n_next_x][v_n_next_y] == 'R') or \
                          (exists(h_prev_x, h_prev_y >= 0) and
                           exists(h_p_prev_x, h_p_prev_y) and
                           grid[h_prev_x][h_prev_y] == 'R' and
                           grid[h_p_prev_x][h_p_prev_y] == 'R') or \
                          (exists(h_next_x, h_next_y) and
                           exists(h_n_next_y, h_n_next_y) and
                           grid[h_next_x][h_next_y] == 'R' and
                           grid[h_n_next_x][h_n_next_y] == 'R') or \
                          (exists(h_prev_x, h_prev_y) and
                           exists(h_next_x, h_next_y) and
                           grid[h_prev_x][h_prev_y] == 'R' and
                           grid[h_next_x][h_next_y] == 'R') or \
                          (exists(v_prev_x, v_prev_y) and
                           exists(v_next_x, v_next_y) and
                           grid[v_prev_x][v_prev_y] == 'R' and
                           grid[v_next_x][v_next_y] == 'R')

                be_red = (v_prev_x >= 0 and v_prev_y >= 0 and
                          v_p_prev_x >= 0 and v_p_prev_y >= 0 and
                          grid[v_prev_x][v_prev_y] == 'B' and
                          grid[v_p_prev_x][v_p_prev_y] == 'B') or \
                         (v_next_x >= 0 and v_next_y >= 0 and
                          v_n_next_x >= 0 and v_n_next_y >= 0 and
                          grid[v_next_x][v_next_y] == 'B' and
                          grid[v_n_next_x][v_n_next_y] == 'B') or \
                         (h_prev_x >= 0 and h_prev_y >= 0 and
                          h_p_prev_x >= 0 and h_p_prev_y >= 0 and
                          grid[h_prev_x][h_prev_y] == 'B' and
                          grid[h_p_prev_x][h_p_prev_y] == 'B') or \
                         (h_next_x >= 0 and h_next_y >= 0 and
                          h_n_next_y >= 0 and h_n_next_y >= 0 and
                          grid[h_next_x][h_next_y] == 'B' and
                          grid[h_n_next_x][h_n_next_y] == 'B') or \
                          (exists(h_prev_x, h_prev_y) and
                           exists(h_next_x, h_next_y) and
                           grid[h_prev_x][h_prev_y] == 'B' and
                           grid[h_next_x][h_next_y] == 'B') or \
                          (exists(v_prev_x, v_prev_y) and
                           exists(v_next_x, v_next_y) and
                           grid[v_prev_x][v_prev_y] == 'B' and
                           grid[v_next_x][v_next_y] == 'B')

                if be_blue:
                    grid[x][y] = 'B'
                elif be_red:
                    grid[x][y] = 'R'
            x += 1
        y += 1


def exists(a, b):
    return a >= 0 and b >= 0


def next_horiz(horiz, vert, width):
    if horiz == width - 1:
        return -1, -1
    return horiz + 1, vert


def prev_horiz(horiz, vert):
    if horiz == 0:
        return -1, -1
    return horiz - 1, vert


def next_vert(horiz, vert, height):
    if vert == height - 1:
        return -1, -1
    return horiz, vert + 1


def prev_vert(horiz, vert):
    if vert == 0:
        return -1, -1
    return horiz, vert - 1


def print_grid(grid):
    for line in grid:
        for square in line:
            if square == ' ':
                square = '_'
            print(square, end='  ')
        print('')


if __name__ == "__main__":
    grid = [['B', ' ', ' ', ' '],
            ['B', 'B', ' ', ' '],
            [' ', ' ', ' ', ' '],
            [' ', 'B', ' ', 'B']]
    print_grid(grid)
    solve(grid)
    print("")
    print_grid(grid)