Juego de las ocho reinas

En esta ocasión te traeré el entretenido juego de las ocho reinas desarrollado en una versión gráfica con Java y la librería Swing, implementado en el IDE Eclipse. El código incluye explicaciones detalladas línea por línea para que cualquiera pueda entenderlo, incluso sin experiencia previa en Java.

Codigo fuente del juego de las ocho reinas

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

/**
 * Este programa implementa el juego de las ocho reinas utilizando una interfaz gráfica basada en Swing.
 */
public class QueensGame extends JFrame {

    private final int SIZE = 8; // Tamaño del tablero
    private JButton[][] board; // Matriz de botones que representa el tablero
    private boolean[][] queens; // Matriz lógica para almacenar la ubicación de las reinas

    public QueensGame() {
        // Configuración básica de la ventana
        setTitle("Juego de las Ocho Reinas");
        setSize(600, 600);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLayout(new BorderLayout());

        // Inicializar el tablero gráfico
        JPanel boardPanel = new JPanel(new GridLayout(SIZE, SIZE));
        board = new JButton[SIZE][SIZE];
        queens = new boolean[SIZE][SIZE];

        // Crear botones para el tablero
        for (int row = 0; row < SIZE; row++) {
            for (int col = 0; col < SIZE; col++) {
                JButton button = new JButton();
                button.setBackground((row + col) % 2 == 0 ? Color.WHITE : Color.GRAY); // Colores alternos
                int finalRow = row;
                int finalCol = col;

                // Acción al hacer clic en un botón
                button.addActionListener(e -> placeQueen(finalRow, finalCol));
                board[row][col] = button;
                boardPanel.add(button);
            }
        }

        // Agregar el tablero y las instrucciones
        add(boardPanel, BorderLayout.CENTER);
        add(createInstructionsPanel(), BorderLayout.SOUTH);
    }

    /**
     * Crear un panel de instrucciones para los jugadores.
     * @return JPanel con las instrucciones del juego.
     */
    private JPanel createInstructionsPanel() {
        JPanel instructionsPanel = new JPanel();
        instructionsPanel.setLayout(new GridLayout(0, 1));
        JLabel instructions = new JLabel("Instrucciones: Coloca 8 reinas en el tablero sin que se ataquen entre ellas.");
        JLabel rules = new JLabel("Las reinas no deben compartir fila, columna ni diagonal.");
        instructionsPanel.add(instructions);
        instructionsPanel.add(rules);
        return instructionsPanel;
    }

    /**
     * Coloca o elimina una reina en la posición indicada.
     * @param row Fila seleccionada.
     * @param col Columna seleccionada.
     */
    private void placeQueen(int row, int col) {
        if (queens[row][col]) {
            // Si ya hay una reina, la eliminamos
            queens[row][col] = false;
            board[row][col].setText("");
        } else {
            // Verificar si la posición es válida para colocar una reina
            if (isValid(row, col)) {
                queens[row][col] = true;
                board[row][col].setText("Q");
            } else {
                JOptionPane.showMessageDialog(this, "No puedes colocar una reina aquí, sería atacada.");
            }
        }
    }

    /**
     * Comprueba si es válido colocar una reina en la posición dada.
     * @param row Fila a comprobar.
     * @param col Columna a comprobar.
     * @return true si es válido, false en caso contrario.
     */
    private boolean isValid(int row, int col) {
        // Verificar la columna
        for (int i = 0; i < SIZE; i++) {
            if (queens[i][col]) {
                return false;
            }
        }

        // Verificar la fila
        for (int j = 0; j < SIZE; j++) {
            if (queens[row][j]) {
                return false;
            }
        }

        // Verificar diagonales
        for (int i = 1; i < SIZE; i++) {
            if (row - i >= 0 && col - i >= 0 && queens[row - i][col - i]) {
                return false;
            }
            if (row - i >= 0 && col + i < SIZE && queens[row - i][col + i]) {
                return false;
            }
            if (row + i < SIZE && col - i >= 0 && queens[row + i][col - i]) {
                return false;
            }
            if (row + i < SIZE && col + i < SIZE && queens[row + i][col + i]) {
                return false;
            }
        }

        return true;
    }

    /**
     * Método principal para iniciar el juego.
     * @param args Argumentos de la línea de comandos (no se utilizan).
     */
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> {
            QueensGame game = new QueensGame();
            game.setVisible(true);
        });
    }
}

Explicación del código:

Configuración inicial:

-Se crea una ventana (JFrame) con el título «Juego de las Ocho Reinas» y un tamaño predefinido.

-Se organiza el contenido en un diseño de borde (BorderLayout), con el tablero al centro y las instrucciones en la parte inferior.

Tablero gráfico:

-Se usa un GridLayout para organizar los botones en una cuadrícula de 8×8.

-Cada botón representa una celda del tablero y alterna entre colores blanco y gris.

Lógica de las reinas:

-Una matriz lógica (queens) almacena dónde están las reinas.

-Al hacer clic en un botón, se coloca o elimina una reina, verificando si la posición es válida.

Validación:

-El método isValid comprueba que una reina no comparta fila, columna ni diagonal con otra.

Interfaz:

-Se incluye un panel de instrucciones con reglas básicas para los jugadores.

Inicio del programa:

-La aplicación se ejecuta con SwingUtilities.invokeLater para garantizar la creación segura de la interfaz gráfica en el hilo de eventos.

Instrucciones para jugar:

– Haz clic en una celda del tablero para colocar una reina.

– Evita colocar una reina en posiciones donde pueda ser atacada (misma fila, columna o diagonal).

– El objetivo es colocar 8 reinas sin que se ataquen entre sí.