Jeu de mots - implémentation de plateau?

Je travaille sur un jeu de type boggle pour Android, en utilisant libgdx. L'utilisateur est présenté avec une grille de lettres 4x4 et doit trouver des mots en faisant glisser son doigt sur les lettres.

Contrairement à boggle, je veux que les lettres utilisées disparaissent. Les lettres restantes tomberont (vers le bas du tableau, l'orientation de l'écran est fixe) et le tableau est rechargé par le haut. Les utilisateurs peuvent faire pivoter le tableau pour essayer de mettre des lettres difficiles à utiliser à un meilleur endroit par une sélection stratégique de mots.

Un exemple:

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

Si je sélectionnais le mot GRIT, ces lettres disparaîtraient et les autres tomberaient:

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

puis être remplacé par de nouvelles lettres

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

Je suis coincé à trouver comment représenter le plateau et les tuiles.

J'ai essayé de représenter le tableau comme une matrice pour garder une trace des tuiles sélectionnées et des mouvements valides ainsi que des tuiles stockées dans une matrice afin qu'il y ait une cartographie facile. Cela fonctionne, mais j'ai dû écrire du code alambiqué pour faire pivoter la carte.

Comment les autres jeux gèrent-ils ce problème?

EDIT: Donc, en y réfléchissant, je devrais vraiment juste traiter mon point de contact en fonction de la rotation de la carte afin que les cellules restent constantes. Ci-joint une image de ce que je pense. Écran tactile traité pour que l'orientation de la carte ne change jamais

android libgdx

— andy mcevoy
source

Vous voulez dire que la direction dans laquelle les lettres tombent dépend de l'orientation de l'appareil? Pourriez-vous également préciser ce que vous entendez par «foiré quand je veux faire pivoter les carreaux» .

— Petr Abdulin

Je voulais dire que ma cartographie de l'emplacement du conseil d'administration à l'emplacement des tuiles était très compliquée une fois que j'avais effectué une rotation. Cependant, je pense que je peux résoudre ce problème si je pense que la planche tourne autour de l'origine d'un système de coordonnées au lieu que toutes les tuiles changent de place ...

— andy mcevoy

Merci pour la mise à jour. Il est généralement préférable de mettre à jour la question elle-même, afin que les autres n'aient pas besoin de fouiller dans les commentaires pour obtenir des informations précieuses. Je ne sais toujours pas comment la rotation est effectuée (maintenant), quel en est le résultat et comment cela rend le suivi difficile. Il n'est pas clair si le plateau complet est tourné ou que les carreaux individuels seulement. L'ajout de fragments de code est généralement d'une grande aide pour comprendre le problème.

— Petr Abdulin

Je pense que j'allais mal à propos du problème, le traitement du point de contact des utilisateurs en fonction de la rotation me permettra de considérer la carte comme un objet statique.

— andy mcevoy

Veuillez mettre ceci dans une réponse et acceptez votre réponse si vous avez trouvé la solution à votre problème; sinon, vous pouvez garder cela ouvert si vous n'êtes toujours pas sûr à 100%. Le terme pour décrire la solution que vous proposez est "traduction d'espace", c'est-à-dire que vous traduisez votre point de contact entre l'espace d'écran et l'espace de carte (tourné).

— Ingénieur

Réponses:

Je n'utiliserais pas du tout de tableaux pour cela car sa gestion deviendra de plus en plus complexe. Créez une structure de données de carte personnalisée avec des nœuds qui font référence à leurs voisins. Il s'agit essentiellement d'une LinkedList multidimensionnelle de nœuds. De cette façon, si la lettre d'un nœud est supprimée, les autres nœuds peuvent voir cela de manière encapsulée. Cela évite l'arithmétique compliquée des tableaux. Vous aurez besoin d'une grande fonction pour tout connecter correctement, mais une fois liée, la logique devrait être beaucoup plus facile à utiliser.

Vos nœuds périphériques auront des voisins définis null, alors assurez-vous de gérer cela en conséquence dans vos méthodes de la classe Node qui doivent faire référence aux voisins.

J'ai utilisé cette approche pour implémenter Game Of Life de Conway et une fois que vous l'avez configuré, cela réduit considérablement la complexité de l'ajout d'une logique qui change l'état d'un nœud en fonction des voisins.

Selon la façon dont vous manipulez les nœuds de la carte, vous pouvez avoir besoin d'une méthode de carte pour parcourir et déterminer l'état ou l'action suivante et l'enregistrer dans chaque nœud. Suivez ensuite cela en itérant et en validant chaque nœud dans le nouvel état. Cela évite que les nœuds déterminent leur prochain état en regardant les nœuds qui ont déjà changé.

— Assistant Tartle
source

-2

Oui, la solution est que vous obtenez la valeur de votre matrice ou tableau et définissez cette valeur pour le tableau ou la matrice temporaire, puis définissez la valeur à partir de là, cela vous montre votre valeur de rotation. J'ai ajouté du code ci-dessous, je pense que cela vous aide

    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
source