seleccionar celdas del tablero

[navbuoy]

Hola Neftali Casimiro y compañia

esta vez es algo sencillo (creo) pero que a mi me marea bastante jajaja

recordais el TABLERO del juego no?? de 11 x 12 filas y columnas (empezando desde la posicion 0,0 X-Y)

bien, lo que me gustaria hacer de forma rapida, es calcular en base a un numero de puntos de una tirada de dado (numero entero del 1 al 16) las posiciones en dicho tablero de las celdas accesibles mediante dicha puntuacion para iluminarlas de forma suave para indicar el RANGO de donde puede moverse partiendo de donde tiene la nave posicionada en celda tal y cual

yo no acabo de verlo muy claro aunque si me pongo lo hare pero quizas vosotros tengais la mente mas despierta para elaborar alguna clase de codigo que lo haga bien y sin formar mucho lio

solo necesito que haga el calculo de que celdas son las posibles "alcanzables" que podria "mover la ficha" en base a los puntos del dado (lo de iluminarlas ya lo hago yo, eso no problem)

un Saludo

[Neftali [Germán.Estévez]]

Por lo que recuerdo de clase (que a esta alturas es poco ) hay varias estrategias para resolverlo.
Una de las más fáciles de implementar es "Prueba y error".

Se trata de evaluar todas las posibilidades e ir descartando las que no son correctas. En tu caso recorrer todas las celdas del tablero, e ir descartando las que no son accesibles o no están a accesibles con tu tirada.

Te queda generar una función que te devuelva la distancia entre 2 celdas del tablero.

[navbuoy]

le he preguntado a ChatGPT:

Para resolver este problema, puedes crear una función que reciba una posición inicial y un número de puntos de movimiento, y que calcule todas las posiciones de las celdas a las que puedes moverte en un tablero de 11 x 12 celdas.

Para simplificar, consideremos que:

La ficha puede moverse en cuatro direcciones: arriba, abajo, izquierda y derecha.
Los movimientos están limitados por el tamaño del tablero y por los puntos de movimiento disponibles.
Una posible estrategia es usar una búsqueda en anchura (BFS, por sus siglas en inglés), que te permitirá explorar todas las celdas alcanzables en función de los puntos de movimiento.

Pasos:
Entrada:

La posición inicial de la ficha (fila, columna).
Los puntos de movimiento disponibles.

Proceso:

Utiliza una cola para ir guardando las posiciones a las que te puedes mover.
Desde cada posición, intenta moverte a las cuatro direcciones posibles.
Resta un punto de movimiento cada vez que te muevas a una nueva celda.
Evita moverte fuera del tablero o visitar la misma celda más de una vez.

Salida:

Un conjunto de posiciones a las que te puedes mover.

Utilizaremos un enfoque basado en BFS (búsqueda en anchura) con una cola y un conjunto para almacenar las celdas visitadas. A continuación te presento un ejemplo de cómo podrías implementarlo.

#include <vcl.h>
#include <queue>
#include <set>
#include <utility>  // Para std::pair
#include <vector>
#pragma hdrstop
#pragma argsused

// Definir las dimensiones del tablero
const int FILAS = 11;
const int COLUMNAS = 12;

// Función para obtener las posiciones alcanzables
std::set<std::pair<int, int>> movimientos_posibles(std::pair<int, int> inicio, int puntos_movimiento) {
    // Direcciones de movimiento: arriba, abajo, izquierda, derecha
    std::vector<std::pair<int, int>> direcciones = { {-1, 0}, {1, 0}, {0, -1}, {0, 1} };
    
    // Set para almacenar las posiciones alcanzables
    std::set<std::pair<int, int>> visitadas;
    // Cola para BFS (posición actual y puntos de movimiento restantes)
    std::queue<std::pair<std::pair<int, int>, int>> cola;
    
    // Agregar la posición inicial
    cola.push({inicio, puntos_movimiento});
    visitadas.insert(inicio);
    
    while (!cola.empty()) {
        // Obtener el frente de la cola
        auto actual = cola.front();
        cola.pop();
        int fila_actual = actual.first.first;
        int col_actual = actual.first.second;
        int movimientos_restantes = actual.second;
        
        if (movimientos_restantes > 0) {
            // Explorar las 4 direcciones
            for (auto direccion : direcciones) {
                int nueva_fila = fila_actual + direccion.first;
                int nueva_columna = col_actual + direccion.second;
                
                // Verificar si la nueva posición está dentro del tablero
                if (nueva_fila >= 0 && nueva_fila < FILAS && nueva_columna >= 0 && nueva_columna < COLUMNAS) {
                    std::pair<int, int> nueva_posicion = {nueva_fila, nueva_columna};
                    // Si la posición no ha sido visitada
                    if (visitadas.find(nueva_posicion) == visitadas.end()) {
                        // Agregar la nueva posición
                        visitadas.insert(nueva_posicion);
                        // Agregar la nueva posición a la cola con los movimientos restantes
                        cola.push({nueva_posicion, movimientos_restantes - 1});
                    }
                }
            }
        }
    }
    
    return visitadas;
}

int main() {
    // Posición inicial en la celda (5, 5)
    std::pair<int, int> inicio = {5, 5};
    int puntos_movimiento = 3;  // Número de puntos de movimiento

    // Obtener las celdas alcanzables
    std::set<std::pair<int, int>> celdas_alcanzables = movimientos_posibles(inicio, puntos_movimiento);

    // Imprimir las posiciones alcanzables
    for (auto posicion : celdas_alcanzables) {
        printf("(%d, %d)\n", posicion.first, posicion.second);
    }

    return 0;
}

creo que por ahi ya puedo ir desarrollandolo

me he puesto este disco para animarme con el codigo jaja



https://www.youtube.com/watch?v=0YG2...45yRnZ8mA1RE93

[navbuoy]

ya hemos hecho una pantalla de Login decente, menos mal

[Neftali [Germán.Estévez]]

Empezado por navbuoy

ya hemos hecho una pantalla de Login decente, menos mal

Está chula!!