Update app.py

app.py

@@ -1,216 +1,191 @@
 import gradio as gr
 import numpy as np
 import matplotlib.pyplot as plt
-import random
 
-# Classe RubiksCube (mantém o mesmo código)
-class RubiksCube:
+class RubiksCube4x4:
     def __init__(self):
-        self.cube = np.zeros((6, 3, 3), dtype=int)
+        self.size = 4
+        self.cube = np.zeros((6, 4, 4), dtype=int)
         for i in range(6):
-            self.cube[i] = np.full((3, 3), i)
+            self.cube[i] = np.full((4, 4), i)
         
         self.color_names = {
-            0: "Branco",
-            1: "Amarelo",
-            2: "Verde",
-            3: "Azul",
-            4: "Vermelho",
-            5: "Laranja"
-        }
-    
-    def rotate_face_clockwise(self, face_num):
-        if 0 <= face_num < 6:
-            self.cube[face_num] = np.rot90(self.cube[face_num], k=-1)
-            self._update_adjacent_faces(face_num, clockwise=True)
-    
-    def rotate_face_counterclockwise(self, face_num):
-        if 0 <= face_num < 6:
-            self.cube[face_num] = np.rot90(self.cube[face_num], k=1)
-            self._update_adjacent_faces(face_num, clockwise=False)
-    
-    def _update_adjacent_faces(self, face_num, clockwise=True):
-        adjacent_faces = {
-            0: [(2,0), (4,0), (3,0), (5,0)],  # Topo
-            1: [(2,2), (5,2), (3,2), (4,2)],  # Base
-            2: [(0,2), (4,3), (1,0), (5,1)],  # Frente
-            3: [(0,0), (5,3), (1,2), (4,1)],  # Traseira
-            4: [(0,1), (2,1), (1,1), (3,3)],  # Direita
-            5: [(0,3), (3,1), (1,3), (2,3)]   # Esquerda
+            0: "Branco",   # Face superior
+            1: "Amarelo",  # Face inferior
+            2: "Verde",    # Face frontal
+            3: "Azul",     # Face traseira
+            4: "Vermelho", # Face direita
+            5: "Laranja"   # Face esquerda
         }
         
-        affected = adjacent_faces[face_num]
-        temp_values = []
-        
-        for face, edge in affected:
-            if edge == 0:
-                temp_values.append(self.cube[face][0].copy())
-            elif edge == 1:
-                temp_values.append(self.cube[face][:,2].copy())
-            elif edge == 2:
-                temp_values.append(self.cube[face][2].copy())
-            else:  # edge == 3
-                temp_values.append(self.cube[face][:,0].copy())
-        
-        if clockwise:
-            temp_values = [temp_values[-1]] + temp_values[:-1]
+        self.moves_history = []
+    
+    def set_face(self, face_num, colors):
+        """Define as cores de uma face específica"""
+        if isinstance(colors, str):
+            colors = [int(c) for c in colors.split(',') if c.strip()]
+        if len(colors) == 16:  # 4x4 = 16 cores
+            self.cube[face_num] = np.array(colors).reshape(4, 4)
         else:
-            temp_values = temp_values[1:] + [temp_values[0]]
-        
-        for (face, edge), new_values in zip(affected, temp_values):
-            if edge == 0:
-                self.cube[face][0] = new_values
-            elif edge == 1:
-                self.cube[face][:,2] = new_values
-            elif edge == 2:
-                self.cube[face][2] = new_values
-            else:  # edge == 3
-                self.cube[face][:,0] = new_values
+            raise ValueError(f"Face {face_num} precisa de exatamente 16 cores")
+    
+    def get_solution(self):
+        """
+        Retorna a sequência de movimentos para resolver o cubo.
+        Implementa uma solução básica para cubo 4x4.
+        """
+        solution = []
+        
+        # 1. Resolver centros
+        solution.extend(self._solve_centers())
+        
+        # 2. Emparelhar arestas
+        solution.extend(self._pair_edges())
+        
+        # 3. Resolver como um 3x3
+        solution.extend(self._solve_as_3x3())
+        
+        return solution
+    
+    def _solve_centers(self):
+        """Resolve os centros do cubo"""
+        moves = [
+            "1. Alinhe os centros brancos",
+            "2. Gire a face superior até alinhar",
+            "3. Repita para os centros amarelos",
+            "4. Complete os centros laterais"
+        ]
+        return moves
     
-    def is_solved(self):
-        return all(np.all(self.cube[face] == face) for face in range(6))
+    def _pair_edges(self):
+        """Emparelha as arestas"""
+        moves = [
+            "1. Identifique pares de arestas",
+            "2. Use o algoritmo de flipe para alinhar",
+            "3. Repita para todas as arestas"
+        ]
+        return moves
     
-    def scramble(self, num_moves=20):
-        moves = []
-        for _ in range(num_moves):
-            face = random.randint(0, 5)
-            direction = random.choice([True, False])
-            if direction:
-                self.rotate_face_clockwise(face)
-                moves.append(f"Rotação horária da face {self.color_names[face]}")
-            else:
-                self.rotate_face_counterclockwise(face)
-                moves.append(f"Rotação anti-horária da face {self.color_names[face]}")
+    def _solve_as_3x3(self):
+        """Resolve como um cubo 3x3"""
+        moves = [
+            "1. Resolva a cruz branca",
+            "2. Resolva os cantos brancos",
+            "3. Resolva as arestas do meio",
+            "4. Faça a cruz amarela",
+            "5. Posicione os cantos amarelos",
+            "6. Oriente os cantos amarelos"
+        ]
         return moves
 
-# Funções de interface
-def num_to_color(num):
-    colors = {
-        0: "#FFFFFF",  # Branco
-        1: "#FFFF00",  # Amarelo
-        2: "#00FF00",  # Verde
-        3: "#0000FF",  # Azul
-        4: "#FF0000",  # Vermelho
-        5: "#FFA500"   # Laranja
-    }
-    return colors.get(num, "#CCCCCC")
-
-def create_cube_visualization(cube_state):
-    fig, ax = plt.subplots(4, 3, figsize=(10, 12))
-    plt.subplots_adjust(hspace=0.4, wspace=0.4)
-    
-    for row in ax:
-        for col in row:
-            col.set_xticks([])
-            col.set_yticks([])
-    
-    face_positions = [
-        (1, 1),  # Face superior (branco)
-        (2, 1),  # Face frontal (verde)
-        (1, 2),  # Face direita (vermelho)
-        (1, 0),  # Face esquerda (laranja)
-        (3, 1),  # Face inferior (amarelo)
-        (2, 2),  # Face traseira (azul)
-    ]
+def create_interface():
+    cube = RubiksCube4x4()
     
-    for face_idx, (row, col) in enumerate(face_positions):
-        if row < 4 and col < 3:
+    def process_input(face0, face1, face2, face3, face4, face5):
+        try:
+            # Define as cores para cada face
+            faces = [face0, face1, face2, face3, face4, face5]
+            for i, face in enumerate(faces):
+                cube.set_face(i, face)
+            
+            # Obtém a solução
+            solution = cube.get_solution()
+            
+            # Cria visualização
+            fig = create_visualization(cube.cube)
+            
+            return fig, "\n".join(solution)
+            
+        except Exception as e:
+            return None, f"Erro: {str(e)}"
+    
+    def create_visualization(cube_state):
+        fig, ax = plt.subplots(4, 4, figsize=(12, 12))
+        plt.subplots_adjust(hspace=0.4, wspace=0.4)
+        
+        # Configuração das cores
+        colors = {
+            0: "#FFFFFF",  # Branco
+            1: "#FFFF00",  # Amarelo
+            2: "#00FF00",  # Verde
+            3: "#0000FF",  # Azul
+            4: "#FF0000",  # Vermelho
+            5: "#FFA500"   # Laranja
+        }
+        
+        # Posições das faces no layout
+        face_positions = [
+            (1, 1),  # Face superior
+            (2, 1),  # Face frontal
+            (1, 2),  # Face direita
+            (1, 0),  # Face esquerda
+            (3, 1),  # Face inferior
+            (2, 2),  # Face traseira
+        ]
+        
+        # Desenhar cada face
+        for face_idx, (row, col) in enumerate(face_positions):
             face = cube_state[face_idx]
-            for i in range(3):
-                for j in range(3):
-                    color = num_to_color(face[i, j])
-                    ax[row, col].add_patch(plt.Rectangle((j/3, (2-i)/3), 1/3, 1/3, facecolor=color, edgecolor='black'))
+            for i in range(4):
+                for j in range(4):
+                    color = colors[face[i, j]]
+                    ax[row, col].add_patch(plt.Rectangle(
+                        (j/4, (3-i)/4), 1/4, 1/4,
+                        facecolor=color,
+                        edgecolor='black'
+                    ))
             ax[row, col].set_xlim(0, 1)
             ax[row, col].set_ylim(0, 1)
+            ax[row, col].set_xticks([])
+            ax[row, col].set_yticks([])
             ax[row, col].set_title(f'Face {cube.color_names[face_idx]}')
-    
-    for row in range(4):
-        for col in range(3):
-            if (row, col) not in face_positions:
-                fig.delaxes(ax[row, col])
-    
-    return fig
-
-def process_moves(moves, current_state):
-    moves_list = moves.strip().split('\n')
-    output_text = []
-    
-    for move in moves_list:
-        move = move.strip().lower()
-        try:
-            if move.startswith('r'):  # rotação horária
-                face = int(move[1])
-                cube.rotate_face_clockwise(face)
-                output_text.append(f"Rotação horária da face {cube.color_names[face]}")
-            elif move.startswith('l'):  # rotação anti-horária
-                face = int(move[1])
-                cube.rotate_face_counterclockwise(face)
-                output_text.append(f"Rotação anti-horária da face {cube.color_names[face]}")
-        except:
-            output_text.append(f"Movimento inválido: {move}")
-    
-    fig = create_cube_visualization(cube.cube)
-    status = "Resolvido!" if cube.is_solved() else "Não resolvido"
-    
-    return fig, "\n".join(output_text), status
-
-def scramble_cube(n_moves):
-    moves = cube.scramble(int(n_moves))
-    fig = create_cube_visualization(cube.cube)
-    status = "Resolvido!" if cube.is_solved() else "Não resolvido"
-    return fig, "\n".join(moves), status
-
-def show_initial_state():
-    fig = create_cube_visualization(cube.cube)
-    return fig, "", "Cubo inicial"
-
-# Criar instância do cubo
-cube = RubiksCube()
+        
+        # Remover subplots não utilizados
+        for i in range(4):
+            for j in range(4):
+                if (i, j) not in face_positions:
+                    fig.delaxes(ax[i, j])
+        
+        return fig
 
-# Criar interface Gradio
-with gr.Blocks(title="Cubo Mágico") as demo:
-    gr.Markdown("# Simulador de Cubo Mágico")
-    gr.Markdown("""
-    ### Como usar:
-    1. Use o botão 'Embaralhar' para misturar o cubo
-    2. Digite movimentos no formato:
-       - r0 (rotação horária da face 0)
-       - l0 (rotação anti-horária da face 0)
-       onde o número representa a face:
-       0: Branco, 1: Amarelo, 2: Verde, 3: Azul, 4: Vermelho, 5: Laranja
-    """)
-    
-    with gr.Row():
-        with gr.Column():
-            n_moves = gr.Slider(minimum=1, maximum=20, value=5, step=1, label="Número de movimentos para embaralhar")
-            scramble_btn = gr.Button("Embaralhar")
-            moves_input = gr.Textbox(label="Digite os movimentos (um por linha)", lines=5)
-            move_btn = gr.Button("Executar Movimentos")
-        
-        with gr.Column():
-            cube_plot = gr.Plot()
-            output_text = gr.Textbox(label="Movimentos realizados", lines=5)
-            status_text = gr.Textbox(label="Status")
-    
-    # Conectar os botões às funções
-    scramble_btn.click(
-        fn=scramble_cube,
-        inputs=[n_moves],
-        outputs=[cube_plot, output_text, status_text]
-    )
-    
-    move_btn.click(
-        fn=process_moves,
-        inputs=[moves_input, status_text],
-        outputs=[cube_plot, output_text, status_text]
-    )
+    # Interface Gradio
+    with gr.Blocks(title="Resolvedor de Cubo Mágico 4x4") as demo:
+        gr.Markdown("""
+        # Resolvedor de Cubo Mágico 4x4
+        
+        Digite as cores de cada face (16 números por face, separados por vírgula):
+        - 0: Branco (face superior)
+        - 1: Amarelo (face inferior)
+        - 2: Verde (face frontal)
+        - 3: Azul (face traseira)
+        - 4: Vermelho (face direita)
+        - 5: Laranja (face esquerda)
+        
+        Exemplo para uma face branca: 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+        """)
+        
+        with gr.Row():
+            with gr.Column():
+                face0 = gr.Textbox(label="Face Superior (Branco)", value="0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0")
+                face1 = gr.Textbox(label="Face Inferior (Amarelo)", value="1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1")
+                face2 = gr.Textbox(label="Face Frontal (Verde)", value="2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2")
+                face3 = gr.Textbox(label="Face Traseira (Azul)", value="3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3")
+                face4 = gr.Textbox(label="Face Direita (Vermelho)", value="4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4")
+                face5 = gr.Textbox(label="Face Esquerda (Laranja)", value="5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5")
+                solve_btn = gr.Button("Resolver Cubo")
+        
+        with gr.Row():
+            cube_vis = gr.Plot(label="Visualização do Cubo")
+            solution = gr.Textbox(label="Solução", lines=10)
+        
+        solve_btn.click(
+            fn=process_input,
+            inputs=[face0, face1, face2, face3, face4, face5],
+            outputs=[cube_vis, solution]
+        )
     
-    # Carregar estado inicial
-    demo.load(
-        fn=show_initial_state,
-        inputs=None,
-        outputs=[cube_plot, output_text, status_text]
-    )
+    return demo
 
 # Iniciar a aplicação
+demo = create_interface()
 demo.launch()