Tablero.cpp

#include "Tablero.h"
#include <iostream>
#include <chrono>
#include <algorithm>

using namespace std;

Tablero::Tablero()
    : inicio(nullptr), filas(9), columnas(9),
      rng(static_cast<unsigned int>(chrono::high_resolution_clock::now().time_since_epoch().count()))
{
    crearTablero();
}

Tablero::~Tablero() {
    // borrar todos los nodos creados
    for (Nodo* n : allNodes) {
        delete n;
    }
    allNodes.clear();
    inicio = nullptr;
}

void Tablero::crearTablero() {
    // Crear nodos y guardar en allNodes, luego conectar punteros
    // Primero crear todos los nodos (filas x columnas)
    allNodes.reserve(filas * columnas);
    for (int i = 0; i < filas; ++i) {
        for (int j = 0; j < columnas; ++j) {
            Nodo* n = new Nodo();
            allNodes.push_back(n);
        }
    }

    // conectar
    auto idx = [&](int f, int c) { return f * columnas + c; };
    for (int i = 0; i < filas; ++i) {
        for (int j = 0; j < columnas; ++j) {
            Nodo* n = allNodes[idx(i,j)];
            // paredes externas
            if (i == 0 || i == filas-1 || j == 0 || j == columnas-1) {
                n->esPared = true;
                n->tipo = MURO;
                n->descubierto = true; // muro externo siempre visible
            } else {
                n->esPared = false;
                n->tipo = OCULTO;
                n->descubierto = false;
            }
            if (i > 0) n->arriba = allNodes[idx(i-1,j)];
            if (i < filas-1) n->abajo = allNodes[idx(i+1,j)];
            if (j > 0) n->izquierda = allNodes[idx(i,j-1)];
            if (j < columnas-1) n->derecha = allNodes[idx(i,j+1)];
        }
    }

    inicio = allNodes[0]; // (0,0)
}

Nodo* Tablero::obtenerNodo(int fila, int columna) const {
    if (fila < 0 || fila >= filas || columna < 0 || columna >= columnas) return nullptr;
    return allNodes[fila * columnas + columna];
}

bool Tablero::posicionOcupada(int f, int c) const {
    // fuera del área interna (bordes) -> ocupado
    if (f <= 0 || f >= filas-1 || c <= 0 || c >= columnas-1) return true;

    for (const auto& p : posicionesMuros) {
        if (p.first == f && p.second == c) return true;
    }
    for (const auto& p : posicionesTesoros) {
        if (p.first == f && p.second == c) return true;
    }
    return false;
}

void Tablero::inicializarJuego() {
    // resetea casillas internas (no paredes externas), limpia vectores auxiliares
    posicionesMuros.clear();
    posicionesTesoros.clear();

    for (int i = 1; i < filas-1; ++i) {
        for (int j = 1; j < columnas-1; ++j) {
            Nodo* n = obtenerNodo(i,j);
            n->tipo = OCULTO;
            n->tesoro = NINGUNO;
            n->descubierto = false;
            n->esPared = false;
        }
    }
}

void Tablero::colocarMuros(int cantidad) {
    posicionesMuros.clear();
    uniform_int_distribution<int> dist(1, filas-2);
    int colocados = 0;
    int maxIntentos = 1000;
    while (colocados < cantidad && maxIntentos-- > 0) {
        int f = dist(rng);
        int c = dist(rng);
        if (!posicionOcupada(f,c)) {
            Nodo* n = obtenerNodo(f,c);
            n->tipo = MURO;
            n->descubierto = false; // oculto hasta que se intente revelar
            posicionesMuros.emplace_back(f,c);
            ++colocados;
        }
    }
}

void Tablero::colocarTesoros(int cantidad) {
    posicionesTesoros.clear();
    uniform_int_distribution<int> dist(1, filas-2);
    int colocados = 0;
    int maxIntentos = 1000;
    uniform_int_distribution<int> tipoDist(0, 3); // 4 tipos
    while (colocados < cantidad && maxIntentos-- > 0) {
        int f = dist(rng);
        int c = dist(rng);
        if (!posicionOcupada(f,c)) {
            Nodo* n = obtenerNodo(f,c);
            n->tipo = TESORO;
            n->tesoro = static_cast<TipoTesoro>(tipoDist(rng));
            n->descubierto = false;
            posicionesTesoros.emplace_back(f,c);
            ++colocados;
        }
    }
}

void Tablero::mostrarTablero(int jugadorFila, int jugadorCol) const {
    cout << "\n   ";
    for (int j = 0; j < columnas; ++j) {
        cout << " " << j << " ";
    }
    cout << "\n";

    for (int i = 0; i < filas; ++i) {
        if (i < 10) cout << " ";
        cout << i << " ";
        for (int j = 0; j < columnas; ++j) {
            const Nodo* nodo = obtenerNodo(i,j);
            if (i == jugadorFila && j == jugadorCol) {
                cout << " P ";
            } else if (nodo->esPared) {
                cout << " # ";
            } else if (nodo->descubierto) {
                if (nodo->tipo == MURO) {
                    cout << " | ";
                } else if (nodo->tipo == TESORO) {
                    // tesoro descubierto: mostrar vacío al usuario (pero internamente es TESORO)
                    cout << " T ";
                } else {
                    cout << "   ";
                }
            } else {
                cout << " o ";
            }
        }
        cout << "\n";
    }
    cout << "\n";
}

void Tablero::revelarCasilla(int fila, int columna) {
    Nodo* n = obtenerNodo(fila, columna);
    if (n && !n->esPared) {
        n->descubierto = true;
        // si es muro interno y estaba oculto, sigue siendo MURO pero ahora visible
        // si es TESORO, se mantiene TESORO hasta que el jugador se mueva a la casilla
    }
}

void Tablero::ocultarTablero() {
    for (int i = 1; i < filas-1; ++i) {
        for (int j = 1; j < columnas-1; ++j) {
            Nodo* n = obtenerNodo(i,j);
            if (n->tipo != MURO && !n->esPared) {
                n->descubierto = false;
            }
        }
    }
}

int Tablero::contarMuros() const {
    return static_cast<int>(posicionesMuros.size());
}

void Tablero::eliminarMuroAleatorio() {
    if (posicionesMuros.empty()) return;
    uniform_int_distribution<int> dist(0, (int)posicionesMuros.size() - 1);
    int idx = dist(rng);
    auto pos = posicionesMuros[idx];
    Nodo* n = obtenerNodo(pos.first, pos.second);
    if (n) {
        n->tipo = VACIO;
        n->tesoro = NINGUNO;
        n->descubierto = false;
    }
    posicionesMuros.erase(posicionesMuros.begin() + idx);
}

pair<int,int> Tablero::obtenerPosicionAleatoria(bool evitarDescubiertos) {
    uniform_int_distribution<int> dist(1, filas-2);
    int intentos = 0;
    while (intentos++ < 200) {
        int f = dist(rng);
        int c = dist(rng);
        if (!posicionOcupada(f,c)) {
            Nodo* n = obtenerNodo(f,c);
            if (!evitarDescubiertos || !n->descubierto) {
                return {f,c};
            }
        }
    }
    // fallback: buscar secuencialmente
    for (int i = 1; i < filas-1; ++i) {
        for (int j = 1; j < columnas-1; ++j) {
            if (!posicionOcupada(i,j)) {
                Nodo* n = obtenerNodo(i,j);
                if (!evitarDescubiertos || !n->descubierto) {
                    return {i,j};
                }
            }
        }
    }
    return {1,1};
}

void Tablero::limpiarPosiciones() {
    posicionesMuros.clear();
    posicionesTesoros.clear();
}

void Tablero::eliminarTesoroEn(int fila, int columna) {
    posicionesTesoros.erase(
        remove_if(
            posicionesTesoros.begin(),
            posicionesTesoros.end(),
            [&](const std::pair<int,int>& p){
                return p.first == fila && p.second == columna;
            }
        ),
        posicionesTesoros.end()
    );
}