Gioco di parole - implementazione del tabellone?

Sto lavorando a un gioco di tipo boggle per Android, usando libgdx. All'utente viene presentata una griglia di lettere 4x4 e deve trovare le parole trascinando il dito sulle lettere.

A differenza di Boggle, voglio che le lettere usate scompaiano. Le lettere rimanenti cadranno (nella parte inferiore della scheda, l'orientamento dello schermo è fisso) e la scheda viene riempita dall'alto. Gli utenti possono ruotare la lavagna per cercare di mettere le lettere difficili da usare in un posto migliore grazie alla selezione strategica delle parole.

Un esempio:

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

Se avessi selezionato la parola GRIT, quelle lettere sarebbero scomparse e le rimanenti sarebbero cadute:

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

e quindi essere sostituito da nuove lettere

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

Sono bloccato a capire come rappresentare la tavola e le tessere.

Ho provato a rappresentare la tavola come una matrice per tenere traccia delle tessere selezionate e delle mosse valide e anche delle tessere memorizzate in una matrice in modo che ci fosse una facile mappatura. Funziona, ma ho dovuto scrivere del codice contorto per ruotare la scheda.

In che modo altri giochi gestiscono questo problema?

EDIT: Quindi, a pensarci bene, dovrei semplicemente elaborare il mio punto di contatto in base alla rotazione della scheda in modo che le celle rimangano costanti. In allegato un'immagine di ciò che sto pensando.

Non userei affatto array per questo perché la sua gestione diventerà sempre più complessa. Crea una struttura di dati Board personalizzata con nodi che hanno riferimenti ai loro vicini. Questa è essenzialmente una LinkedList multidimensionale di nodi. In tal modo, se la lettera di un nodo viene rimossa, altri nodi possono visualizzarla in modo incapsulato. Questo evita la complessa aritmetica dell'array. Avrai bisogno di una grande funzione per connettere tutto correttamente, ma una volta collegata la logica dovrebbe essere molto più facile con cui lavorare.

I nodi perimetrali avranno vicini impostati null, quindi assicurati di gestirli di conseguenza nei tuoi metodi nella classe Nodo che devono fare riferimento ai vicini.

Ho usato questo approccio per implementare il Game Of Life di Conway e, una volta impostato, riduce drasticamente la complessità dell'aggiunta della logica che modifica lo stato di un nodo in base ai vicini.

A seconda di come si stanno manipolando i nodi nella scheda, potrebbe essere necessario un metodo della scheda per scorrere e determinare lo stato o l'azione successivi e salvarli all'interno di ciascun nodo. Quindi segui iterando e impegnando ciascun nodo nel nuovo stato. Ciò evita che i nodi determinino il loro stato successivo osservando i nodi che sono già stati modificati.

Sì, la soluzione è ottenere il valore dalla tua matrice o matrice e impostare quel valore per matrice o matrice temporanea e quindi impostare il valore da lì questo ti mostra il tuo valore di rotazione gird. Ho aggiunto il codice qui sotto, penso che ti aiuti

    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