Discussion :

[Kropernic]

Hello,

Lors d'un après-midi de profond ennui, je me suis lancé le défi de coder un candy crush like. Ce qui conceptuellement ne semble pas du tout insurmontable.

Par contre, je sèche pour l'implémentation la fonction/procédure qui sera chargée de trouver s'il y a des combinaisons dans la grille.

J'ai tenté la recherche google car j'imagine que ce genre de problématique doit déjà avoir été à maintes reprises mais je ne dois pas utiliser les bons mots clefs car j'ai fait chou blanc jusqu'ici.

Quelqu'un aurait-il une idée quant aux mots clefs à utiliser ?

Sinon, pour quelque chose de plus concret, j'ai en fait un tableau de 10*10 cases qui contient des nombres entiers entre 1 à 5 (pour simplifier).
Ce que je cherche, c'est comment faire ma recherche de manière élégante. Les choses non élégantes se produisant en bordure de grille. L'idée de devoir faire des if pour tester si l'index de la ligne ou de la colonne vaut 0, 1, 8 ou 9 ne me plaît pas du tout. Je cherche donc une manière élégante de pallier à cela.

[Kropernic]

Hello,

Finalement, en puisant dans mes cellules grises, je suis parvenu à ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
    Public Sub CheckForPattern()
        Dim tilesToPop As New List(Of Tile)
        For Each t As Tile In MovedTiles
            'initialization
            MatchingTilesInRow = New List(Of Tile)
            MatchingTilesInCol = New List(Of Tile)
 
            'horizontal lookup
            MatchingTilesInRow.Add(t)
            'leftwards
            Dim r As Short = t.Row
            Dim c As Short = t.Col - 1
            Dim break As Boolean = False
            While Not (c < 0 Or break)
                If Tiles(r, c).Candy.Value = t.Candy.Value Then
                    MatchingTilesInRow.Add(Tiles(r, c))
                Else
                    break = True
                End If
                c -= 1
            End While
            'rightwards
            c = t.Col + 1
            break = False
            While Not (c > 9 Or break)
                If Tiles(r, c).Candy.Value = t.Candy.Value Then
                    MatchingTilesInRow.Add(Tiles(r, c))
                Else
                    break = True
                End If
                c += 1
            End While
            'vertical lookup
            MatchingTilesInCol.Add(t)
            'upwards
            r = t.Row - 1
            c = t.Col
            break = False
            While Not (r < 0 Or break)
                If Tiles(r, c).Candy.Value = t.Candy.Value Then
                    MatchingTilesInCol.Add(Tiles(r, c))
                Else
                    break = True
                End If
                r -= 1
            End While
            'downwards
            r = t.Row + 1
            break = False
            While Not (r > 9 Or break)
                If Tiles(r, c).Candy.Value = t.Candy.Value Then
                    MatchingTilesInCol.Add(Tiles(r, c))
                Else
                    break = True
                End If
                r += 1
            End While
 
            If MatchingTilesInCol.Count >= 3 Then
                For Each tile As Tile In MatchingTilesInCol
                    If Not tilesToPop.Contains(tile) Then
                        tilesToPop.Add(tile)
                    End If
                Next
            End If
            If MatchingTilesInRow.Count >= 3 Then
                For Each tile As Tile In MatchingTilesInRow
                    If Not tilesToPop.Contains(tile) Then
                        tilesToPop.Add(tile)
                    End If
                Next
            End If
        Next
        Pop(tilesToPop) 'delete matching candies
    End Sub

Y a probablement moyen d'optimiser le bousin alors s'il y en a parmi vous qui sont intéressés, n'hésitez pas ! (je peux filer le code de tout le projet s'il faut)

Reste encore à écrire le code qui reconnaîtra le type de pattern et lui attribuera un score.

[Uranne-jimmy]

Bonjour,
Je l'avoue, je ne connais pas le principe de candy crush, uniquement le principe de ce genre de jeu ^^ et de ce que j'ai compris du code, ça fonctionne uniquement sur des lignes, sauf cas particulier dans le sens où tu ne regarde pas autour de toutes les cases identiques que tu as trouvé (en espérant que tu comprennes ma phrase O.o).
Une autre méthode, assez semblable, donc pas forcement intéressante, aurait était d'effectuer le même chemin que les cases, en changeant la case observé à chaque fois, en récursif, si je ne me trompe pas :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
fonction regarderCaseAdjacente(case) :
pour i allant de 1 à 4
si coté(i) = case
enregistrer coté(i)
regarderCaseAdjacente(côté(i))
fin si
fin pour
fin fonction

Après je suis un débutant ^^'

[Kropernic]

[TROLL]
La vache, tu vis dans une grotte pour pas connaître candy crush ?!
[/TROLL]

Le principe de ce jeu est simple. On a une grille de x cases sur y cases (il peut y avoir des cases spéciales mais ne compliquons pas pour le moment^^) et chaque case possède une valeur entre 1 et 5 qui sont représentés, pour le cas de candy crush, par des bonbons de couleurs (et de formes) différentes. Il y en a des bleus, des rouges, des verts, des mauves et des jaunes*.

Le jeu se joue en permutant des cases directement adjacentes (ie pas en diagonale). Une fois les cases permutées, s'il y a une série de bonbons de la même couleur (donc de cases ayant la même valeur), on retire les bonbons** (ça fait marquer des points) et les vides sont comblés par ceux du dessus qui tombent (si le vide est sur la ligne supérieure, on en crée des nouveaux).

Les séries de bonbons (les patterns) se recherchent aussi bien verticalement qu'horizontalement. Les patterns existants sont :

• 3 à la suite
• 4 à la suite
• 5 à la suite
• En T (ou en L mais c'est pareil, juste l'intersection qui a bougé)

Du coup, soit je pige pas bien ton LDA, soit il te manquait de l'info et, du coup, ça ne correspond pas à la situation.

A priori, l'algo que j'ai pondu me trouve bien les séries de cases de même valeur lorsque je permute deux cases. Reste à prioriser maintenant. Car quand on a un T, faut pas qu'il prenne pour 3 à la suite. Ca fait moins de points^^.

* Y a encore des autres valeurs possibles mais ce sont des cas spéciaux donc plus tard.
** Pour les patterns autres que 3 à la suite, un bonbon spécial est créé mais c'est pour plus tard aussi.

[Kropernic]

Dans l'algo de mon 2e message, je stocke les cases qui constituent un pattern. Peut-être faudrait-il plutôt que je détecte à ce moment le type de pattern dont il s'agit et stocker carément le pattern en question (via une nouvelle classe qui va bien) histoire de pouvoir l'identifier par après pour l'attribution des points (et en bonus, la création du bonbon spécial s'il y a lieu)

[Uranne-jimmy]

[troll]
J'évite les jeux casus/sociaux dans ce genre là, je préfère un émulateur de GB ou un bon jeu de réflexion à un jeu comme celui là, surtout si, lié à facebook, il me demande de me mettre à genou et demander avec insistance des "vies" à mes contacts
[/troll]

J'ai oublié de préciser que i alant de 1 à 4 représente les 4 côtés, un for each CaseAdjacente fait pareil en plus clair.
Je ne sais pas si mon algo est correct, je pense qu'il marche, sauf qu'effectivement, je n'ai pas introduit la notion de ligne, de T ou de L uniquement de paquet de bonbons identiques collés quelque soit la forme du paquet. (ba oui, je connais le même type de jeu mais avec des règles légèrement différentes).

Pour autant, je vois des cas qui semblent ne pas fonctionner dans ton algo.
Imaginons que la case que tu test, qui vient donc de bouger, est à l'extrémité d'un T ? (le 2 dans le schéma suivant)

00000
02110<-- ligne testé
00100
00100
00000
-/\---
-||---
Colonne testé


Pour les patterns : si ils sont peu nombreux, c'est sans doute un moyen d'éviter une surcharge de travail du pc, si ils sont nombreux, tu vas te créer une surcharge de travail à faire tout les patterns.

Encore une fois, je nuance mes propos par l'expérience que j'ai : faible.

[Kropernic]

Cela ne pourra pas arriver.

Une combinaison valide est automatiquement supprimée

impossible donc d'avoir (en admettant que 0 est une valeur aléatoire dont on ne tient pas compte pour l'exemple)
0000000
0111000
0010000
0010000
0000000
0000000
où les cases ayant permutées sont celles en gras. Car la série en italique aurait été supprimée au coup précédent.