Juego.cpp

#include "Juego.h"
#include "Tablero.h"
#include <iostream>
#include <limits>
#include <cctype>

using namespace std;

Juego::Juego()
    : tablero(nullptr), jugador(nullptr),
      tesorosRestantes(10), juegoActivo(false)
{
}

Juego::~Juego() {
    delete tablero;
    delete jugador;
}

void Juego::limpiarPantalla() const {
    cout << "\033[2J\033[1;1H";  // Escape ANSI
}


void Juego::iniciar() {
    cout << "  BIENVENIDO AL JUEGO DE LABERINTOS  \n";
    menuPrincipal();
}

void Juego::menuPrincipal() {
    int opcion;
    do {
        cout << "\n===== MENU PRINCIPAL =====\n";
        cout << "1. Nueva Partida\n";
        cout << "2. Ver Ranking\n";
        cout << "3. Buscar Jugador\n";
        cout << "4. Salir\n";
        cout << "Seleccione una opcion: ";
        if (!(cin >> opcion)) {
            cin.clear();
            cin.ignore(numeric_limits<streamsize>::max(), '\n');
            opcion = 0;
        } else {
            cin.ignore(numeric_limits<streamsize>::max(), '\n');
        }

        switch(opcion) {
            case 1: nuevaPartida(); break;
            case 2: verRanking(); break;
            case 3: buscarJugador(); break;
            case 4: cout << "\n¡Gracias por jugar!\n"; break;
            default: cout << "Opcion invalida.\n";
        }
    } while(opcion != 4);
}

void Juego::nuevaPartida() {
    string nombre;
    cout << "\nIngrese su nombre: ";
    getline(cin, nombre);
    if (nombre.empty()) nombre = "Jugador";

    // limpiar estado previo
    delete tablero; tablero = nullptr;
    delete jugador; jugador = nullptr;

    tablero = new Tablero();
    jugador = new Jugador(nombre);
    tesoros.clear();
    tesorosRestantes = 10;
    juegoActivo = true;

    tablero->inicializarJuego();
    tablero->colocarMuros(16);
    tablero->colocarTesoros(10);

    // colocar jugador en posición aleatoria que no sea muro ni tesoro ni pared
    auto pos = tablero->obtenerPosicionAleatoria(true);
    jugador->fila = pos.first;
    jugador->columna = pos.second;
    jugador->puntaje = 0;

    cout << "\n Partida iniciada. Encuentra los 10 tesoros ocultos. \n";
    cout << "Controles: W (arriba), S (abajo), A (izquierda), D (derecha)\n";
    cout << "           T (ver tesoros), X (usar tesoro)\n\n";

    jugar();
}

void Juego::jugar() {
    char comando;

    while (juegoActivo && tesorosRestantes > 0) {
        mostrarEstadoJuego();

        cout << "Ingrese comando: ";
        if (!(cin >> comando)) {
            cin.clear();
            cin.ignore(numeric_limits<streamsize>::max(), '\n');
            continue;
        }
        comando = static_cast<char>(toupper(static_cast<unsigned char>(comando)));

        if (comando == 'W' || comando == 'S' || comando == 'A' || comando == 'D') {
            procesarMovimiento(comando);
        } else if (comando == 'T') {
            tesoros.mostrar();
        } else if (comando == 'X') {
            usarTesoro();
        } else {
            cout << "Comando invalido.\n";
        }
    }

    if (tesorosRestantes == 0) {
        limpiarPantalla();
        cout << "FELICIDADES! GANASTE EL JUEGO!\n";
        cout << "\nJugador: " << jugador->nombre << "\n";
        cout << "Puntaje final: " << jugador->puntaje << " puntos\n\n";

        scoreBoard.agregarPuntaje(jugador->nombre, jugador->puntaje);

        cout << "Desea jugar otra partida? (S/N): ";
        char resp;
        cin >> resp;
        cin.ignore(numeric_limits<streamsize>::max(), '\n');

        if (toupper(static_cast<unsigned char>(resp)) == 'S') {
            nuevaPartida();
        }
    }
}

void Juego::procesarMovimiento(char direccion) {
    int nuevaFila = jugador->fila;
    int nuevaCol = jugador->columna;
    switch (direccion) {
        case 'W': nuevaFila--; break;
        case 'S': nuevaFila++; break;
        case 'A': nuevaCol--; break;
        case 'D': nuevaCol++; break;
    }

    if (nuevaFila < 0 || nuevaFila >= tablero->getFilas() ||
        nuevaCol < 0 || nuevaCol >= tablero->getColumnas()) {
        cout << "No puedes salir del tablero!\n";
        return;
    }

    Nodo* nodoDestino = tablero->obtenerNodo(nuevaFila, nuevaCol);
    if (!nodoDestino) return;

    if (nodoDestino->esPared) {
        cout << "No puedes atravesar las paredes externas!\n";
        return;
    }

    // Si está oculto lo revelamos (y mostramos muros si corresponde)
    if (!nodoDestino->descubierto) {
        tablero->revelarCasilla(nuevaFila, nuevaCol);
    }

    if (nodoDestino->tipo == MURO) {
        cout << "Hay un muro! No puedes pasar por aqui.\n";
        return;
    }

    // Mover jugador
    jugador->fila = nuevaFila;
    jugador->columna = nuevaCol;
    jugador->puntaje++; // cada movimiento suma 1 punto

    if (nodoDestino->tipo == TESORO) {
        TesoroItem tesoro(nodoDestino->tesoro);
        tesoros.agregar(tesoro);
        cout << "\nHas encontrado un " << tesoro.obtenerNombre() << "!\n";
        cout << "Presiona ENTER para continuar...";
        cin.clear();
        cin.ignore(10000, '\n');
        cin.get();   // AHORA SÍ ESPERA
        nodoDestino->tipo = VACIO;
        nodoDestino->tesoro = NINGUNO;
        nodoDestino->descubierto = true;
        // quitar la posicion de tesoros de la lista auxiliar
        tablero->eliminarTesoroEn(nuevaFila, nuevaCol);
        tesorosRestantes--;
        cout << "Tesoros restantes: " << tesorosRestantes << "\n";
    }
}

void Juego::usarTesoro() {
    if (tesoros.estaVacia()) {
        cout << "\nNo tienes tesoros para usar.\n";
        return;
    }

    TesoroItem tesoro = tesoros.obtenerUltimo();
    cout << "\nUsando " << tesoro.obtenerNombre() << "\n";

    switch (tesoro.tipo) {
        case RUBI: aplicarEfectoRubi(); break;
        case DIAMANTE: aplicarEfectoDiamante(); break;
        case PERLA: aplicarEfectoPerla(); break;
        case AMBAR: aplicarEfectoAmbar(); break;
        default: break;
    }

    // recolocar exactamente UN tesoro (no todos) para mantener la cuenta
    tablero->colocarTesoros(1);
    tablero->ocultarTablero();
    tesorosRestantes++; // como se reubica el tesoro usado, aumenta la cuenta de restantes
    cout << "El tesoro ha sido reubicado en el laberinto.\n";
    cout << "El tablero ha sido cubierto nuevamente.\n";
}

void Juego::aplicarEfectoRubi() {
    int anterior = jugador->puntaje;
    jugador->puntaje /= 2;
    cout << "Tu puntaje se ha reducido a la mitad! ";
    cout << anterior << " → " << jugador->puntaje << "\n";
}

void Juego::aplicarEfectoDiamante() {
    int eliminados = 0;
    for (int i = 0; i < 2 && tablero->contarMuros() > 0; ++i) {
        tablero->eliminarMuroAleatorio();
        ++eliminados;
    }
    cout << "Se han eliminado " << eliminados << " muros del tablero\n";
}

void Juego::aplicarEfectoPerla() {
    int aleatorio = rand() % 2;
    int anterior = jugador->puntaje;
    if (aleatorio == 0) {
        jugador->puntaje = 0;
        cout << " Tu puntaje se ha reducido a cero ";
        cout << anterior << " → 0\n";
    } else {
        jugador->puntaje *= 2;
        cout << "Tu puntaje se ha multiplicado por 2! ";
        cout << anterior << " → " << jugador->puntaje << "\n";
    }
}

void Juego::aplicarEfectoAmbar() {
    auto pos = tablero->obtenerPosicionAleatoria(true);
    jugador->fila = pos.first;
    jugador->columna = pos.second;
    cout << "Has sido teletransportado a otra parte del laberinto\n";
}

void Juego::mostrarEstadoJuego() const {
    limpiarPantalla();
    cout << "JUEGO DE LABERINTOS\n";
    cout << "Jugador: " << jugador->nombre << "\n";
    cout << "Puntaje: " << jugador->puntaje << " | ";
    cout << "Tesoros recolectados: " << (10 - tesorosRestantes) << "/10\n";

    tablero->mostrarTablero(jugador->fila, jugador->columna);

    cout << "Leyenda: P=Jugador, #=Pared, |=Muro, o=Oculto, T=Tesoro (si descubierto),    =Vacio\n";
}

void Juego::verRanking() {
    limpiarPantalla();
    scoreBoard.mostrarRanking();
}

void Juego::buscarJugador() {
    string nombre;
    cout << "\nIngrese el nombre del jugador a buscar: ";
    getline(cin, nombre);
    if (nombre.empty()) {
        cout << "Nombre vacio.\n";
        return;
    }
    int puntaje = scoreBoard.buscarJugador(nombre);
    if (puntaje != -1) {
        cout << "\n" << nombre << " ha jugado antes.\n";
        cout << "Mejor puntaje: " << puntaje << " puntos\n\n";
    } else {
        cout << "\n" << nombre << " no ha jugado antes.\n\n";
    }
}