seleccionar celdas del tablero

[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!!

[navbuoy]

Mira Neftali, joe estuvo ampliando cosas del interface de botones con mas cosas que tendra el juego
Tambien he optimizado el juego (porque utilizando TTable que carga todo en memoria, cargaba 18.000 registros del tablero total de celdas (que cazurro llega a ser uno eh?), menos mal que me di cuenta que con un TQuery todo queda mucho mas optimizado a nivel de consultas de X registros y ya)

como ves ahi, la policia nos atosiga igual que en la vida real, no es fantastico este juego??

[navbuoy]

Mirad Casimiro y Neftali

[navbuoy]