Juegos VI: The Marconix Codebreaker (Juego de Posiciones)

The Marconix Codebreaker

Descripción del juego:
Este es un juego de ordenamiento en el que el jugador debe organizar una serie de casillas, cada una representada por una letra (A-F), en el orden correcto. Cada letra tiene asociado un número oculto (1-6) y el objetivo es ordenar las letras de manera que sus números asociados estén en orden ascendente.

Reglas del juego:
El juego comienza con 6 casillas (A-F) en orden alfabético y cada letra tiene un número oculto (1-6) asignado aleatoriamente.
El jugador tiene una puntuación inicial de 1000 puntos.
En cada turno, el jugador puede:
  . Pedir una pista (cuesta 50 puntos)
  . Reorganizar las casillas (cuesta 100 puntos)
  . Intentar salir del juego
Las pistas proporcionan información sobre el orden relativo de tres letras.
Al reorganizar, el jugador debe ingresar un nuevo orden para todas las letras.
Después de cada acción, el juego verifica si las casillas están en el orden correcto.
El juego termina cuando:
  .El jugador ordena correctamente las casillas (victoria)
  .El jugador decide salir del juego
La puntuación final se basa en los puntos restantes después de restar el costo de las pistas y reorganizaciones utilizadas.


Estructura jerárquica

Marconix
├── Variables estáticas
│   ├── NUM_CASILLAS
│   ├── letras
│   ├── numeros
│   ├── letraANumero
│   ├── pistasUsadas
│   └── puntuacion
│
├── main()
│   ├── inicializarJuego()
│   └── jugar()
│
├── inicializarJuego()
│
├── jugar()
│   ├── mostrarCasillas()
│   ├── darPista()
│   │   └── generarPistaCompleja()
│   ├── reorganizarCasillas()
│   │   └── darFeedback()
│   └── estaOrdenado()
│
├── mostrarCasillas()
│
├── darPista()
│   └── generarPistaCompleja()
│
├── generarPistaCompleja()
│
├── reorganizarCasillas()
│   └── darFeedback()
│
├── darFeedback()
│
└── estaOrdenado()


Diagrama de funcionamiento

┌─► Inicio
├─► Inicializar juego
├◄───────────────────────────────────────────────────────┐
├─► Mostrar casillas actuales                            │
├─► Mostrar puntuación                                   │
└─► Preguntar por pista                                  │
    ├─► Sí                                               │
    │   └─► Dar pista                                    │
    │       Restar 50 puntos ───────────────────────────►┤
    └─► No                                               │
        └─► Preguntar por reorganizar                    │
            ├─► Sí                                       │
            │   └─► Reorganizar casillas                 │
            │       Restar 100 puntos ──────────────────►┤
            └─► No                                       │
                └─► Preguntar por salir                  │
                    ├─► Sí                               │
                    │   └─► Terminar juego*              │
                    └─► No                               │
                        └─► Verificar si está ordenado   │
                            ├─► Sí                       │
                            │   └─► Mostrar victoria     │
                            │       Terminar juego*      │
                            └─► No ─────────────────────►┘



Código Java (Marconix.java):

package Marconix;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

public class Marconix {

    private static final int NUM_CASILLAS = 6;
    private static final List<Character> letras = new ArrayList<>();
    private static final List<Integer> numeros = new ArrayList<>();
    private static final Map<Character, Integer> letraANumero = new HashMap<>();
    private static final Set<String> pistasUsadas = new HashSet<>();
    private static int puntuacion = 1000;

    public static void main(String[] args) {
        inicializarJuego();
        jugar();
    }

    private static void inicializarJuego() {
        for (char c = 'A'; c < 'A' + NUM_CASILLAS; c++) {
            letras.add(c);
        }
        for (int i = 1; i <= NUM_CASILLAS; i++) {
            numeros.add(i);
        }
        Collections.shuffle(numeros);
        for (int i = 0; i < NUM_CASILLAS; i++) {
            letraANumero.put(letras.get(i), numeros.get(i));
        }
    }

    private static void jugar() {
        try (Scanner scanner = new Scanner(System.in)) {
            while (true) {
                mostrarCasillas();
                System.out.println("Puntuación actual: " + puntuacion);
                System.out.println("¿Quieres una pista? (s/n)");
                String respuesta = scanner.nextLine().toLowerCase();
                if (respuesta.equals("s")) {
                    darPista();
                    puntuacion -= 50;
                } else if (respuesta.equals("n")) {
                    System.out.println("¿Quieres reorganizar las casillas? (s/n)");
                    respuesta = scanner.nextLine().toLowerCase();
                    if (respuesta.equals("s")) {
                        reorganizarCasillas(scanner);
                        puntuacion -= 100;
                    } else if (respuesta.equals("n")) {
                        System.out.println("¿Quieres salir del juego? (s/n)");
                        if (scanner.nextLine().toLowerCase().equals("s")) {
                            break;
                        }
                    }
                }
                if (estaOrdenado()) {
                    System.out.println("¡Felicidades! Has ordenado correctamente las casillas.");
                    System.out.println("Puntuación final: " + puntuacion);
                    break;
                }
            }
        }
    }

    private static void mostrarCasillas() {
        System.out.println("Orden actual de las casillas:");
        letras.forEach(letra -> System.out.print(letra + " "));
        System.out.println();
    }

    private static void darPista() {
        String pista;
        do {
            pista = generarPistaCompleja();
        } while (pistasUsadas.contains(pista));
        pistasUsadas.add(pista);
        System.out.println("Pista: " + pista);
    }

    private static String generarPistaCompleja() {
        List<Character> letrasAleatorias = new ArrayList<>(letras);
        Collections.shuffle(letrasAleatorias);
        char letra1 = letrasAleatorias.get(0);
        char letra2 = letrasAleatorias.get(1);
        char letra3 = letrasAleatorias.get(2);
        int num1 = letraANumero.get(letra1);
        int num2 = letraANumero.get(letra2);
        int num3 = letraANumero.get(letra3);

        if (num1 < num2 && num2 < num3) {
            return letra1 + " < " + letra2 + " < " + letra3;
        } else if (num1 < num2 && num2 > num3 && num1 < num3) {
            return letra1 + " < " + letra3 + " < " + letra2;
        } else if (num2 < num1 && num1 < num3) {
            return letra2 + " < " + letra1 + " < " + letra3;
        } else if (num2 < num3 && num3 < num1) {
            return letra2 + " < " + letra3 + " < " + letra1;
        } else if (num3 < num1 && num1 < num2) {
            return letra3 + " < " + letra1 + " < " + letra2;
        } else {
            return letra3 + " < " + letra2 + " < " + letra1;
        }
    }

    private static void reorganizarCasillas(Scanner scanner) {
        System.out.println("Ingresa el nuevo orden de las letras (sin espacios):");
        String nuevoOrden = scanner.nextLine().toUpperCase();
        if (nuevoOrden.length() == NUM_CASILLAS && nuevoOrden.chars().distinct().count() == NUM_CASILLAS) {
            letras.clear();
            for (char c : nuevoOrden.toCharArray()) {
                letras.add(c);
            }
            darFeedback();
        } else {
            System.out.println("Orden inválido. Asegúrate de incluir todas las letras una vez.");
        }
    }

    private static void darFeedback() {
        int posicionesCorrectas = 0;
        for (int i = 0; i < NUM_CASILLAS; i++) {
            if (letraANumero.get(letras.get(i)) == i + 1) {
                posicionesCorrectas++;
            }
        }
        System.out.println("Tienes " + posicionesCorrectas + " letra(s) en la posición correcta.");
    }

    private static boolean estaOrdenado() {
        for (int i = 1; i < NUM_CASILLAS; i++) {
            if (letraANumero.get(letras.get(i - 1)) > letraANumero.get(letras.get(i))) {
                return false;
            }
        }
        return true;
    }
}


Resultado:

run:
Orden actual de las casillas:
A B C D E F
Puntuación actual: 1000
¿Quieres una pista? (s/n)
s
Pista: D < F < A
Orden actual de las casillas:
A B C D E F
Puntuación actual: 950
¿Quieres una pista? (s/n)
n
¿Quieres reorganizar las casillas? (s/n)
s
Ingresa el nuevo orden de las letras (sin espacios):
BCDEFA
Tienes 3 letra(s) en la posición correcta.
Orden actual de las casillas:
B C D E F A
Puntuación actual: 850
¿Quieres una pista? (s/n)
n
¿Quieres reorganizar las casillas? (s/n)
n
¿Quieres salir del juego? (s/n)
s
BUILD SUCCESSFUL (total time: 2 minutes 11 seconds)