Игра в слова - настольная реализация?

Я работаю над игрой типа boggle для Android, используя libgdx. Пользователь представлен сеткой букв 4х4 и должен найти слова, проводя пальцем по буквам.

В отличие от boggle, я хочу, чтобы использованные буквы исчезли. Оставшиеся буквы будут опускаться (до нижней части доски, ориентация экрана фиксирована), и доска заполняется сверху. Пользователи могут повернуть доску, чтобы попытаться сложнее использовать буквы в более удобном месте с помощью стратегического выбора слов.

Пример:

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

Если я выберу слово GRIT, эти буквы исчезнут, а остальные упадут:

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

а затем получить новые буквы

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

Я застрял, выясняя, как изобразить доску и плитки.

Я попытался представить доску в виде матрицы, чтобы отслеживать выбранные плитки и действительные ходы, а также плитки, сохраненные в матрице, чтобы было удобное отображение. Это работает, но мне пришлось написать какой-то замысловатый код, чтобы повернуть доску.

Как другие игры решают эту проблему?

РЕДАКТИРОВАТЬ: Итак, подумав, я должен просто обработать свою точку касания в соответствии с вращением доски, чтобы ячейки оставались постоянными. Прикрепил изображение того, о чем я думаю.

Я бы не стал использовать массивы для этого, потому что управление им будет становиться все более и более сложным. Создайте пользовательскую структуру данных Board с узлами, которые имеют ссылки на своих соседей. По сути, это многомерный LinkedList узлов. Таким образом, если буква узла удаляется, другие узлы могут просматривать это инкапсулированным способом. Это позволяет избежать сложной арифметики массивов. Вам понадобится одна большая функция, чтобы связать все правильно, но после связывания с логикой работать станет намного проще.

На ваших краевых узлах будут установлены соседи null, поэтому убедитесь, что обрабатываете это соответствующим образом в ваших методах класса Node, которые должны ссылаться на соседей.

Я использовал этот подход для реализации Game Of Life Конвея, и, как только вы его настроите, он значительно снизит сложность добавления логики, которая изменяет состояние узла на основе соседей.

В зависимости от того, как вы манипулируете узлами на плате, вам может понадобиться один метод на плате, чтобы выполнить итерацию и определить следующее состояние или действие и сохранить его в каждом узле. Затем выполните это, повторяя и фиксируя каждый узел в новом состоянии. Это позволяет избежать наличия узлов, определяющих их следующее состояние, путем просмотра узлов, которые уже изменились.

Да, решение состоит в том, что вы получаете значение из вашей матрицы или массива и устанавливаете Это значение для временного массива или матрицы, а затем устанавливаете значение оттуда, это покажет вам вашу величину вращения. Я добавил код ниже, я думаю, это поможет вам

    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