Jogo de palavras - implementação de tabuleiro?

Estou trabalhando em um jogo do tipo boggle para android, usando libgdx. O usuário é apresentado com uma grade de letras 4x4 e deve encontrar palavras arrastando o dedo sobre as letras.

Ao contrário do boggle, quero que as letras usadas desapareçam. As letras restantes caem (na parte inferior do quadro, a orientação da tela é fixa) e o quadro é reabastecido pela parte superior. Os usuários podem girar o quadro para tentar colocar as letras difíceis de usar em um lugar melhor com a seleção estratégica de palavras.

Um exemplo:

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

Se eu selecionasse a palavra GRIT, essas letras desapareceriam e as restantes cairiam:

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

e depois ser substituído por novas letras

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

Estou preso tentando descobrir como representar o tabuleiro e os ladrilhos.

Tentei representar o quadro como uma matriz para acompanhar os ladrilhos selecionados e os movimentos válidos e os ladrilhos armazenados em uma matriz, para que houvesse um mapeamento fácil. Isso funciona, mas eu tive que escrever um código complicado para girar o quadro.

Como outros jogos lidam com esse problema?

EDIT: Então, pensando bem, eu realmente deveria apenas processar meu ponto de contato de acordo com a rotação do painel para que as células permaneçam constantes. Anexou uma imagem do que estou pensando.

Eu não usaria matrizes para isso, pois o gerenciamento será cada vez mais complexo. Crie uma estrutura de dados personalizada da placa com nós que tenham referências a seus vizinhos. Este é essencialmente um LinkedList multidimensional de nós. Dessa forma, se a letra de um nó for removida, outros nós poderão visualizar isso de forma encapsulada. Isso evita aritmética de matriz complicada. Você precisará de uma grande função para conectar tudo corretamente, mas uma vez vinculada, a lógica deve ser muito mais fácil de trabalhar.

Seus nós de borda terão vizinhos definidos como null, portanto, lembre-se de lidar com isso de acordo com seus métodos na classe Node que precisam se referir a vizinhos.

Eu usei essa abordagem para implementar o Game Of Life de Conway e, depois de configurada, diminui drasticamente a complexidade de adicionar lógica que altera o estado de um nó com base nos vizinhos.

Dependendo de como você está manipulando os nós no quadro, pode ser necessário um método para iterar e determinar o próximo estado ou ação e salvá-lo em cada nó. Em seguida, itere-o e confirme cada nó no novo estado. Isso evita que os nós determinem seu próximo estado observando os nós que já foram alterados.

Sim, a solução é obter valor de sua matriz ou matriz e definir esse valor para matriz ou matriz temporária e, em seguida, definir valor a partir daí, isso mostra o seu valor de rotação. Eu adicionei o código abaixo, acho que ajuda você

    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