Juego de palabras: ¿implementación de tablero?

Estoy trabajando en un juego de tipo boggle para Android, usando libgdx. Al usuario se le presenta una cuadrícula de letras 4x4 y debe encontrar palabras arrastrando el dedo sobre las letras.

A diferencia de boggle, quiero que las letras usadas desaparezcan. Las letras restantes caerán (en la parte inferior del tablero, la orientación de la pantalla es fija) y el tablero se rellenará desde la parte superior. Los usuarios pueden rotar el tablero para tratar de poner letras difíciles de usar en un lugar mejor mediante la selección estratégica de palabras.

Un ejemplo:

d g a o
u o r T
h v R I
d G n a

Si seleccionara la palabra GRIT, esas letras desaparecerían y el resto se caería:

d
u g a
h o r o
d v n a

y luego ser reemplazado por nuevas letras

d w x y
u g a z
h o r o
d v n a

Estoy atrapado descubriendo cómo representar el tablero y las fichas.

Intenté representar el tablero como una matriz para hacer un seguimiento de los mosaicos seleccionados y los movimientos válidos y los mosaicos almacenados en una matriz también para que hubiera un mapeo fácil. Esto funciona, pero tuve que escribir un código complicado para rotar el tablero.

¿Cómo otros juegos manejan este problema?

EDITAR: Entonces, al pensarlo, realmente debería procesar mi punto de contacto de acuerdo con la rotación del tablero para que las celdas se mantengan constantes. Adjunto una imagen de lo que estoy pensando.

No usaría matrices para esto en absoluto porque administrarlo se volverá cada vez más complejo. Haga una estructura de datos de tablero personalizada con nodos que tengan referencias a sus vecinos. Esto es esencialmente una lista de nodos vinculada multidimensional. De esa manera, si se elimina la letra de un nodo, otros nodos pueden ver esto de forma encapsulada. Esto evita la aritmética de matriz complicada. Necesitará una gran función para conectar todo correctamente, pero una vez vinculada, la lógica debería ser mucho más fácil de trabajar.

Sus nodos de borde tendrán vecinos configurados en null, así que asegúrese de manejar eso en consecuencia en sus métodos en la clase Nodo que necesitan referirse a vecinos.

He utilizado este enfoque para implementar Game Of Life de Conway y una vez que lo configura, disminuye drásticamente la complejidad de agregar lógica que cambia el estado de un Nodo en función de los vecinos.

Dependiendo de cómo esté manipulando los nodos en el tablero, es posible que necesite un método de tablero para iterar y determinar el siguiente estado o acción y guardarlo dentro de cada nodo. Luego, siga iterando y confirmando cada nodo al nuevo estado. Esto evita que los nodos determinen su próximo estado al observar los nodos que ya han cambiado.

Sí, la solución es obtener el valor de su matriz o matriz y establecer ese valor para la matriz temporal o matriz y luego establecer el valor a partir de ahí, esto le mostrará su valor de rotación gird. Agregué el código a continuación, creo que te ayuda

    int MAX_GRID = 4;
    int[][] main_array = new int[MAX_GRID][MAX_GRID];
    int[][] temp_array = new int[MAX_GRID][MAX_GRID];

    /** This method for clockwise **/
    int mainRow = MAX_GRID - 1;
    for (int c = 0; c < MAX_GRID; c++) {
        for (int r = 0; r < MAX_GRID; r++) {
            temp_array [mainRow][c] = main_array [r][c];
            Log.i("TAG", "R C : [ " + mainRow + " " + c + " ]" + " => [ "
                    + r + " " + c + " ]");
            mainRow--;
        }
    }
    main_array = temp_array;

    /** This method for anti-clockwise **/
    int mainCol = 0;
    for (int c = MAX_GRID - 1; c >= 0; c--) {
        for (int r = MAX_GRID - 1; r >= 0; r--) {
            temp_array [r][mainCol] = main_array [c][r];
            Log.i("TAG", "R C : [ " + r + " " + mainCol + " ]" + " => [ "
                    + c + " " + r + " ]");
        }
        mainCol++;
    }
    main_array = temp_array;

    // Now you can set main_array value then its rotate