PureBasic

c'est une fonction récursive...

exemple de Procedure Recursive

(c'est a dire , une procedure qui s'appelle elle meme )

ici pour calculer la factoriel d'un nombre

Code : Tout sélectionner


; ******* avec recursivité **********
debug "********* avec recursivité **********"
for i=1 to valeur_max
  debug factorielle(i)
next i 
 Procedure factorielle(n)
  If n = 1
    ProcedureReturn 1
  EndIf
  ProcedureReturn n * factorielle(n - 1) ; ici on sort de la procedure, puis on la relance avec un niveau different (recursivité )
EndProcedure
; ***********************************

on utilise la recursivité pour explorer tout les fichiers d'une arborescence par exemple

procedure je lis des fichiers (path )....

tiens... voila un dossier ...on entre dedans et .... --> procedure je lis les fichiers (nouveau path ) ....etc ...

si fin de liste fichier , alors path-1 ; on remonte
fin procedure

dans ton jeux, il faut obligatoirement en passer par la recursivité,
puisqu'on doit analyser le tableau , a un instant T , puis les conséquences de la disparition d'ensemble de couleurs (3 couleur alignées) et du coup, la reconfiguration du tableau suite a déplacement des couleurs...recreer probablement de nouveaux alignements de couleurs
qu'il faut vérifier et supprimer .....etc ...
(le serpent qui se mord la queue )

bref, il faut effectuer plusieurs verif, qui modifie ton tableau, et qu'il faut a nouveau vérifier .... (c'est chaud la récursivité a comprendre )

pour moi ça revient à faire ça (y'a sûrement des subtilités qui m'échappent !), je ne comprends pas trop l'intérêt de la fonction en paramètre, ni des 4 paramètres de la fonction anonyme !

Code : Tout sélectionner

// Loop over the cluster tiles And execute a function
    function loopClusters() {
        For (var i=0; i<clusters.length; i++) {
            //  { column, row, length, horizontal }
            var cluster = clusters[i];
            var coffset = 0;
            var roffset = 0;
            For (var j=0; j<cluster.length; j++) {
               level.tiles[cluster.column+coffset][ cluster.row+roffset].type = -1
                If (cluster.horizontal) {
                    coffset++;
                } Else {
                    roffset++;
                }
            }
        }
    }
   
    // Remove the clusters
    function removeClusters() {
        // Change the type of the tiles To -1, indicating a removed tile
        loopClusters();

        // Calculate how much a tile should be shifted downwards
        For (var i=0; i<level.columns; i++) {
            var shift = 0;
            For (var j=level.rows-1; j>=0; j--) {
                // Loop from bottom To top
                If (level.tiles[i][j].type == -1) {
                    // Tile is removed, increase shift
                    shift++;
                    level.tiles[i][j].shift = 0;
                } Else {
                    // Set the shift
                    level.tiles[i][j].shift = shift;
                }
            }
        }
}

pourquoi ne pas avoir chercher a refaire le jeux a partir de zero en Purebasic ?

la traduction d'un langage dans un autre, n'apporte pas toujours la solution...
mais bon , c'est aussi un challenge

Zorro a écrit :pourquoi ne pas avoir chercher a refaire le jeux a partir de zero en Purebasic ?

la traduction d'un langage dans un autre, n'apporte pas toujours la solution...
mais bon , c'est aussi un challenge

en fait, j'ai essayé, mais je n'ai pas réussi, je suis bloqué et à vrai dire, je ne sais pas trop quelle est la méthode pour ce type de jeu.
Voici un de mes premiers tests, mais ça bug :
http://www.purebasic.fr/french/viewtopi ... =1&t=16048

Donc, j'espérai que la traduction depuis un truc fonctionnel serait intéressant, mais c'est plus galère qu'autre chose à vrai dire ^^

bon j'ai eu un peu de temp pour regarder comment j'aurai aborder le truc
je precise, que je n'ai jamais coder ce genre de truc, mais fidele a mes habitude, je vais au plus simple (plus logique selon moi)
des fois, ça ne marche pas, mais dans 99% du temps, allez au plus simple donne un resultat

dans ce code exemple, j'utilise les chaines de caractere
ici je fait ressortir le principe de base

1- on recherche si 3 caractères sont consécutif (en horizontale pour le moment), si c'est le cas , on remplace par du vide (en fait une image noire )

2- on "compress" , c'est a dire que je part de la derniere ligne du bas , et je compare chaque caractere
avec son voisin du dessus (ligne-1)
si le caractere du bas est noire ("0") , on echange avec son voisin du dessus
ainsi de suite jusqu'en haut ce qui a pour effet, de remonter le noir vers le haut
et de donner aussi l'illusion que ce sont les couleurs qui tombent

pour le moment le code ne fait que ça !

il suffit de lancer le code , et de cliquer plusieurs fois sur le bouton pour voir le "tassement"se faire
dans une prochaine etape, il faut ajouter de nouveaux element qui tombe du haut ....
(c'est fait !! )

note, j'ai ajouté deja une gestion de la souris, (callback) en cliquant sur une case, ça renvoi la ligne et la colonne
se qui servira dans les strings, pour savoir quelle caractere on echange

en interne, j'utilise donc des caracteres , auquel je fait correspondre des images
de la sorte, la logique du jeux c'est du simple travail sur des carateres, donc utilisation du swap etc ...(lib String)

et le rendu c'est simplement la lecture de chaque ligne de caractere , auquel on fait correspondre une image de couleur
simple et efficace , pas de prise de tete avec les sprites ou autre
les images, bien sur pourront etre personnalisé, puisque de fait, nous ce qui nous intéresse c'est simplement les Strings !

voir code plus bas

j'ai ajouté les elements qui sont generé par le haut

plus qu'a gerer le swap avec la souris , la mecanique de base, fonctionne

n'oublie pas que le fait de cliquer sur le bouton c'est juste un mode Step by step

toute l'operation du debut se fera tout seul au lancement du jeux,
ensuite, vu que c'est rodé, les echanges de case pour creer de nouvelle serie de 3 caractere
actionneront, la mecanique d'animation , ce sera la meme que maintenant

ensuite, j'ajouterai la gestion des triplés verticale, c'est la meme chose en faite
sauf qu'on regarde sur 3 lignes a la position X

bon voici la suite

maintenant, j'ai donc passé toute la partie initialisation en automatique
au bout d'une instant tres court, la matrice se stabilise, il n'y a plus de serie de 3 dalles identique horizontale

que je vais appeler "triplet"
j'ai donc ajouté la gestion de la souris , donc maintenant lorsqu'on clique sur une dalle , ça echange
avec son voisin du dessus !

a partir de la, il faut essayer de faire que l’échange donne un nouveau triplet
si c'est le cas, l'animation s'effectue (les 2 etapes expliquée au debut de mon intervention )
1- recherche de triplet et remplacement par des dalles noires (les "trous")
2- compression de ces trous en les remontant vers le haut de la matrice
ceci s'effectue en permanence , ce qui fait que si on cree cette situation (un triplet)
ben le prg le supprime !

c'est a ce moment precis, qu'il faudra ajouter un compteur de points

voici le nouveau code :

le code a été transferé ici
http://www.purebasic.fr/french/viewtopi ... =2&t=16369

Salut Zorro

Merci pour ton exemple, je comprends l'idée et c'est pas mal d'utiliser les strings effectivement.
Par contre, ensuite, comment faire déplacer les cases (animation) car là, tout est remplacé immédiatement, or ce serait pas mal de voir les cases descendre (disons en une seconde),

idem lorsqu'on clique sur une case, ce serait bien de voir que c'est interverti : la case du haut dessus et celle du bas monte.

En tout cas l'idée est intéressante

ben ton ordi doit etre plus rapide que le miens !!

chez moi ça descend , je vois l'animation

met un petit delay()

je vais ecrire un nouveau topic pour ma derniere version quasi complete
qui tiens compte des alignements verticaux

ici :
http://www.purebasic.fr/french/viewtopi ... =2&t=16369

[reedit]
bon je reprends ma reponse , puisque j'ai été interrompu (donner a manger aux chats, menage,etc ...

)

pour ce qui est de l'animation , en fait, là, je donne le moteur de base, on connait la dalle qui a été cliqué
sous forme de coordonnées (ligne$,caractere$ )
on connaît forcement la destination (ligne$-1,caractere$ )
le changement en interne est mème deja fait (swap)
a partir de là , tout le reste c'est du decorum ..
la logique est établie , ensuite ont peut ajouter du décors (de l'animation)

par exemple , rien n’empêche de poser un sprite sur la dalle de départ et d'arrivé (puisqu'on donnait leur emplacement respectif)
et de faire "voler" les 2 sprites au dessus de la carte, avant de le positionner a leur emplacement d'arrivée, puis de les faire disparaître

de faire en sorte que toute les dalles de la matrice semble flotter au dessus d'un starfield ..etc
ajout de musique, et bruitage lors des déplacement , changement des dalles de couleurs par des images de bonbons

un peu a l'image de ce fameux jeux d'echec "Battle chess" sur Atari/Amiga

lorsqu'on déplaçait une piece , l'animation se mettait en route , alors que la logique interne du prg etait deja au courant
de leur deplacements, et de qui allait gagner le combat

là, le principe est le même , tout se qui sort de la base (le moteur du prg avec sa logique interne )
c'est du décorum , de l'esbroufe , du graphisme , bref, aucune importance pour le fonctionnement du code
mais forcement tres intéressant pour l'aspect

c'est clair, qu'il reste du travail , mais ça reste du Fun, la base est là

PureBasic

jeu de type match3

Re: jeu de type match3

Re: jeu de type match3

Re: jeu de type match3

Re: jeu de type match3

Re: jeu de type match3

Re: jeu de type match3

Re: jeu de type match3

Re: jeu de type match3

Re: jeu de type match3

Re: jeu de type match3