Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-08-06· OpenAIAi2 WildChat-4.8M (AI2)

creo que el problema esta con las conexiones ya que aqui por ejemplo 0° ┬ Arriba (Up),…

  1. User

    creo que el problema esta con las conexiones ya que aqui por ejemplo 0° ┬ Arriba (Up), Izquierda (Left), Derecha (Right), solo puede conectarse desde 3 lados distintos o sea tiene abierto izq, der y abajo. Pero no puede conectarse a uno de arriba aunque arriba haya una cruz que es la que conecta con todo. 90° ┤ Derecha (Right), Arriba (Up), Abajo (Down), en este ejemplo tiene abiertos 3 lados, pero no se puede conectar con la derecha por ejemplo, creo que el tema para las conexiones es asignar que lados tiene abiertos y cuales cerrados y asi construir un path correcto. Reescribe todo el codigo para que al resolver lo haga de esta manera en el que cada bloque tenga esos 1 o 0 dependiendo si esta abierto o no ese lado, o sea cada bloque tendrá 4 lados con un 1 o un 0. Y si el path desde el inicio hasta el final se llega con todo "1" sera la solucion correcta. Hay que vigilar que no vuelva a posiciones que ya han sido visitadas para no entrar en un bucle. Los bloques pueden tener las siguientes conexiones : 'chars': ['─', '│', '─', '│'], # 0°, 90°, 180°, 270°. y aqui estan todas : ""pieces = { 'line': { 'chars': ['─', '│', '─', '│'], # 0°, 90°, 180°, 270° 'connections': [ [0, 1, 0, 1], # 0°, horizontal [1, 0, 1, 0], # 90°, vertical [0, 1, 0, 1], # 180°, horizontal [1, 0, 1, 0], # 270°, vertical ] }, 'curve': { 'chars': ['└', '┌', '┐', '┘'], 'connections': [ [1, 1, 0, 0], # 0°, conecta Arriba y Derecha [0, 1, 1, 0], # 90°, conecta Derecha y Abajo [0, 0, 1, 1], # 180°, conecta Abajo y Izquierda [1, 0, 0, 1], # 270°, conecta Izquierda y Arriba ] }, 't': { 'chars': ['┬', '┤', '┴', '├'], 'connections': [ [1, 1, 0, 1], # 0°, conecta Arriba, Derecha, Izquierda [1, 1, 1, 0], # 90°, conecta Arriba, Derecha, Abajo [0, 1, 1, 1], # 180°, conecta Derecha, Abajo, Izquierda [1, 0, 1, 1], # 270°, conecta Arriba, Abajo, Izquierda ] }, 'cross': { 'chars': ['┼', '┼', '┼', '┼'], 'connections': [ [1, 1, 1, 1], # Todas las rotaciones son iguales, conecta todas las direcciones [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], ] }"" al final se trata de una app en la que tras presentar un grid de 5x5 bloques tambien haya un boton de verificar solucion y otro de resolver el puzzle.

  2. Assistant

    Para abordar este problema, debemos poder representar cada pieza en el grid utilizando una estructura de datos que contenga información sobre sus posibles conexiones. La idea es que cada pieza tenga un estado (una rotación) y se pueda verificar si las conexiones son consistentes con las de las piezas adyacentes.

    Voy a proponer un esquema de cómo puedes plantear el problema usando Python. La solución asume que tienes una representación de tu grid y que puedes acceder a cada celda de la misma. Implementaremos una función para verificar si hay un camino desde el inicio hasta el final válido considerando las conexiones.

    Para la gestión del grid y las piezas, necesitamos:

    1. Definición de las piezas: Cada tipo de pieza tiene definiciones para sus conexiones según la rotación.

    2. Clase para piezas: Una clase Piece que puede almacenar el tipo, el estado/rotación, y los métodos para obtener las conexiones.

    3. Gestión del grid: Una estructura 2D que almacena instancias de la clase Piece.

    4. Algoritmo de búsqueda: Para verificar si hay un camino válido desde el inicio al final del grid, usaremos un algoritmo como DFS (Depth-First Search) o BFS (Breadth-First Search).

    Aquí tienes un esquema básico en Python para cómo podrías implementar esto:

    class Piece:
        def __init__(self, piece_type, rotation=0):
            self.piece_type = piece_type
            self.rotation = rotation
    
        def connections(self):
            # Return the connection map for the current rotation
            return PIECES[self.piece_type]['connections'][self.rotation]
    
    # Define the set of available pieces and their rotations/connections
    PIECES = {
        'line': {
            'chars': ['─', '│', '─', '│'],  # 0°, 90°, 180°, 270°
            'connections': [
                [0, 1, 0, 1],  # 0°, horizontal
                [1, 0, 1, 0],  # 90°, vertical
                [0, 1, 0, 1],  # 180°, horizontal
                [1, 0, 1, 0],  # 270°, vertical
            ]
        },
        # ... (other pieces as defined by you)
    }
    
    class Grid:
        def __init__(self, width, height):
            self.width = width
            self.height = height
            self.grid = [[None for _ in range(width)] for _ in range(height)]
    
        def set_piece(self, x, y, piece):
            self.grid[y][x] = piece
    
        def is_valid_connection(self, x1, y1, x2, y2, direction):
            # Check if (x1, y1) can validly connect with (x2, y2) in 'direction'
            piece1 = self.grid[y1][x1]
            piece2 = self.grid[y2][x2]
    
            if not piece1 or not piece2:
                return False
    
            connections1 = piece1.connections()
            connections2 = piece2.connections()
    
            # Mapping of direction for matching opposite connections
            dir_map = {'up': 0, 'right': 1, 'down': 2, 'left': 3}
            opposite_dir_map = {'up': 2, 'right': 3, 'down': 0, 'left': 1}
    
            dir_index = dir_map[direction]
            opp_dir_index = opposite_dir_map[direction]
    
            return connections1[dir_index] == 1 and connections2[opp_dir_index] == 1
    
        def is_path_valid(self, start_x, start_y, end_x, end_y):
            visited = set()
    
            def dfs(x, y):
                if (x, y) == (end_x, end_y):
                    return True
                visited.add((x, y))
    
                # Check all possible directions
                directions = ['up', 'right', 'down', 'left']
                dxs_dys = [(-1, 0), (0, 1), (1, 0), (0, -1)]
    
                for dir_idx, (dx, dy) in enumerate(dxs_dys):
                    nx, ny = x + dx, y + dy
                    if 0 <= nx < self.width and 0 <= ny < self.height:
                        if (nx, ny) not in visited and self.is_valid_connection(x, y, nx, ny, directions[dir_idx]):
                            if dfs(nx, ny):
                                return True
    
                return False
    
            return dfs(start_x, start_y)
    
    # Example usage:
    grid = Grid(5, 5)
    grid.set_piece(0, 0, Piece('line', 0))
    grid.set_piece(0, 1, Piece('curve', 1))
    # ... set other pieces as needed
    
    print(grid.is_path_valid(0, 0, 4, 4))  # Check if a path exists from (0, 0) to (4, 4)
    

    Consideraciones:

    • Conexión bidireccional: Cuando compruebas las conexiones de dos piezas adyacentes, asegúrate de que ambas pueden conectarse en la dirección opuesta.

    • Algoritmo de búsqueda: Aquí se utiliza DFS para recorrer el grid. Es importante controlar que no se ingrese en un bucle revisitando celdas explotando el uso del conjunto visited.

    • Interfaz de usuario: Tendrías que conectar este backend con una interfaz gráfica que permita al usuario manipular el grid y un botón para "verificar" o "resolver". Esto podría hacerse con una librería GUI como tkinter en Python.

    Este código proporciona un marco básico y necesitas adaptar y expandirlo según las necesidades específicas de tu aplicación y cómo quieras gestionar la interacción del usuario.

  3. User

    quiero el codigo entero y con la libreria tkinter

  4. Assistant

    Implementar un puzzle de piezas conectadas usando Python y tkinter requiere un poco de trabajo, pero te proporcionaré un esquema básico que puedes expandir y mejorar. Este ejemplo incluye una interfaz simple, donde puedes colocar piezas en un grid y verificar si hay un camino válido desde una celda de inicio hasta una celda de destino. Vamos a definir las piezas y configurar una interfaz de usuario básica.

    Primero, asegúrate de tener Python instalado, ya que contiene tkinter como parte de la librería estándar. Luego, ejecuta el siguiente código:

    import tkinter as tk
    from tkinter import messagebox
    
    # Definición de las piezas
    PIECES = {
        'line': {
            'chars': ['─', '│', '─', '│'],
            'connections': [
                [0, 1, 0, 1],  # 0°, horizontal
                [1, 0, 1, 0],  # 90°, vertical
                [0, 1, 0, 1],  # 180°, horizontal
                [1, 0, 1, 0],  # 270°, vertical
            ]
        },
        'curve': {
            'chars': ['└', '┌', '┐', '┘'],
            'connections': [
                [1, 1, 0, 0],  # 0°, conecta Arriba y Derecha
                [0, 1, 1, 0],  # 90°, conecta Derecha y Abajo
                [0, 0, 1, 1],  # 180°, conecta Abajo y Izquierda
                [1, 0, 0, 1],  # 270°, conecta Izquierda y Arriba
            ]
        },
        't': {
            'chars': ['┬', '┤', '┴', '├'],
            'connections': [
                [1, 1, 0, 1],  # 0°, conecta Arriba, Derecha, Izquierda
                [1, 1, 1, 0],  # 90°, conecta Arriba, Derecha, Abajo
                [0, 1, 1, 1],  # 180°, conecta Derecha, Abajo, Izquierda
                [1, 0, 1, 1],  # 270°, conecta Arriba, Abajo, Izquierda
            ]
        },
        'cross': {
            'chars': ['┼', '┼', '┼', '┼'],
            'connections': [
                [1, 1, 1, 1],
                [1, 1, 1, 1],
                [1, 1, 1, 1],
                [1, 1, 1, 1],
            ]
        }
    }
    
    class Piece:
        def __init__(self, piece_type, rotation=0):
            self.piece_type = piece_type
            self.rotation = rotation
    
        def connections(self):
            return PIECES[self.piece_type]['connections'][self.rotation]
    
        def char(self):
            return PIECES[self.piece_type]['chars'][self.rotation]
    
    class Grid:
        def __init__(self, width, height):
            self.width = width
            self.height = height
            self.grid = [[None for _ in range(width)] for _ in range(height)]
    
        def set_piece(self, x, y, piece):
            self.grid[y][x] = piece
    
        def is_valid_connection(self, x1, y1, x2, y2, direction):
            piece1 = self.grid[y1][x1]
            piece2 = self.grid[y2][x2]
            if not piece1 or not piece2:
                return False
    
            connections1 = piece1.connections()
            connections2 = piece2.connections()
    
            dir_map = {'up': 0, 'right': 1, 'down': 2, 'left': 3}
            opposite_dir_map = {'up': 2, 'right': 3, 'down': 0, 'left': 1}
    
            dir_index = dir_map[direction]
            opp_dir_index = opposite_dir_map[direction]
    
            return connections1[dir_index] == 1 and connections2[opp_dir_index] == 1
    
        def is_path_valid(self, start_x, start_y, end_x, end_y):
            visited = set()
    
            def dfs(x, y):
                if (x, y) == (end_x, end_y):
                    return True
                visited.add((x, y))
    
                directions = ['up', 'right', 'down', 'left']
                dxs_dys = [(-1, 0), (0, 1), (1, 0), (0, -1)]
    
                for dir_idx, (dx, dy) in enumerate(dxs_dys):
                    nx, ny = x + dx, y + dy
                    if 0 <= nx < self.width and 0 <= ny < self.height:
                        if (nx, ny) not in visited and self.is_valid_connection(x, y, nx, ny, directions[dir_idx]):
                            if dfs(nx, ny):
                                return True
    
                return False
    
            return dfs(start_x, start_y)
    
    class App:
        def __init__(self, root):
            self.root = root
            self.root.title("Grid Puzzle Solver")
            
            self.grid = Grid(5, 5)
            self.buttons = [[None for _ in range(5)] for _ in range(5)]
            self.current_piece_type = 'line'
            self.current_rotation = 0
            self.setup_ui()
    
        def setup_ui(self):
            control_frame = tk.Frame(self.root)
            control_frame.pack(side=tk.TOP)
            
            for piece_type in PIECES:
                button = tk.Button(control_frame, text=piece_type, command=lambda p=piece_type: self.set_piece_type(p))
                button.pack(side=tk.LEFT)
    
            rotation_button = tk.Button(control_frame, text="Rotate", command=self.rotate_piece)
            rotation_button.pack(side=tk.LEFT)
    
            verify_button = tk.Button(control_frame, text="Verify", command=self.verify_solution)
            verify_button.pack(side=tk.LEFT)
    
            grid_frame = tk.Frame(self.root)
            grid_frame.pack()
    
            for y in range(5):
                for x in range(5):
                    button = tk.Button(grid_frame, width=5, height=2,
                                       command=lambda row=y, col=x: self.place_piece(row, col))
                    button.grid(row=y, column=x)
                    self.buttons[y][x] = button
    
        def set_piece_type(self, piece_type):
            self.current_piece_type = piece_type
    
        def rotate_piece(self):
            self.current_rotation = (self.current_rotation + 1) % 4
    
        def place_piece(self, row, col):
            piece = Piece(self.current_piece_type, self.current_rotation)
            self.grid.set_piece(col, row, piece)
            self.update_ui()
    
        def update_ui(self):
            for y in range(5):
                for x in range(5):
                    piece = self.grid.grid[y][x]
                    if piece:
                        self.buttons[y][x].config(text=piece.char())
    
        def verify_solution(self):
            if self.grid.is_path_valid(0, 0, 4, 4):
                messagebox.showinfo("Result", "Valid path found!")
            else:
                messagebox.showerror("Result", "No valid path found.")
    
    if __name__ == "__main__":
        root = tk.Tk()
        app = App(root)
        root.mainloop()
    

    Explicación del Código:

    • Definición de Piezas: Contiene un diccionario para las piezas con sus conexiones y rotaciones.

    • Clase Piece: Define una pieza del puzzle dadas su tipo y rotación actuales.

    • Clase Grid: Administra un grid de tamaño variable, permitiendo colocar piezas y verificar si una conexión es válida mediante la comparación de conexiones.

    • Clase App: Administra la interfaz gráfica utilizando tkinter, proporciona botones para seleccionar piezas, rotarlas y verificar el puzzle. Usa un grid de 5x5 donde puedes colocar piezas y verificar si existe un camino válido.

    Este código es una base que puedes expandir para incluir funcionalidades adicionales, como la remoción de piezas, incremento de tamaño del grid, y más opciones de interfaz de usuario.

  5. User

    bien pero falta , al inicio que crees un tablero con bloques aleatorio, tambien falta un boton de resolver el puzzle. Mejora la presentacion tambien

  6. Assistant

    Vamos a mejorar el programa para que, al inicio, el tablero se genere con piezas colocadas aleatoriamente, y añadiremos un botón para resolver automáticamente el puzzle. También intentaré darle una mejor presentación a la interfaz gráfica de usuario. Para simplificar el algoritmo de resolución automática, podemos utilizar una estrategia que recorra el grid tratando de conectar las piezas de forma que haya un camino válido desde el inicio hasta el final.

    Aquí tienes el código mejorado:

    import tkinter as tk
    from tkinter import messagebox
    import random
    
    # Definición de las piezas
    PIECES = {
        'line': {
            'chars': ['─', '│', '─', '│'],
            'connections': [
                [0, 1, 0, 1],  # 0°, horizontal
                [1, 0, 1, 0],  # 90°, vertical
                [0, 1, 0, 1],  # 180°, horizontal
                [1, 0, 1, 0],  # 270°, vertical
            ]
        },
        'curve': {
            'chars': ['└', '┌', '┐', '┘'],
            'connections': [
                [1, 1, 0, 0],  # 0°, conecta Arriba y Derecha
                [0, 1, 1, 0],  # 90°, conecta Derecha y Abajo
                [0, 0, 1, 1],  # 180°, conecta Abajo y Izquierda
                [1, 0, 0, 1],  # 270°, conecta Izquierda y Arriba
            ]
        },
        't': {
            'chars': ['┬', '┤', '┴', '├'],
            'connections': [
                [1, 1, 0, 1],  # 0°, conecta Arriba, Derecha, Izquierda
                [1, 1, 1, 0],  # 90°, conecta Arriba, Derecha, Abajo
                [0, 1, 1, 1],  # 180°, conecta Derecha, Abajo, Izquierda
                [1, 0, 1, 1],  # 270°, conecta Arriba, Abajo, Izquierda
            ]
        },
        'cross': {
            'chars': ['┼', '┼', '┼', '┼'],
            'connections': [
                [1, 1, 1, 1],
                [1, 1, 1, 1],
                [1, 1, 1, 1],
                [1, 1, 1, 1],
            ]
        }
    }
    
    class Piece:
        def __init__(self, piece_type, rotation=0):
            self.piece_type = piece_type
            self.rotation = rotation
    
        def connections(self):
            return PIECES[self.piece_type]['connections'][self.rotation]
    
        def char(self):
            return PIECES[self.piece_type]['chars'][self.rotation]
    
    class Grid:
        def __init__(self, width, height):
            self.width = width
            self.height = height
            self.grid = [[None for _ in range(width)] for _ in range(height)]
    
        def set_piece(self, x, y, piece):
            self.grid[y][x] = piece
    
        def is_valid_connection(self, x1, y1, x2, y2, direction):
            piece1 = self.grid[y1][x1]
            piece2 = self.grid[y2][x2]
            if not piece1 or not piece2:
                return False
    
            connections1 = piece1.connections()
            connections2 = piece2.connections()
    
            dir_map = {'up': 0, 'right': 1, 'down': 2, 'left': 3}
            opposite_dir_map = {'up': 2, 'right': 3, 'down': 0, 'left': 1}
    
            dir_index = dir_map[direction]
            opp_dir_index = opposite_dir_map[direction]
    
            return connections1[dir_index] == 1 and connections2[opp_dir_index] == 1
    
        def is_path_valid(self, start_x, start_y, end_x, end_y):
            visited = set()
    
            def dfs(x, y):
                if (x, y) == (end_x, end_y):
                    return True
                visited.add((x, y))
    
                directions = ['up', 'right', 'down', 'left']
                dxs_dys = [(-1, 0), (0, 1), (1, 0), (0, -1)]
    
                for dir_idx, (dx, dy) in enumerate(dxs_dys):
                    nx, ny = x + dx, y + dy
                    if 0 <= nx < self.width and 0 <= ny < self.height:
                        if (nx, ny) not in visited and self.is_valid_connection(x, y, nx, ny, directions[dir_idx]):
                            if dfs(nx, ny):
                                return True
    
                return False
    
            return dfs(start_x, start_y)
    
        def generate_random_board(self):
            for y in range(self.height):
                for x in range(self.width):
                    piece_type = random.choice(list(PIECES.keys()))
                    rotation = random.randint(0, 3)
                    self.set_piece(x, y, Piece(piece_type, rotation))
    
    class App:
        def __init__(self, root):
            self.root = root
            self.root.title("Grid Puzzle Solver")
            
            self.grid = Grid(5, 5)
            self.grid.generate_random_board()  # Generar el tablero aleatorio al inicio.
            self.buttons = [[None for _ in range(5)] for _ in range(5)]
            self.current_piece_type = 'line'
            self.current_rotation = 0
            self.setup_ui()
            self.update_ui()
    
        def setup_ui(self):
            control_frame = tk.Frame(self.root)
            control_frame.pack(side=tk.TOP, pady=10)
            
            for piece_type in PIECES:
                button = tk.Button(control_frame, text=piece_type.capitalize(), command=lambda p=piece_type: self.set_piece_type(p))
                button.pack(side=tk.LEFT, padx=5)
    
            rotation_button = tk.Button(control_frame, text="Rotate", command=self.rotate_piece)
            rotation_button.pack(side=tk.LEFT, padx=5)
    
            verify_button = tk.Button(control_frame, text="Verify", command=self.verify_solution)
            verify_button.pack(side=tk.LEFT, padx=5)
    
            solve_button = tk.Button(control_frame, text="Solve", command=self.solve_puzzle)
            solve_button.pack(side=tk.LEFT, padx=5)
    
            grid_frame = tk.Frame(self.root)
            grid_frame.pack(pady=10)
    
            for y in range(5):
                for x in range(5):
                    button = tk.Button(grid_frame, width=5, height=2,
                                       font=("Courier", 20),
                                       command=lambda row=y, col=x: self.place_piece(row, col))
                    button.grid(row=y, column=x)
                    self.buttons[y][x] = button
    
        def set_piece_type(self, piece_type):
            self.current_piece_type = piece_type
    
        def rotate_piece(self):
            self.current_rotation = (self.current_rotation + 1) % 4
    
        def place_piece(self, row, col):
            piece = Piece(self.current_piece_type, self.current_rotation)
            self.grid.set_piece(col, row, piece)
            self.update_ui()
    
        def update_ui(self):
            for y in range(5):
                for x in range(5):
                    piece = self.grid.grid[y][x]
                    if piece:
                        self.buttons[y][x].config(text=piece.char())
                    else:
                        self.buttons[y][x].config(text="")
    
        def verify_solution(self):
            if self.grid.is_path_valid(0, 0, 4, 4):
                messagebox.showinfo("Result", "Valid path found!")
            else:
                messagebox.showerror("Result", "No valid path found.")
    
        def solve_puzzle(self):
            # Esto es un método sencillo que intenta encontrar una solución válida, ajusta las rotaciones.
            for y in range(self.grid.height):
                for x in range(self.grid.width):
                    piece = self.grid.grid[y][x]
                    if piece:
                        for rotation in range(4):
                            piece.rotation = rotation
                            if self.grid.is_path_valid(0, 0, 4, 4):
                                self.update_ui()
                                messagebox.showinfo("Result", "Solved!")
                                return
            messagebox.showerror("Result", "No solution found.")
            self.update_ui()
    
    if __name__ == "__main__":
        root = tk.Tk()
        app = App(root)
        root.mainloop()
    

    Mejoras y Consideraciones:

    • Tablero Aleatorio: Al inicio, el tablero se llena con piezas aleatorias. Esto se realiza en la función generate_random_board.

    • Botón de Solución: Añadido un botón "Solve" que intenta encontrar automáticamente una solución válida rotando las piezas. Esto es una implementación básica y a menudo no encontrará una solución para tableros aleatorios muy desordenados, pero es un punto de partida.

    • Interfaz Mejorada: Se han añadido márgenes y alineaciones para mejorar la apariencia del GUI. Los nombres de las piezas se capitalizan en los botones.

    Este código es una base que puedes expandir. Podrías mejorar el algoritmo de solución y ajustar más detalles de la interfaz según sea necesario.

  7. User

    indica con un fondo verde el inicio y el final con un fondo rojo. Quita los botones de piezas, el usuario solo podra rotar las piezas

  8. Assistant

    Vamos a modificar el programa para:

    1. Eliminar los botones de selección de tipo de pieza, para que el usuario solo pueda rotar las piezas ya colocadas.
    2. Indicar el inicio con un fondo verde y el final con un fondo rojo.

    Aquí está el código modificado:

    import tkinter as tk
    from tkinter import messagebox
    import random
    
    # Definición de las piezas
    PIECES = {
        'line': {
            'chars': ['─', '│', '─', '│'],
            'connections': [
                [0, 1, 0, 1],  # 0°, horizontal
                [1, 0, 1, 0],  # 90°, vertical
                [0, 1, 0, 1],  # 180°, horizontal
                [1, 0, 1, 0],  # 270°, vertical
            ]
        },
        'curve': {
            'chars': ['└', '┌', '┐', '┘'],
            'connections': [
                [1, 1, 0, 0],  # 0°, conecta Arriba y Derecha
                [0, 1, 1, 0],  # 90°, conecta Derecha y Abajo
                [0, 0, 1, 1],  # 180°, conecta Abajo y Izquierda
                [1, 0, 0, 1],  # 270°, conecta Izquierda y Arriba
            ]
        },
        't': {
            'chars': ['┬', '┤', '┴', '├'],
            'connections': [
                [1, 1, 0, 1],  # 0°, conecta Arriba, Derecha, Izquierda
                [1, 1, 1, 0],  # 90°, conecta Arriba, Derecha, Abajo
                [0, 1, 1, 1],  # 180°, conecta Derecha, Abajo, Izquierda
                [1, 0, 1, 1],  # 270°, conecta Arriba, Abajo, Izquierda
            ]
        },
        'cross': {
            'chars': ['┼', '┼', '┼', '┼'],
            'connections': [
                [1, 1, 1, 1],
                [1, 1, 1, 1],
                [1, 1, 1, 1],
                [1, 1, 1, 1],
            ]
        }
    }
    
    class Piece:
        def __init__(self, piece_type, rotation=0):
            self.piece_type = piece_type
            self.rotation = rotation
    
        def connections(self):
            return PIECES[self.piece_type]['connections'][self.rotation]
    
        def char(self):
            return PIECES[self.piece_type]['chars'][self.rotation]
    
    class Grid:
        def __init__(self, width, height):
            self.width = width
            self.height = height
            self.grid = [[None for _ in range(width)] for _ in range(height)]
    
        def set_piece(self, x, y, piece):
            self.grid[y][x] = piece
    
        def is_valid_connection(self, x1, y1, x2, y2, direction):
            piece1 = self.grid[y1][x1]
            piece2 = self.grid[y2][x2]
            if not piece1 or not piece2:
                return False
    
            connections1 = piece1.connections()
            connections2 = piece2.connections()
    
            dir_map = {'up': 0, 'right': 1, 'down': 2, 'left': 3}
            opposite_dir_map = {'up': 2, 'right': 3, 'down': 0, 'left': 1}
    
            dir_index = dir_map[direction]
            opp_dir_index = opposite_dir_map[direction]
    
            return connections1[dir_index] == 1 and connections2[opp_dir_index] == 1
    
        def is_path_valid(self, start_x, start_y, end_x, end_y):
            visited = set()
    
            def dfs(x, y):
                if (x, y) == (end_x, end_y):
                    return True
                visited.add((x, y))
    
                directions = ['up', 'right', 'down', 'left']
                dxs_dys = [(-1, 0), (0, 1), (1, 0), (0, -1)]
    
                for dir_idx, (dx, dy) in enumerate(dxs_dys):
                    nx, ny = x + dx, y + dy
                    if 0 <= nx < self.width and 0 <= ny < self.height:
                        if (nx, ny) not in visited and self.is_valid_connection(x, y, nx, ny, directions[dir_idx]):
                            if dfs(nx, ny):
                                return True
    
                return False
    
            return dfs(start_x, start_y)
    
        def generate_random_board(self):
            for y in range(self.height):
                for x in range(self.width):
                    piece_type = random.choice(list(PIECES.keys()))
                    rotation = random.randint(0, 3)
                    self.set_piece(x, y, Piece(piece_type, rotation))
    
    class App:
        def __init__(self, root):
            self.root = root
            self.root.title("Grid Puzzle Solver")
            
            self.grid = Grid(5, 5)
            self.grid.generate_random_board()  # Generar el tablero aleatorio al inicio.
            self.buttons = [[None for _ in range(5)] for _ in range(5)]
            self.setup_ui()
            self.update_ui()
    
        def setup_ui(self):
            control_frame = tk.Frame(self.root)
            control_frame.pack(side=tk.TOP, pady=10)
            
            rotation_button = tk.Button(control_frame, text="Rotate Piece", command=self.rotate_piece)
            rotation_button.pack(side=tk.LEFT, padx=5)
    
            verify_button = tk.Button(control_frame, text="Verify", command=self.verify_solution)
            verify_button.pack(side=tk.LEFT, padx=5)
    
            solve_button = tk.Button(control_frame, text="Solve", command=self.solve_puzzle)
            solve_button.pack(side=tk.LEFT, padx=5)
    
            grid_frame = tk.Frame(self.root)
            grid_frame.pack(pady=10)
    
            for y in range(5):
                for x in range(5):
                    button = tk.Button(grid_frame, width=5, height=2,
                                       font=("Courier", 20),
                                       command=lambda row=y, col=x: self.place_piece(row, col))
                    button.grid(row=y, column=x)
                    self.buttons[y][x] = button
    
            # Establecer los colores de fondo para el inicio y el final
            self.buttons[0][0].config(bg="lightgreen")
            self.buttons[4][4].config(bg="lightcoral")
    
        def rotate_piece(self):
            self.current_rotation = (self.current_rotation + 1) % 4
    
        def place_piece(self, row, col):
            piece = self.grid.grid[row][col]
            piece.rotation = (piece.rotation + 1) % 4
            self.update_ui()
    
        def update_ui(self):
            for y in range(5):
                for x in range(5):
                    piece = self.grid.grid[y][x]
                    if piece:
                        self.buttons[y][x].config(text=piece.char())
                    else:
                        self.buttons[y][x].config(text="")
    
        def verify_solution(self):
            if self.grid.is_path_valid(0, 0, 4, 4):
                messagebox.showinfo("Result", "Valid path found!")
            else:
                messagebox.showerror("Result", "No valid path found.")
    
        def solve_puzzle(self):
            # Esto es un método sencillo que intenta encontrar una solución válida, ajusta las rotaciones.
            for y in range(self.grid.height):
                for x in range(self.grid.width):
                    piece = self.grid.grid[y][x]
                    if piece:
                        for rotation in range(4):
                            piece.rotation = rotation
                            if self.grid.is_path_valid(0, 0, 4, 4):
                                self.update_ui()
                                messagebox.showinfo("Result", "Solved!")
                                return
            messagebox.showerror("Result", "No solution found.")
            self.update_ui()
    
    if __name__ == "__main__":
        root = tk.Tk()
        app = App(root)
        root.mainloop()
    

    Cambios Realizados:

    • Colores de Inicio y Final: El botón de la posición inicial (0, 0) está configurado con un fondo verde claro y el botón de la posición final (4, 4) tiene un fondo rojo claro para distinguir visualmente el inicio y el final en el tablero.

    • Interacción Simplificada: Se ha removido la selección de tipo de pieza. El usuario solo puede rotar las piezas existentes para encontrar una solución válida. Esto se hace haciendo clic en las piezas (simula un clic para rotar).

    • Interfaz Mejorada: Botones para rotar una pieza, verificar la solución y resolver el puzzle automático se encuentran en la barra superior.

    Esta versión del código proporciona una simplificación en cuanto a la interacción y una presentación mejorada orientada hacia el objetivo de encontrar un camino válido conectando los componentes en el grid.