Gra słowna - realizacja planszy?

Pracuję nad grą typu Boggle na Androida, używając libgdx. Użytkownik ma siatkę liter 4x4 i musi znaleźć słowa, przeciągając palcem po literach.

W przeciwieństwie do boggle chcę, aby używane litery zniknęły. Pozostałe litery spadną na dół (na dole planszy orientacja ekranu jest ustalona), a plansza zostanie uzupełniona od góry. Użytkownicy mogą obracać tablicę, próbując umieścić trudne w użyciu litery w lepszym miejscu poprzez strategiczny wybór słów.

Przykład:

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

Gdybym wybrał słowo GRIT, litery te zniknęłyby, a pozostałe spadły:

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

a następnie zostaną zastąpione nowymi literami

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

Utknąłem, zastanawiając się, jak przedstawić planszę i płytki.

Próbowałem przedstawić planszę jako matrycę, aby śledzić wybrane kafelki i prawidłowe ruchy, a także kafelki przechowywane w macierzy, aby było łatwe mapowanie. To działa, ale musiałem napisać skomplikowany kod, aby obrócić płytę.

Jak inne gry radzą sobie z tym problemem?

EDYCJA: Więc myśląc o tym, naprawdę powinienem po prostu przetworzyć mój punkt styku zgodnie z obrotem płytki, aby komórki pozostały stałe. Załączam obraz tego, co myślę.

W ogóle nie używałbym do tego tablic, ponieważ zarządzanie nim będzie coraz bardziej skomplikowane. Utwórz niestandardową strukturę danych tablicy z węzłami, które mają odniesienia do swoich sąsiadów. Jest to zasadniczo wielowymiarowa LinkedList z węzłów. W ten sposób, jeśli litera węzła zostanie usunięta, inne węzły mogą wyświetlić to w sposób enkapsulowany. Pozwala to uniknąć skomplikowanej arytmetyki tablic. Będziesz potrzebował jednej dużej funkcji, aby wszystko połączyć poprawnie, ale po połączeniu logika powinna być znacznie łatwiejsza w obsłudze.

Twoje węzły brzegowe będą miały ustawione na sąsiadów null, więc upewnij się, że odpowiednio sobie z tym radzisz w swoich metodach w klasie Node, które muszą odnosić się do sąsiadów.

Zastosowałem to podejście do implementacji Game of Life Conwaya, a kiedy już ją skonfigurujesz, drastycznie zmniejsza złożoność dodawania logiki, która zmienia stan Węzła w oparciu o sąsiadów.

W zależności od tego, w jaki sposób manipulujesz węzłami na tablicy, może być potrzebna jedna metoda na tablicy do iteracji i określenia następnego stanu lub akcji i zapisania tego w każdym węźle. Następnie wykonaj to, iterując i zatwierdzając każdy węzeł do nowego stanu. Dzięki temu węzły nie określają następnego stanu, patrząc na węzły, które już się zmieniły.

Tak, rozwiązaniem jest uzyskanie wartości z macierzy lub macierzy i ustawienie tej wartości dla macierzy lub macierzy temperatury, a następnie ustawienie wartości stamtąd pokazuje ci wartość obrotu. Dodałem kod poniżej i myślę, że ci to pomoże

    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