Graph in Bubble Shooter Télécharger - Graph in Bubble Shooter Téléchargement du code source

Graph in Bubble Shooter

Autre code source

Télécharger

Tireur de graphiques dans des bulles

Une implémentation simple d'un algorithme graphique dans Bubble Shooter

Introduction

Bubble Shooter est un jeu classique dans lequel le joueur tire des bulles colorées sur un champ rempli d'autres bulles. Le but est d'éliminer toutes les bulles sur le terrain en tirant des combinaisons de bulles de la même couleur. Les règles de base comprenant :

<1> Lorsque le joueur fait correspondre 3 bulles, les bulles apparaissent et sont supprimées du plateau.

<2> Lorsqu'une bulle n'est pas attachée à la racine, elle devient « flottante » et est retirée du tableau.

Implémentation de graphiques

Commençons par le sommet de notre graphique :

La Bulle est simplement une classe qui conserve toute la viabilité dont nous avons besoin. Nous définissons d'abord la profondeur sur -1 et découvrons sur false, puis nous ajoutons toutes les bulles adjacentes à la liste des bords.

 public class Bubble {
    public BubbleColor mBubbleColor ;
    public int mDepth = - 1 ;
    public boolean mDiscover = false ;
    public final ArrayList < Bubble > mEdges = new ArrayList <>( 6 );
    // ...
}

Recherche en largeur d'abord

Pour trouver des bulles correspondantes, nous utilisons BFS pour rechercher notre graphique. Nous partons du nouveau tir du joueur de bulles, qui est ajouté au graphique après collision avec d'autres bulles. Ensuite, on vérifie la profondeur, si elle est supérieure ou égale à 2 (en partant de 0), on supprime simplement celles dont la profondeur des bulles n'est pas -1.

 private void bfs ( Bubble root , BubbleColor color ) {
    Queue < Bubble > queue = new LinkedList <>();
    root . mDepth = 0 ;
    queue . offer ( root );

    while ( queue . size () > 0 ) {
        Bubble currentBubble = queue . poll ();
        for ( Bubble b : currentBubble . mEdges ) {
            // Unvisited bubble
            if ( b . mDepth == - 1 && b . mBubbleColor == color ) {
                b . mDepth = currentBubble . mDepth + 1 ;
                queue . offer ( b );
            }
        }
    }
}

Recherche en profondeur d'abord

Pour trouver des flotteurs, nous utilisons DFS pour rechercher notre graphique.

 private void dfs ( Bubble bubble ) {
    bubble . mDiscover = true ;
    for ( Bubble b : bubble . mEdges ) {
        if (! b . mDiscover && b . mBubbleColor != BubbleColor . BLANK ) {
            dfs ( b );
        }
    }
}

Tout d’abord, nous partons de la bulle de la première ligne en tant que racine.

 private void popFloater () {
    // We start dfs from root
    for ( int i = 0 ; i < mCol ; i ++) {
        Bubble bubble = mBubbleArray [ 0 ][ i ];   // Bubble at row 0
        if ( bubble . mBubbleColor != BubbleColor . BLANK ) {
            // Search from root bubble with dfs
            dfs ( bubble );
        }
    }
    // ...
}

Ensuite, on supprime simplement toutes les bulles non découvertes. (En fait, définissez-le sur VIERGE, pas nécessairement supprimé de notre graphique)