🐺 LoboGAME - Guía Paso a Paso

📋 Resumen del Proyecto

Un juego de rol social donde:

• Un jugador es el LOBO (infiltrado, mata de noche)
• El resto son ALDEANOS (intentan votar al lobo durante el día)
• El lobo tiene que disimular y mentir
• Los aldeanos tienen que deducir quién es el lobo
• Turnos alternos: NOCHE (lobo mata) → DÍA (aldeanos votan)

---

🎯 Objetivo de Aprendizaje

Este proyecto integra:

• Enum: Roles (LOBO, ALDEANO)
• ArrayList: Gestión de jugadores
• Estados: Fases del juego (NOCHE, DÍA, FIN)
• Secretos: El lobo sabe su identidad, otros no
• Votaciones: Lógica de eliminación
• Random: Asignar roles y elegir muertes
• Menú interactivo: Acciones por turno

---

🏗️ Estructura de Clases

Rol (Enum)
├─ LOBO
└─ ALDEANO

Jugador
├─ nombre (String)
├─ rol (Rol)
├─ vivo (boolean)
└─ métodos: getRol(), getInfo(), morir()

Juego
├─ jugadores: ArrayList<Jugador>
├─ turnoActual: int
├─ fase: String (NOCHE/DÍA/FIN)
└─ métodos:
   ├─ asignarRoles()
   ├─ turnoNoche()
   ├─ turnoDía()
   ├─ votarJugador()
   ├─ verificarGanador()
   └─ mostrarJugadores()

Main
└─ menú: setup, turnos, acciones

---

🔄 Pasos para Resolver

Paso 1: Enum Rol

Crea un enum con 2 valores:

public enum Rol {
    LOBO,
    ALDEANO
}

Muy simple, pero fundamental para diferenciar tipos.

---

Paso 2: Clase Jugador

Atributos:

• nombre (String)
• rol (Rol)
• vivo (boolean) - inicialmente true

Métodos:

• getRol() → retorna rol
• getNombre() → retorna nombre
• isVivo() → retorna vivo
• morir() → pone vivo = false
• getInfo() → retorna "Nombre (VIVO/MUERTO)" sin mostrar rol si está vivo
  • Ejemplo: "Juan (vivo)" si está vivo
  • Ejemplo: "María (muerta) - era ALDEANO" si está muerta

---

Paso 3: Clase Juego - Inicialización

Atributos:

• jugadores (ArrayList)
• turnoActual (int) - comienza en 1
• fase (String) - "NOCHE", "DÍA", "FIN"
• random (Random)
• lobo (Jugador) - referencia al lobo

Constructor:

• Inicializa ArrayList vacío
• turnoActual = 1
• fase = "NOCHE"

Método agregarJugador(String nombre):

• Crea Jugador y agrega a ArrayList
• Imprime "✅ Jugador {nombre} unido"

---

Paso 4: Asignar Roles Aleatoriamente

Método asignarRoles():

Lógica:

1. Valida que haya al menos 3 jugadores
2. Elige índice aleatorio para el lobo: random.nextInt(jugadores.size())
3. Asigna ese jugador como LOBO, resto como ALDEANO
4. Guarda referencia en this.lobo

public void asignarRoles() {
    if (jugadores.size() < 3) {
        System.out.println("❌ Se necesitan al menos 3 jugadores");
        return;
    }

    int indiceLoboPredeterminado = random.nextInt(jugadores.size());
    for (int i = 0; i < jugadores.size(); i++) {
        if (i == indiceLoboPredeterminado) {
            jugadores.get(i).asignarRol(Rol.LOBO);
            this.lobo = jugadores.get(i);
        } else {
            jugadores.get(i).asignarRol(Rol.ALDEANO);
        }
    }
    System.out.println("✅ Roles asignados secretamente");
}

---

Paso 5: Turno NOCHE

Método turnoNoche():

1. Imprime "🌙 === TURNO " + turnoActual + " - NOCHE ==="
2. Imprime "🐺 El lobo despierta en secreto..."
3. Solo el lobo ve esto:
   • Muestra lista de aldeanos vivos (sin números, solo nombres)
   • Pide: "¿A quién quieres matar? (nombre completo)"
4. Busca el jugador elegido:
   • Si no existe o ya está muerto: aviso
   • Si es el lobo mismo: no puede
   • Si existe y es aldeano vivo: lo mata
5. Llama lobo.matar(nombre)
6. Avanza a turno DÍA

---

Paso 6: Turno DÍA

Método turnoDía():

1. Imprime "☀️ === TURNO " + turnoActual + " - DÍA ==="
2. Revela la muerte:
   • Si hay muerto: "💀 {nombre} fue asesinado por la noche. Era {rol}"
   • Si no: "🙏 La aldea despierta en paz"
3. Muestra vivos (para toda la aldea): mostrarJugadoresVivos()
4. Debate y votación:
   • Cada jugador vivo vota por alguien (incluido el lobo)
   • Imprime: "{nombre} vota por: {votado}"
5. Cuenta votos y expulsa al más votado:
   • Si hay empate: expulsa al primero del empate
   • Revela su rol: "{expulsado} era {rol}"

---

Paso 7: Método votarJugador()

public void votarJugador(Scanner scanner) {
    for (int i = 0; i < jugadores.size(); i++) {
        Jugador j = jugadores.get(i);
        if (!j.isVivo()) continue;

        System.out.print(j.getNombre() + ", ¿a quién votas? ");
        String votado = scanner.nextLine();

        // Busca al votado
        for (Jugador jVotado : jugadores) {
            if (jVotado.getNombre().equalsIgnoreCase(votado) && jVotado.isVivo()) {
                // Cuenta voto
                // ...
                break;
            }
        }
    }
}

---

Paso 8: Verificar Ganador

Método verificarGanador() retorna String:

Condiciones:

1. Ganan Aldeanos: No hay lobos vivos
   • Retorna: "ALDEANOS"
2. Ganan Lobos: Lobos ≥ Aldeanos vivos
   • Retorna: "LOBOS"
3. Sigue el juego: Retorna null

---

Paso 9: Mostrar Estado

Método mostrarJugadoresVivos():

• Imprime: "👥 Jugadores vivos:"
• Lista cada uno: "{nombre}"
• Sin revelar rol

Método mostrarTodosConRoles() (para final):

• Imprime todos: "{nombre} - {rol}"

---

Paso 10: Main - Menú

Menú principal:

🐺 === LoboGAME ===
1. Crear jugadores
2. Ver jugadores
3. Iniciar juego
4. Salir

Cuando Iniciar juego:

1. Llama asignarRoles()
2. Loop de turnos:

   Mientras fase != "FIN":
   - turnoNoche()
   - verificarGanador() → si gana alguien, fase = "FIN"
   - turnosDía()
   - verificarGanador() → si gana alguien, fase = "FIN"
   - turnoActual++
   

3. Muestra ganador y todos los roles

---

🎮 Ejemplo de Flujo

🐺 === LoboGAME ===
1. Crear jugadores
...
Elige: 1

Nombre: Juan
✅ Jugador Juan unido

Nombre: María
✅ Jugador María unido

Nombre: Pedro
✅ Jugador Pedro unido

Elige: 3

✅ Roles asignados secretamente

🌙 === TURNO 1 - NOCHE ===
🐺 El lobo despierta...
[Solo el lobo ve:] Eres el LOBO
Aldeanos disponibles: María, Pedro
¿A quién quieres matar? María

☀️ === TURNO 1 - DÍA ===
💀 María fue asesinada. Era ALDEANO

👥 Jugadores vivos: Juan, Pedro
Juan, ¿a quién votas? Pedro
Pedro, ¿a quién votas? Juan

📊 Votos: Juan=1, Pedro=1 (empate)
❌ Pedro fue expulsado. Era LOBO

🎉 ¡¡¡ALDEANOS GANAN!!!

Resultados finales:
- Juan: ALDEANO ✅
- María: ALDEANO (asesinado)
- Pedro: LOBO (expulsado)

---

📌 Notas Importantes

• Secreto: El lobo sabe su rol, los aldeanos no
• Al morir: Se revela el rol de quien muere
• Enum: Usa Rol.LOBO y Rol.ALDEANO
• CaseSensitive: Los nombres sí importan (usa .equalsIgnoreCase())
• Validación: No puedes votar por muertos ni por ti mismo (opcional)

---

✨ Conceptos Clave

Concepto	Dónde	Por qué
Enum	Rol	Valores fijos (LOBO/ALDEANO)
ArrayList	jugadores	Lista dinámica
Random	asignarRoles()	Elegir lobo aleatoriamente
Boolean	vivo	Estado de jugador
Scanner	Menú, votaciones	Input del usuario
Bucles	Turnos, votaciones	Repetir acciones
Condicionales	Verificar ganador	Lógica de victoria

---

¡Ahora abre los archivos en PLANTILLAS/ y resuelve! 🐺