Skip to content
TheChatArchiveThe Chat Archive
o1-preview-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

crea una irterfaz grafica estetica en java "import java.util.*; public class Main { //…

  1. User

    crea una irterfaz grafica estetica en java "import java.util.*;

    public class Main {

    // Variables finales para indicar el numero de capas y cables de la bomba
    private static final int NUM_CAPAS = 5;
    private static final int NUM_CABLES = 5;
    
    private static int numeroAleatorio(int valor) {
        Random random = new Random();
        return random.nextInt(valor) + 1;
    }
    
    // Obtiene un numero aleatorio del 1 al 5 y lo multiplica por 10, ej 10, 20, 30, 40 o 50
    private static int obtenerCable() {
        return numeroAleatorio(5) * 10;
    }
    
    // Obtiene los 5 cables y los agrega a una capa
    private static int[] obtenerCapa(int cantidadCables) {
        int[] capa = new int[cantidadCables];
        for (int i = 0; i < cantidadCables; i++) {
            capa[i] = obtenerCable() + i + 1;
        }
        return capa;
    }
    
    // Obtiene cada capa y las agrega a la bomba
    private static int[][] generarBomba() {
        int[][] bomba = new int[NUM_CAPAS][NUM_CABLES];
        for (int i = 0; i < NUM_CAPAS; i++) {
            bomba[i] = obtenerCapa(NUM_CABLES);
        }
        return bomba;
    }
    
    // Muestra una capa especifica
    private static void mostrarCapa(int capa, int[][] bomba) {
        System.out.println(Arrays.toString(bomba[capa]));
    }
    
    // Muestra al usuario los cables de una capa, con el fin de que escoja cual cortar
    private static void mostrarOpciones(int[][] bomba, int posicion) {
        for (int i = 0; i < NUM_CABLES; i++) {
            System.out.println((i + 1) + ") " + bomba[posicion][i]);
        }
    }
    
    // Toma desde consola un valor del 1 al 5 ingresado por el usuario
    private static int escogerOpcion(Scanner scanner) {
        int opcion;
        // Se ejecuta hasta que ingrese un digito valido, no controla valores distintos a enteros
        do {
            System.out.print("Elige una opción (1-5): ");
            opcion = scanner.nextInt();
        } while (opcion < 1 || opcion > NUM_CABLES);
        return opcion;
    }
    
    public static void main(String[] args) {
    
    
        // Genera una bomba, por defecto de 5 x 5
        int[][] bomba = generarBomba();
        Scanner scanner = new Scanner(System.in);
    
        // Ejecuta un bloque de codigo por cada capa
        for (int i = 0; i < NUM_CAPAS; i++) {
    
            // Crea conjuntos vacios A, B y C
            int[] conjuntoA = new int[3];
            int[] conjuntoB = new int[3];
            int[] conjuntoC = new int[3];
    
            // Selecciona un cable aleatorio de la capa "i" el cual tomara el papel de cable a cortar
            int cableAleatorio = numeroAleatorio(NUM_CABLES) - 1;
    
            // Guarda el cable a cortar
            int cableCorrecto = bomba[i][cableAleatorio];
    
            // Crea una lista del 1 al 3, para dar aleatoriedad al orden de los conjuntos
            List<Integer> numbers = new ArrayList<>();
            for (int j = 0; j < 3; j++) {
                numbers.add(j);
            }
    
            // Randomiza la lista
            Collections.shuffle(numbers);
    
            // Creamos un LinkedHashSet para que no se creen cables repetidos en los conjuntos
            Set<Integer> uniqueNumbers = new LinkedHashSet<>();
    
            // Agregamos al set los cables de la capa
            for (int j = 0; j < 5; j++) {
                uniqueNumbers.add(bomba[i][j]);
            }
    
            // Creamos los cables aleatorios, se ejecutara hasta que se creen los cables no repetidos.
            while (uniqueNumbers.size() < 10) {
                int number = obtenerCable() + numeroAleatorio(5);
                uniqueNumbers.add(number);
            }
    
            // Convertir el Set a un array de enteros
            int[] array = new int[uniqueNumbers.size()];
            int index = 0;
            for (Integer number : uniqueNumbers) {
                array[index++] = number;
            }
    
            // Se agrega, los cables, correctos, repetido y cables aleatorios, a cada conjunto
            //Conjunto A
            conjuntoA[numbers.get(0)] = cableCorrecto;
            conjuntoA[numbers.get(1)] = array[5];
            conjuntoA[numbers.get(2)] = array[6];
    
            //Conjunto B
            conjuntoB[numbers.get(0)] = array[5];
            conjuntoB[numbers.get(1)] = cableCorrecto;
            conjuntoB[numbers.get(2)] = array[7];
    
            //Conjunto C
            conjuntoC[numbers.get(0)] = array[8];
            conjuntoC[numbers.get(1)] = array[9];
            conjuntoC[numbers.get(2)] = array[5];
    
            // Mostramos la capa actual
            System.out.println("Capa " + (i + 1));
            mostrarCapa(i, bomba);
    
            // Mostramos los Conjuntos - Pistas
            System.out.println("\nPista:");
            System.out.println("(A∩B)-C");
            System.out.println("A: " + Arrays.toString(conjuntoA));
            System.out.println("B: " + Arrays.toString(conjuntoB));
            System.out.println("C: " + Arrays.toString(conjuntoC) + "\n");
    
            // Mostramos los posibles cables a cortar
            mostrarOpciones(bomba, i);
    
            // Recibe la entrada del usuario
            int opcion = escogerOpcion(scanner) - 1;
    
            // Verifica si el la opcion no es correcta, en caso de no serlo la bomba explota y termina el programa
            if (cableAleatorio != opcion) {
                System.out.println("Opción incorrecta\nLa bomba explotó");
                break;
            }
    
            // Si el cable correcto se ejecuta este bloque
            // Indica cual cable corto y en cual capa se encuentra
            System.out.println("Cortaste el cable: " + cableCorrecto);
            if (i < NUM_CAPAS - 1) {
                System.out.println("Muy bien, continúa así.\n");
            } else {
                System.out.println("Excelente trabajo salvando a la ciudad");
            }
        }
        scanner.close();
    }
    

    }"

  2. Assistant

    ¡Claro! Puedo ayudarte a crear una interfaz gráfica estética para tu juego de desactivación de bombas en Java. Usaremos JavaFX para crear una interfaz moderna y atractiva. A continuación, te proporcionaré el código completo y explicaré cómo integrarlo.

    Requisitos Previos

    • Java Development Kit (JDK) 8 o superior.
    • JavaFX (A partir de JDK 11, JavaFX se distribuye por separado). Puedes descargarlo desde Gluon.
    • Un IDE como IntelliJ IDEA, Eclipse o NetBeans.

    Estructura del Proyecto

    Crearemos una clase principal y dividiremos el código en métodos para mantenerlo organizado. La interfaz gráfica mostrará:

    • La capa actual de la bomba con los cables visualmente representados.
    • Las pistas con los conjuntos A, B y C.
    • Botones para que el usuario seleccione el cable a cortar.

    Código Fuente

    import javafx.application.Application;
    import javafx.geometry.Insets;
    import javafx.geometry.Pos;
    import javafx.scene.Scene;
    import javafx.scene.control.Button;
    import javafx.scene.control.Label;
    import javafx.scene.control.Alert;
    import javafx.scene.control.Alert.AlertType;
    import javafx.scene.layout.*;
    import javafx.stage.Stage;
    
    import java.util.*;
    
    public class BombDefusalGame extends Application {
    
        private static final int NUM_CAPAS = 5;
        private static final int NUM_CABLES = 5;
        private int[][] bomba;
        private int capaActual = 0;
        private int cableCorrecto;
        private Label labelCapa;
        private Label labelPista;
        private HBox hboxCables;
        private Stage primaryStage;
    
        public static void main(String[] args) {
            launch(args);
        }
    
        @Override
        public void start(Stage primaryStage) {
            this.primaryStage = primaryStage;
            bomba = generarBomba();
    
            BorderPane root = new BorderPane();
            root.setPadding(new Insets(20));
    
            labelCapa = new Label("Capa 1");
            labelCapa.setStyle("-fx-font-size: 24px; -fx-font-weight: bold;");
            root.setTop(labelCapa);
            BorderPane.setAlignment(labelCapa, Pos.CENTER);
    
            hboxCables = new HBox(10);
            hboxCables.setAlignment(Pos.CENTER);
            root.setCenter(hboxCables);
    
            labelPista = new Label();
            labelPista.setStyle("-fx-font-size: 16px;");
            VBox vboxPista = new VBox(labelPista);
            vboxPista.setAlignment(Pos.CENTER);
            vboxPista.setPadding(new Insets(20, 0, 0, 0));
            root.setBottom(vboxPista);
    
            prepararCapa();
    
            Scene scene = new Scene(root, 600, 400);
            primaryStage.setTitle("Desactivación de Bombas");
            primaryStage.setScene(scene);
            primaryStage.show();
        }
    
        private void prepararCapa() {
            if (capaActual >= NUM_CAPAS) {
                mostrarMensaje("¡Felicidades!", "Has desactivado la bomba y salvado a la ciudad.", AlertType.INFORMATION);
                primaryStage.close();
                return;
            }
    
            labelCapa.setText("Capa " + (capaActual + 1));
            hboxCables.getChildren().clear();
    
            int[] cablesCapa = bomba[capaActual];
    
            // Generar el cable correcto y las pistas
            cableCorrecto = generarPistas();
    
            for (int i = 0; i < NUM_CABLES; i++) {
                Button btnCable = new Button("Cable " + (i + 1));
                btnCable.setPrefSize(100, 50);
                int indiceCable = i;
                btnCable.setOnAction(e -> verificarCable(indiceCable));
                hboxCables.getChildren().add(btnCable);
            }
        }
    
        private int numeroAleatorio(int valor) {
            Random random = new Random();
            return random.nextInt(valor) + 1;
        }
    
        private int obtenerCable() {
            return numeroAleatorio(5) * 10;
        }
    
        private int[] obtenerCapa(int cantidadCables) {
            int[] capa = new int[cantidadCables];
            for (int i = 0; i < cantidadCables; i++) {
                capa[i] = obtenerCable() + i + 1;
            }
            return capa;
        }
    
        private int[][] generarBomba() {
            int[][] bomba = new int[NUM_CAPAS][NUM_CABLES];
            for (int i = 0; i < NUM_CAPAS; i++) {
                bomba[i] = obtenerCapa(NUM_CABLES);
            }
            return bomba;
        }
    
        private int generarPistas() {
            int[] conjuntoA = new int[3];
            int[] conjuntoB = new int[3];
            int[] conjuntoC = new int[3];
    
            int cableAleatorio = numeroAleatorio(NUM_CABLES) - 1;
            int cableCorrecto = bomba[capaActual][cableAleatorio];
    
            List<Integer> numbers = new ArrayList<>();
            for (int j = 0; j < 3; j++) {
                numbers.add(j);
            }
            Collections.shuffle(numbers);
    
            Set<Integer> uniqueNumbers = new LinkedHashSet<>();
            for (int j = 0; j < 5; j++) {
                uniqueNumbers.add(bomba[capaActual][j]);
            }
    
            while (uniqueNumbers.size() < 10) {
                int number = obtenerCable() + numeroAleatorio(5);
                uniqueNumbers.add(number);
            }
    
            int[] array = new int[uniqueNumbers.size()];
            int index = 0;
            for (Integer number : uniqueNumbers) {
                array[index++] = number;
            }
    
            conjuntoA[numbers.get(0)] = cableCorrecto;
            conjuntoA[numbers.get(1)] = array[5];
            conjuntoA[numbers.get(2)] = array[6];
    
            conjuntoB[numbers.get(0)] = array[5];
            conjuntoB[numbers.get(1)] = cableCorrecto;
            conjuntoB[numbers.get(2)] = array[7];
    
            conjuntoC[numbers.get(0)] = array[8];
            conjuntoC[numbers.get(1)] = array[9];
            conjuntoC[numbers.get(2)] = array[5];
    
            labelPista.setText("Pista: (A∩B)-C\n" +
                    "A: " + Arrays.toString(conjuntoA) + "\n" +
                    "B: " + Arrays.toString(conjuntoB) + "\n" +
                    "C: " + Arrays.toString(conjuntoC));
    
            return cableCorrecto;
        }
    
        private void verificarCable(int indiceCable) {
            if (bomba[capaActual][indiceCable] == cableCorrecto) {
                mostrarMensaje("Correcto", "Cortaste el cable correcto: " + cableCorrecto, AlertType.INFORMATION);
                capaActual++;
                prepararCapa();
            } else {
                mostrarMensaje("¡Boom!", "Cortaste el cable incorrecto. La bomba explotó.", AlertType.ERROR);
                primaryStage.close();
            }
        }
    
        private void mostrarMensaje(String titulo, String mensaje, AlertType tipo) {
            Alert alert = new Alert(tipo);
            alert.setTitle(titulo);
            alert.setHeaderText(null);
            alert.setContentText(mensaje);
            alert.showAndWait();
        }
    }
    

    Explicación del Código

    • Clase Principal: BombDefusalGame extiende Application de JavaFX.
    • Método start: Configura la interfaz gráfica, incluyendo etiquetas para la capa y las pistas, y un contenedor para los botones de los cables.
    • Método prepararCapa: Prepara cada capa, actualiza la interfaz y genera los cables y las pistas.
    • Métodos de Lógica: Incluyen numeroAleatorio, obtenerCable, obtenerCapa, generarBomba y generarPistas.
    • Verificación: Al hacer clic en un cable, se llama a verificarCable para comprobar si es el correcto.
    • Alertas: Se utilizan para mostrar mensajes al usuario, indicando si cortó el cable correcto o si la bomba explotó.

    Cómo Ejecutar el Programa

    1. Configura tu IDE para JavaFX:
      • Si usas IntelliJ IDEA:
        • Ve a File > Project Structure > Libraries y agrega la biblioteca de JavaFX.
        • En las configuraciones de ejecución, agrega las VM options:
          --module-path "ruta/a/javafx-sdk-XX/lib" --add-modules javafx.controls,javafx.fxml
          
    2. Copia el código y pégalo en una clase llamada BombDefusalGame.java.
    3. Ejecuta el programa desde tu IDE.

    Personalización Estética

    Puedes mejorar la estética de la interfaz personalizando los estilos CSS:

    • Cambiar colores de fondo:
      root.setStyle("-fx-background-color: #2c3e50;");
      labelCapa.setStyle("-fx-font-size: 24px; -fx-font-weight: bold; -fx-text-fill: white;");
      labelPista.setStyle("-fx-font-size: 16px; -fx-text-fill: white;");
      
    • Estilizar los botones:
      btnCable.setStyle("-fx-background-color: #e74c3c; -fx-text-fill: white; -fx-font-size: 14px;");
      btnCable.setOnMouseEntered(e -> btnCable.setStyle("-fx-background-color: #c0392b; -fx-text-fill: white; -fx-font-size: 14px;"));
      btnCable.setOnMouseExited(e -> btnCable.setStyle("-fx-background-color: #e74c3c; -fx-text-fill: white; -fx-font-size: 14px;"));
      

    Notas Adicionales

    • Validación de Ingresos: Como ahora estamos usando botones, no es necesario validar la entrada del usuario.
    • Modularización: El código está organizado en métodos para facilitar su lectura y mantenimiento.
    • Adaptación: Puedes adaptar el número de capas y cables modificando las constantes NUM_CAPAS y NUM_CABLES.

    Conclusión

    Con este código, hemos transformado tu juego de consola en una aplicación gráfica interactiva y estética usando JavaFX. Esto mejora la experiencia del usuario y hace el juego más atractivo. ¡Espero que esto te sea de ayuda!