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. Processar o toque na tela para que a orientação da placa nunca mude

android libgdx

— andy mcevoy
fonte

Você quer dizer que a direção em que letras estão caindo depende da orientação do dispositivo? Você também pode elaborar o que você quer dizer com "ferrou quando eu quiser girar os ladrilhos" .

— precisa

Eu quis dizer que meu mapeamento do local do tabuleiro para o local do ladrilho era muito complicado depois que eu fiz uma rotação. No entanto, eu acho que pode resolver este problema se eu pensar no conselho como girar sobre a origem de um sistema de coordenadas em vez de todos os azulejos mudando de lugar ...

— Andy McEvoy

Obrigado pela atualização. Geralmente, é melhor atualizar a pergunta em si, para que outros não precisem cavar comentários para obter informações valiosas. Ainda não está claro para mim como a rotação é executada (agora), qual é o resultado e como isso realmente dificulta o rastreamento. Não está claro se o tabuleiro inteiro é girado ou apenas peças individuais. Normalmente, adicionar fragmentos de código é de grande ajuda para entender o problema.

— Petr Abdulin

Eu acho que estava lidando com o problema de maneira errada. O processamento do ponto de contato dos usuários de acordo com a rotação permitirá que eu pense no quadro como um objeto estático.

— Andy McEvoy

Coloque isso em uma resposta e aceite sua resposta se você encontrou a solução para o seu problema; caso contrário, você poderá mantê-lo aberto se ainda não tiver 100% de certeza. O termo para descrever sua solução proposta é "tradução espacial", ou seja, você está traduzindo seu ponto de contato entre o espaço da tela e o espaço da placa (girado).

— Engineer

Respostas:

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.

— Assistente de Tartle
fonte

-2

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

— Divyang Metalia
fonte