solver.py

'''
from blocks import *
from copy import deepcopy
import time

def place_block(board_matrix: list[list[int]], block_id: int, block_matrix: list[list[int]], start_row: int, start_col: int) -> int:
    cpy = deepcopy(board_matrix)
    try:
        for row in range(len(block_matrix)):
            for col in range(len(block_matrix[0])):
                if board_matrix[start_row + row][start_col + col] != 1:
                    if block_matrix[row][col] != 0:
                        print("Bruh?")
                        print("Trying to place at", (start_row, start_col))
                        print("Block matrix orientation is:")
                        print_matrix(block_matrix)
                        board_matrix = cpy
                        print("Actual matrix is:")
                        print_matrix(board_matrix)
                        return 0
                if block_matrix[row][col] == 1:
                    board_matrix[start_row + row][start_col + col] = block_id
        return 1
    except IndexError:
        print("Index error!!!!")
        print("Trying to place at", (start_row, start_col))
        print("Block matrix orientation is:")
        print_matrix(block_matrix)
        board_matrix = cpy
        print("Actual matrix is:")
        print_matrix(board_matrix)
        return 0

def check_full(board_matrix: list[list[int]]):
    for row in board_matrix:
        for ele in row:
            if ele == 1:
                return -1
    return 1

def reset_board(board_matrix: list[list[int]]):
    for i in range(len(board_matrix)):
        for j in range(len(board_matrix[0])):
            if board_matrix[i][j] >= 2:
                board_matrix[i][j] = 1

def remove_block(board_matrix: list[list[int]], block: Block):
    print("removing the block ", block.id)
    print("Block matrix is:")
    print_matrix(block.matrix)
    print("Before:")
    print_matrix(board_matrix)
    for i in range(len(board_matrix)):
        for j in range(len(board_matrix[0])):
            if board_matrix[i][j] == block.id:
                board_matrix[i][j] = 1
    print("After:")
    print_matrix(board_matrix)

def solve_board_bruteforce(board_matrix: list[list[int]], blocks: list[Block]):
    m_rows = len(board_matrix)
    m_cols = len(board_matrix[0])
    block1, block2, block3, block4 = blocks
    for i1 in range(m_rows):
        for j1 in range(m_cols):
            reset_board(board_matrix)
            for orientation1 in block1.get_all_block_orientations():
                remove_block(board_matrix, block1)
                status1 = place_block(board_matrix, block1.id, orientation1, i1, j1)
                if not status1:
                    continue
                print("First block", block1.id, "placed at", (i1, j1))
                print_matrix(orientation1)
                print("Now matrix is:")
                print_matrix(board_matrix)

                for i2 in range(m_rows):
                    for j2 in range(m_cols):
                        for orientation2 in block2.get_all_block_orientations():
                            remove_block(board_matrix, block2)
                            status2 = place_block(board_matrix, block2.id, orientation2, i2, j2)
                            if not status2:
                                continue
                            print("Second block", block2.id, "placed at", (i2, j2))
                            print_matrix(orientation2)
                            print("Now matrix is:")
                            print_matrix(board_matrix)
                            for i3 in range(m_rows):
                                for j3 in range(m_cols):
                                    for orientation3 in block3.get_all_block_orientations():
                                        remove_block(board_matrix, block3)
                                        status3 = place_block(board_matrix, block3.id, orientation3, i3, j3)
                                        if not status3:
                                            continue
                                        print("Third block", block3.id, "placed at", (i3, j3))
                                        print_matrix(orientation3)
                                        print("Now matrix is:")
                                        print_matrix(board_matrix)
                                        for i4 in range(m_rows):
                                            for j4 in range(m_cols):
                                                for orientation4 in block4.get_all_block_orientations():
                                                    remove_block(board_matrix, block4)
                                                    status4 = place_block(board_matrix, block4.id, orientation4, i4, j4)
                                                    if not status4:
                                                        continue
                                                    print("Fourth block", block4.id, "placed at", (i4, j4))
                                                    print_matrix(orientation4)
                                                    print("Now matrix is:")
                                                    print_matrix(board_matrix)
                                                    if check_full(board_matrix) == 1:
                                                        return True
    return False

if __name__ == '__main__':
    solved_matrix = [
    [0, 1, 1, 1, 0],
    [1, 1, 1, 1, 0],
    [1, 1, 1, 1, 1],
    [1, 1, 1, 1, 1],
    [0, 0, 0, 0, 0],
    ]
    blocks = [
        ThatOneWeirdShape(),
        Line2(),
        LongL(),
        SquareTail()
    ]
    solve_board_bruteforce(solved_matrix, blocks)
'''

from blocks import *
from copy import deepcopy
import time

def check_full(board_matrix: list[list[int]]):
    for row in board_matrix:
        for ele in row:
            if ele == 1:
                return 0
    return 1

def place_block(board_matrix: list[list[int]], block_id: int, block_matrix: list[list[int]], start_row: int, start_col: int) -> int:
    cpy = deepcopy(board_matrix)
    try:
        for row in range(len(block_matrix)):
            for col in range(len(block_matrix[0])):
                if board_matrix[start_row + row][start_col + col] != 1:
                    if block_matrix[row][col] != 0:
                        print("Bruh?")
                        print("Trying to place at", (start_row, start_col))
                        print("Block matrix orientation is:")
                        print_matrix(block_matrix)
                        board_matrix = cpy
                        print("Actual matrix is:")
                        print_matrix(board_matrix)
                        return 0
                if block_matrix[row][col] == 1:
                    board_matrix[start_row + row][start_col + col] = block_id
        #time.sleep(0)
        return 1
    except IndexError:
        print("Index error!!!!")
        print("Trying to place at", (start_row, start_col))
        print("Block matrix orientation is:")
        print_matrix(block_matrix)
        board_matrix = cpy
        print("Actual matrix is:")
        print_matrix(board_matrix)
        return 0


def remove_block(board_matrix: list[list[int]], block: Block):
    print("removing the block ", block.id)
    print("Block matrix is:")
    print_matrix(block.matrix)
    print("Before:")
    print_matrix(board_matrix)
    for i in range(len(board_matrix)):
        for j in range(len(board_matrix[0])):
            if board_matrix[i][j] == block.id:
                board_matrix[i][j] = 1
    print("After:")
    print_matrix(board_matrix)

def solve_board_backtrack(board_matrix: list[list[int]], blocks: list[Block], block_index: int = 0):
    if block_index == len(blocks):
        return check_full(board_matrix) == 1

    m_rows = len(board_matrix)
    m_cols = len(board_matrix[0])
    current_block = blocks[block_index]
    for orientation in current_block.get_all_block_orientations():
        for i in range(m_rows):
            for j in range(m_cols):
                remove_block(board_matrix, current_block)
                status = place_block(board_matrix, current_block.id, orientation, i, j)
                if not status:
                    continue
                print(f"Block {current_block.id} placed at {(i, j)}")
                print_matrix(orientation)
                print("Now matrix is:")
                print_matrix(board_matrix)

                if solve_board_backtrack(board_matrix, blocks, block_index + 1):
                    time.sleep(0.5)
                    return True
                remove_block(board_matrix, current_block)

    return False