Forums Développement Multimédia

Aller au contenu

[TUTO] Tetris simple AS2

CODE

2 réponses à ce sujet

#1 Monsieur Spi

  • Community Manager
  • PipPipPipPipPipPipPipPip
  • 7012 messages

Posté 08 September 2009 - 20:35 PM

Salut,

Je me suis intéressé il y a quelques jours à la conception d’un Tetris, un type de programme pour lequel je n’avais encore jamais fait de tests.

Au départ je me suis dit que j’allais faire çà les doigts dans le nez avec un pied au dessus de la tête et en me tapant le bide par terre sur l’air de Traviata, et ben croyez-moi, croyez-moi pas, c’est pas si simple de trouver la bonne procédure pour démarrer.

Pour me lancer j’ai donc cherché un tuto ou une source simple pour voir dans quelle direction aller. J’en ai trouvé, mais à chaque fois c’était 2000 lignes de code avec des tableaux et des listes de références partout, l’horreur à disséquer quand on veut juste faire un truc rapide pour le fun.

J’ai tout foutu à la poubelle, jugeant la chose imbitable… et j’ai tout repris à zéro en me disant qu’il y avait certainement une manière plus simple de faire çà.

La chose la plus ardue à comprendre pour moi c’était sans doute la manière dont il faut gérer les pièces complexes et les blocs qu’elles contiennent pour les tourner et les emboîter tout en respectant les contraintes imposées par le jeu, avec un peu de réflexion la solution est évidente, il faut se concentrer sur les blocs...

Personnellement je ne suis pas une brute en maths et dès que je commence a avoir des chiffres un peu partout ou des listes de références çà me fait des gargouillis dans l’estomac… l’ulcère se réveille.
J’ai donc décidé de me passer au maximum des tableaux et de préférer utiliser l’IDE quand c’est possible.

Çà m’a pris une petite journée (ce tuto compris) et çà tient en 200 lignes de code et quelques clips. Si çà vous intéresse de voir comment je me suis dépatouillé avec la chose je vous met le retour d’expérience sous forme de tuto, il vous faudra connaître certaines bases pour suivre mais si vous êtes total débutant lorsque vous ne connaissez pas un code ou une expression allez faire un tour dans l’aide de Flash vous trouverez la description de la commande.




Allez c’est parti pour l’étape 1

On commence par paramétrer le projet

- Largeur : 550 px
- Hauteur : 425 px
- FPS : 30
- Couleur de fond : Noir

Création du terrain de jeu

La toute première base de réflexion sur laquelle je suis parti c’est de me dire qu’il va me falloir une grille dans laquelle mes pièces vont évoluer, mon terrain de jeu si vous préférez.



Pour faire simple, j’utilise des petits blocs identiques (des tiles) et je les place sous la forme d’une grille à l’aide du code.
Jusque là rien de bien exceptionnel çà se met en place en moins d’une minute.

Créez un clip vide que vous nommez « vide » et liez pour AS.
Créez un deuxième clip représentant un carré rouge de 25*25 px, nommez le « tiles » et exportez le pour AS.

Supprimez ces deux clips de la scène ils n’ont plus rien à y faire, on en a juste besoin en bibliothèque.
Dans tout l’exercice vous n’aurez jamais rien sur la scène on ne se servira que de clips exportés pour AS et présent dans la bibliothèque.



Sur votre timeline allez sur la frame vide et ouvrez la fenêtre d’actions (F9) puis tapez le code suivant :

// cre la grille
this.attachMovie("vide","grille",10,{_x:25, _y:25});
for (var c:Number = 0; c<10; c++) {
        for (var l:Number = 0; l<15; l++) {
                grille.attachMovie("tiles","bloc"+c+"_"+l,grille.getNextHighestDepth(),{_x:c*25, _y:l*25});
        }
}
 

Traduction

J’attache sur la scène une occurrence de « vide », je lui donne le nom de « grille » et je la positionne.
Puis j’effectue une boucle de 0 a 9 (10 colonnes)
Dans cette boucle (donc par colonne) j’effectue une boucle de 0 à 14 (15 lignes)
Pour chaque case (colonne, ligne) j’attache dans « grille » une occurrence de « tiles » que je nomme et que je positionne.


Créer une pièce

Bien la grille est en place, la deuxième étape dans ma réflexion était de construire les principales commandes du jeu mais avec un seul petit bloc, sans me soucier des pièces et de leurs formes pour le moment.

Pour commencer il me faut :

  • un bloc qui va descendre depuis le haut du terrain de jeu vers le bas.
  • un code de déplacement de ce bloc vers la droite et la gauche
  • les limites du terrain pour que le bloc n’en sorte pas

Créez un nouveau clip, un carré de 25*25 px, nommé « bloc » que vous exportez pour AS.



Sur la timeline ajoutez à votre code :

function creePiece() {
        grille.attachMovie("bloc","piece",2000,{_x:5*25, _y:0*25});
}
creePiece();


Traduction

Crée une fonction « creePiece() “ chargée de créer une nouvelle pièce.
Dans la grille crée une occurrence de « bloc », nomme la « piece » et positionne la.
Lance une première fois la fonction pour créer la première pièce.




Faire tomber, arrêter et enregistrer une pièce

Ok à présent il faut que mon bloc se déplace et s’arrête si il touche le bas du terrain ou un autre bloc situé en dessous, pour çà j’ai besoin de connaître les limites du terrain et d’enregistrer la position des blocs déjà posés.

On va éviter de se perdre dans de multiples tableaux inutiles en utilisant le terrain de jeu.
En effet le terrain est déjà un tableau de référence, çà ne se voit pas au premier coup d’oeil car nul part nous n’avons décrit spécifiquement un tableau en tant que tel (un Array) mais de part sa construction mon objet « grille » (le terrain de jeu) est un tableau à deux dimensions où pour chaque case j’ai un clip de référence. En construisant ma grille j’ai donc aussi construit un tableau, et quel tableau ! Il contient toutes les positions possibles de la zone de jeu, plutôt pratique.

Ce tableau à besoin (pour l’instant) de nous indiquer deux choses :

  • si la case est libre
  • ou si elle est occupée


Pour cela on va introduire la notion d’état.

Si on utilisait les tableaux classiques on regarderait simplement la valeur contenue dans l’entée correspondante à la colonne X et la ligne Y et en fonction de cette valeur on connaîtrait l’état.
Mais nous utilisons un tableau de référence rempli avec des clips et non des variables ou des valeurs. Qu’à cela ne tienne, nous allons vérifier l’état du clip tout simplement.

On commence par éditer le clip « tiles » et on y ajoute une frame sur laquelle on pose le même carré que sur la frame 1 mais d’une couleur différente. On rajoute un stop() au dessus de nos frames.



Le clip « tiles » contient à présent deux états, chacun sur une frame.
Par défaut on considérera que la frame 1 représente l’état « vide » et la frame 2 l’état « occupé »

Pour connaître l’état d’une case on regarde la frame affichée pour cette case.



Pour enregistrer la position d’un bloc immobile on renseigne la grille (passe la case en frame 2),

A la suite du code écrivez :

// boucle
onEnterFrame = function () {
        descendre();
};

function descendre() {

        // variables
var colonne:Number = Math.floor(grille.piece._x/25);
        var ligne:Number = Math.floor(grille.piece._y/25);

        if (ligne<14 && grille["bloc"+colonne+"_"+(ligne+1)]._currentframe != 2) {
                grille.piece._y++;
        } else {
                grille["bloc"+colonne+"_"+ligne].gotoAndStop(2);
                grille.piece._y = 0;
        }

}


Traduction.

Crée une boucle permanente
Appelle la fonction « descendre » à chaque pas du programme.

La fonction « descendre »
Crée deux variables internes, « colonne » et « ligne ».
Vérifie si la pièce n’a pas atteint le bas de la « grille » (la ligne 14).
Vérifie que la ligne située sous le bloc n’est pas dans un état 2
Si ces deux conditions ne sont pas remplies alors la pièce descend.
Sinon enregistre la position actuelle de la pièce dans la « grille »
Recrée la pièce.


Déplacer une pièce

On va créer un moteur de déplacement classique (utilisation de la détection des touches)
Et se servir des flèches gauche et droite pour déplacer la pièce.
Afin de vérifier si ma pièce peut se déplacer à droite ou à gauche je vais encore utiliser la grille
A chaque mouvement je vérifie si la case à droite de la pièce n’est pas occupée et si elle existe.
Si l’emplacement est vide mais existe je peux aller à droite.
Pareil pour la gauche.



Par construction il est nécessaire de bloquer la répétition des touches.
On se déplace de colonne en colonne soit de 25 pixel par pression sur la touche.
Si la répétition est active on se déplace de 25 pixels 30 fois par seconde… c’est injouable.

A la suite de votre code tapez :

var bloqueD:Boolean = false;
var bloqueG:Boolean = false;

function directions() {

        // positions
        var colonne:Number = Math.ceil(grille.piece._x/25);
        var ligneH:Number = Math.floor(grille.piece._y/25);
        var ligneB:Number = Math.ceil(grille.piece._y/25);

        // raccourcis
        var nG:String = "bloc"+(colonne-1);
        var nD:String = "bloc"+(colonne+1);

        // conditions
        var g:Boolean = Key.isDown(Key.LEFT);
        var d:Boolean = Key.isDown(Key.RIGHT);
        var nextGH:Boolean = grille[nG+"_"+ligneH]._currentframe != 2;
        var nextDH:Boolean = grille[nD+"_"+ligneH]._currentframe != 2;
        var nextGB:Boolean = grille[nG+"_"+ligneB]._currentframe != 2;
        var nextDB:Boolean = grille[nD+"_"+ligneB]._currentframe != 2;
        var bordG:Boolean = grille[nG+"_"+ligneB];
        var bordD:Boolean = grille[nD+"_"+ligneB];
        var Gauche:Boolean= g && !bloqueG && nextGH && nextGB && bordG;
        var Droite:Boolean= d && !bloqueD && nextDH && nextDB && bordD;

        // actions
        if (Gauche) {
                grille.piece._x -= 25;
                bloqueG = true;
        } else
        if (Droite) {
                grille.piece._x += 25;
                bloqueD = true;
        }
       
        // dbloque les touches
        if (!g) {
                bloqueG = false;
        }
        if (!d) {
                bloqueD = false;
        }
}
 

Je crée deux variables qui me seront utiles pour bloquer la répétition des touches.
Puis je crée une fonction « directions », cette fonction sera appelée en boucle.
On va donc tout de suite la rajouter dans la boucle principale du programme.

Modifiez :

// boucle
onEnterFrame = function () {
        descendre();
directions();
};
 

Ensuite dans la fonction nous allons créer de nombreuses variables utiles plus tard dans les calculs.
J’ai pris cette habitude de glisser un maximum de choses dans des variables simples de manière à pouvoir les manipuler plus facilement plus tard, du coup les codes sont souvent structurés de la même manière c'est-à-dire que je commence par une définition de toutes les variables utiles dans la fonction puis j’effectue les calculs, çà me parait plus lisible mais c’est à chacun de voir ce qui lui convient le mieux.

Le but de la fonction est de savoir si la « piece » peut se déplacer à droite ou à gauche et d’effectuer le déplacement le cas échéant.

On commence donc par chercher les coordonnées de notre pièce dans la grille, la colonne et deux lignes.

Pourquoi deux lignes ?
Notre bloc est composé de plusieurs côtés, mais se déplace verticalement non pas ligne par ligne mais de manière fluide en fonction d’une vitesse déterminée. Du coup notre bloc est souvent à cheval entre deux lignes et on doit prendre en compte ces deux lignes pour savoir si notre pièce peut bouger à droite ou à gauche.

Si la pièce se trouve entre deux lignes comment savoir quelle ligne prendre en compte ?
On va utiliser deux repères concernant notre bloc, la ligne dite « haute » et celle dite « basse ».
Lorsque le bloc se déplace il faut vérifier ces deux repères pour savoir si aucun bloc ne gène dans la colonne adjacente, à savoir la ligne où se situe le haut du bloc et la ligne où se situe le bas du bloc.



On vérifie également si une touche est pressée puis les états des pièces adjacentes à notre bloc.

Puis on effectue les calculs.

  • Si le bloc peut bouger on le déplace et on bloque la répétition de la touche.
  • Sinon le bloc ne bouge pas.

Si on appuie pas sur une touche on débloque la répétition de cette touche.

Compilez votre programme et regardez ce qu’il se passe.

Nous avons fini avec l’étape 1, rien de bien complexe, on obtient une base simple pour notre futur jeu où on a utilisé que des commandes classiques et un minimum de tableaux de références ou de calculs mathématiques.

La prochaine étape consistera à faire la même chose mais cette fois avec des pièces complexes et non plus un bloc simple.


VOICI LES SOURCES :








ETAPE 2

Bien, à partir de maintenant on va accélérer un peu et réduire les explications.
Si vous avez pris le temps de dépiauter l’exercice ci-dessus et que vous l’avez compris vous devriez réussir à suivre sans trop de problème.

Vous savez :



  • générer la grille
  • créer une pièce simple
  • déplacer la pièce
  • vérifier ses contraintes
  • enregistrer sa position dans la grille

On va donc se concentrer sur la réflexion, le code est entièrement commenté dans la source que je fourni à la fin de ce mini tutoriel, le mieux est de d’abord tout lire ici puis d’aller jeter un œil sur le code.

Dans cette partie nous allons un peu plus loin en voyant comment :



  • créer des pièces complexes
  • déplacer des pièces complexes
  • faire tourner des pièces complexes
  • prévoir la prochaine pièce qui va être générée
  • donner des couleurs aux pièces
  • vérifier si une ligne complète est remplie dans la grille
  • supprimer une ligne dans la grille et faire descendre tout ce qui se trouve au dessus

On ajoutera également au moteur un petit code pour faire descendre la pièce plus vite lorsque l’on appuie sur la flèche « bas », il s’agit simplement d’une modification de la vitesse, inutile de vous décrire cette partie vous devriez être en mesure de la comprendre tout seul.

Concept

L’essentiel du travail à effectuer reposera donc sur la manière dont nous allons gérer des pièces complexes, c'est-à-dire ces pièces composées de plusieurs blocs.



Avec un seul bloc c’était relativement simple, il suffisait de vérifier sa position par rapport à la grille, mais avec des pièces nous allons avoir un problème car la forme varie de l’une à l’autre et elles peuvent s’emboîter. On ne peut donc pas se contenter d’utiliser la pièce dans son ensemble.
Nous allons devoir déterminer la position de chaque bloc à l’intérieur de la pièce puis effectuer des vérifications pour chacun de ces blocs par rapport à la grille, le tout en fonction des mouvements global de la pièce.

A ce stade deux techniques sont possibles pour la même base de réflexion, et c’est ici que nous allons commencer à utiliser l’IDE plutôt que des tableaux (et que les hard codeurs vont sentir un picotement leur monter le long de la colonne vertébrale pour se fini en tic nerveux au niveau du maxillaire droit, la main tendu tout prêt du Rotulator … pas de panique, si vous en êtes à suivre un tuto pour faire un Tetris on peut raisonnablement penser que vous n’êtes pas un « hard codeur » mais que vous voulez juste comprendre comment çà marche).

Avant tout il est nécessaire de bien cerner le principe.

  • Chaque bloc qui compose une pièce a une position précise à l’intérieur de cette pièce.
  • Tous les blocs d’une pièce bougent à l’unisson lorsque la pièce bouge.
  • Il suffit qu’un seul bloc subisse une contrainte pour que la pièce entière la subisse.

Nous pouvons donc soit passer par des tableaux où on renseigne les positions de chaque bloc pour chaque pièce et chacune de ses rotations, puis placer ces blocs directement à l’aide du code lorsque l’on génère une pièce (ce qui revient à générer dynamiquement la pièce à l’aide du tableau de référence et modifier la position des blocs en fonction de la rotation de la pièce…).

Ou nous pouvons utiliser l’IDE de Flash pour créer des pièces et y placer à la main (en « WYSIWYG » diront les geeks) les blocs qui les composent, puis aller chercher, grâce au code, la position de chaque bloc dans la pièce nouvellement générée. On fait donc l’inverse de la proposition précédente, on ne crée pas la pièce en fonction de tableaux de références mais on utilise directement la pièce comme tableau de référence en allant y extraire les positions de chaque bloc.

Avec cette deuxième solution on s’affranchit de nombreux tableaux de références et on gagne un temps énorme. Cependant cette méthode est sans doute moins optimisée, mais n’oublions pas que nous faisons un Tetris, donc un jeu qui ne va pas demander beaucoup de ressources pour fonctionner, on peut donc utiliser cette méthode sans trop de risques de voir le programme surconsommer et se mettre à ramer.

Structure des pièces

Si on était parti de tableaux de références pour déterminer les positions des blocs pour chaque pièce, la logique voudrait qu’on modifie ces tableaux en fonction de la nouvelle position des blocs une fois la pièce tournée dans un certain sens, ou qu’on utilise pleins de tableaux de références pour chaque pièce et chaque état de rotation de la pièce… que c’est compliqué tout çà…

Allez hop, on reprend notre principe avec l’IDE.
On va considérer chaque pièce comme un sprite (…de jeu vidéo, c'est-à-dire une suite d’images sensés représenter un objet en mouvement). Une pièce est donc un clip composé de plusieurs frames avec sur chaque frame une représentation du mouvement à un instant T.



Dans notre cas une pièce est composée d’éléments plus petits, les blocs, on va donc créer les X blocs utiles, les nommer et les placer à la main aux bons endroits pour créer notre forme.
On va ensuite repositionner les blocs sur chaque frame, toujours à la main, pour obtenir notre sprite.
Lorsque l’on fait tourner une pièce on change de frame dans le sprite et on récupère la nouvelle position des blocs.

Il ne reste plus qu’à effectuer les vérifications utiles sur chaque bloc de la pièce, nous avons vu çà pour un bloc unique dans la première partie de cet exercice, il suffit d’utiliser une fonction unique que nous allons appeler pour chaque bloc contenu dans la pièce.

Rotation des pièces

A présent nous allons devoir faire attention aux rotations, une des contraintes est de ne pas pouvoir effectuer une rotation sur une pièce si celle-ci, une fois tournée, entre en conflit avec les conditions de départ, à savoir :
  • La pièce ne doit pas sortir tout ou en partie de la zone de jeu
  • La pièce ne doit pas pouvoir tourner si après rotation elle se superpose avec une autre pièce ou avec le sol

C’est sur ces deux points que passer par des tableaux de références serait réellement utile afin de déterminer quelle serait la position de chaque bloc une fois la pièce tournée mais AVANT d’effectuer la rotation. Il suffirait de vérifier le tableau représentant la prochaine rotation de la pièce.

Mais nous possédons plus d’un tour dans notre sac et faire passer çà par l’IDE pour éviter la manip de tableaux ne semble pas impossible.

Pour cela nous allons créer une copie conforme de la pièce au moment où on la génère.
Ce n’est donc pas une mais deux pièces que l’on va générer à chaque fois.
Ces deux pièces sont tout à fait similaires à ceci près que le clone sera invisible et collé sur la pièce d’origine.



Lorsque nous voulons vérifier si la pièce peut effectuer une rotation, on va d’abord faire tourner le clone. On vérifie si aucun bloc du clone n’est en conflit avec une des contrainte imposées, si le clone ne subit pas de contrainte alors la pièce peut bouger, sinon on replace le clone a sa position d’origine.

Si les actions se passent dans le bon ordre tout fonctionne très bien. C’est certes moins précis car il y a un très léger temps de latence entre la vitesse de chute de la pièce et le moment nécessaire à la rotation du clone et à la vérification des blocs, mais c’est tout à fait négligeable à ce niveau

Effacer des lignes

Tout ceci est bien beau mais la zone de jeu n’est pas extensible, nous allons donc devoir supprimer des blocs dans la grille lorsque nous avons une ligne complète.

C’est la base de Tetris, faire des lignes avec les pièces pour libérer de la place dans la zone de jeu et continuer à pouvoir placer des pièces.

Le comportement doit être le suivant :

  • lorsqu’une ligne est remplie elle s’efface
  • tout ce qui se trouve au dessus de cette ligne descend d’une ligne

Ok, voyons comment on peut conceptualiser çà.
Lorsqu’une pièce est posée (ou bloquée) on effectue une vérification dans la grille.
On partira du bas de la grille et on vérifiera ligne par ligne pour voir si l’une d’elle est remplie.
Si la ligne est remplie (tous les états des blocs de la ligne sont « remplis ») on fait descendre toutes les lignes qui sont au dessus.

Mais nous allons être malins, on ne va pas s’embêter à faire descendre des lignes de blocs de la grille et bouger tous les tiles etc…, on va simplement modifier leurs états. Ainsi lorsqu’un bloc disparaît on récupère l’état du bloc qui se trouve à la ligne juste au dessus de lui dans la même colonne et on lui attribue cet état. On répète l’opération jusqu’à ce qu’on soit arrivé en haut de la grille.



La base du jeu est montée, elle utilise peu de tableaux, le code tient en très peu de lignes, tout ceci ne tourne pas trop mal même si ce n’est pas la perfection pour un développeur.

Attribuer des couleurs et afficher la pièce suivante

Notre jeu est bien avancé mais il nous manque encore quelques petites choses comme la présentation de la pièce suivante ou les couleurs de chaque pièce.

Pour les couleurs c’est très simple et là encore on va utiliser l’IDE.
Chaque pièce est composée de plusieurs occurrences du même bloc.
On peut donc imaginer que le bloc de référence est lui aussi un sprite contenant plusieurs frames (ou états), une par couleur.



Dans le code il suffit de déterminer au moment où on génère une pièce, quelle couleur elle doit avoir.
Puis appeler la bonne frame pour chaque bloc contenu dans la pièce.

Et hop on a nos couleurs sans passer par des tableaux ou des codes étranges avec des objets colorTransform pour modifier la couleur des pièces.

Oui mais voilà, comment on fait pour que, une fois la pièce immobilisée, on puisse obtenir la même couleur dans les états du bloc de la grille de référence ?

Et bien de la même manière, la couleur de la pièce est enregistrée dans une variable, il suffit donc de créer les mêmes frames de couleur dans le bloc sensé représenter l’état « rempli » (frame 2) pour la grille de référence et d’appeler la bonne couleur correspondant à la pièce posée pour que nos blocs se colorent comme il faut.

Ok passons à la pièce dite de « preview » c'est-à-dire la pièce suivante qui doit normalement s’afficher pour indiquer au joueur quelle sera la pièce à venir.

Pour çà c’est très simple, on a vu précédemment l’utilisation des frames pour les couleurs des blocs.
On sait aussi qu’on à X pièces possibles.

On va donc simplement modifier notre code pour déterminer dans l’ordre :

  • quelle sera la prochaine pièce et l’afficher en dehors de la grille
  • créer notre pièce jouable dans la grille avec la référence de la pièce de preview
  • générer une nouvelle preview.

Bien entendu vous devrez faire de même en ce qui concerne les couleurs.



ETAPE 4

Voilà notre Tetris est bien avancé, il reste néanmoins quelques petites choses à voir comme :

  • fin de partie si les blocs touchent le haut de la zone de jeu
  • gain de scores lorsqu’une ligne est supprimée
  • passage de niveaux avec augmentation de la vitesse de jeu
  • enregistrement des scores dans un fichier externe
  • interface, sons et tout le tralala qui fera du jeu un truc complet


Fin de partie

Pour la fin de partie nous allons une nouvelle fois utiliser la grille.
La réflexion est simple, chaque pièce est construite de telle manière qu’il n’est pas possible de l’utiliser sur la ligne supérieure de la grille. Le mouvement de la pièce et sa forme rendent la ligne supérieure totalement injouable. Il ne nous reste plus qu’à utiliser cette ligne pour déterminer si la partie est perdue. Pour cela rien de plus simple, au moment où on pose une pièce on vérifie si un de ses blocs ne se trouve pas sur la ligne supérieure (par construction il s’agit de la première ligne de notre grille). Si c’est le cas on considère que le « plafond » est atteint et que la partie est perdue.



Gain des scores et bonus

C’est une partie plutôt libre pour la construction mais on peut déjà envisager quelques possibilités.

  • attribuer un score par ligne supprimée
  • attribuer un bonus lorsque plusieurs lignes sont supprimées en même temps (compteur)
  • attribuer un bonus lorsqu’une ligne est d’une couleur unique
  • etc…

Passages de niveaux

Cette partie est également adaptable en fonction de vos envies.
Généralement on se contente d’augmenter la vitesse du jeu lorsque un certain temps est écoulé ou un certain nombre de lignes supprimées. Le nombre de niveaux dépend alors de l’augmentation de la vitesse du jeu, il faut s’arrêter avant que cela ne devienne injouable.

Mais partant de ce que vous savez à présent vous pouvez imaginer de faire monter toutes les lignes de la zone de jeu tous les X temps en rajoutant une ligne complète par le bas, les solutions sont multiples à vous de voir ce que vous pouvez ajouter.

Enregistrement des scores
Cette partie est indépendante, il s’agit simplement d’envoyer des variables à partir d’un formulaire à un fichier PHP qui va se charger d’enregistrer les scores. La partie Flash sert à récupérer les données et à les afficher et à enregistrer les scores via un formulaire.

Interface, sons etc…

Là aussi inutile d’entrer trop loin dans le sujet, chacun gère çà à sa manière et ce n’est pas essentiel pour faire fonctionner le jeu.


VOICI LES SOURCES :






CONCLUSION

Je pense que nous avons fait le tour des choses intéressantes à vous de faire le reste selon votre imagination.

Je me dois de vous rappeler que cette méthode n’est pas la meilleure car elle est soumise à certaines contraintes dont on pourrait s’affranchir en passant par du code pur et des tableaux. Cependant elle est largement suffisante pour ce type de jeux et pour vous permettre de comprendre les principes de bases du moteur. Le code est simple et ne devrait pas poser trop de problème à adapter en AS3 pour ceux qui le souhaitent.

Cette source est libre de droits, vous pouvez en faire ce que vous voulez.
Si certains d’entre vous souhaitent apporter des modifications ou améliorations n’hésitez pas à poster le résultat de votre travail, d’autre reprendrons peut être là où vous vous en serez arrêté et compléterons à leur tour…



Pour finir je me permettrais de citer Perceval dans Kaamelott :

Citation

« Dans la vie, j'avais deux ennemis: le vocabulaire et les épinards. Maintenant j'ai la botte secrète, et je bouffe plus d'épinards. Merci, de rien, au revoir messieurs dames. »


Bon courage à vous et bons jeux.

Miniature(s) jointe(s)

  • Image attachée: tetris1.jpg
  • Image attachée: tetris-2.jpg
  • Image attachée: tetris-3.jpg
  • Image attachée: tetris-3a.jpg
  • Image attachée: tetris-4.jpg
  • Image attachée: tetris-5.jpg
  • Image attachée: tetris-6.jpg
  • Image attachée: tetris-7.jpg
  • Image attachée: tetris-8.jpg
  • Image attachée: tetris-9.jpg
  • Image attachée: tetris-10.jpg
  • Image attachée: tetris-11.jpg
  • Image attachée: tetris-12.jpg
  • Image attachée: tetris-13.jpg
  • Image attachée: tetris-14.jpg
  • Image attachée: tetris-15.jpg

Fichier(s) joint(s)



#2 soju22

    Ceinture Marron

  • Members
  • PipPipPipPipPipPip
  • 143 messages

Posté 08 September 2009 - 21:11 PM

Bonjour

Super boulot, j'ai bien aimé l'astuce d'utiliser des clips à la place de tableau (consommation mémoire plus importante par contre, mais pas grave vu que ça reste limité), et aussi le "clone" pour la rotation.

#3 Monsieur Spi

  • Community Manager
  • PipPipPipPipPipPipPipPip
  • 7012 messages

Posté 09 September 2009 - 13:09 PM

Hello,

Merci, c'est juste pour le fun, je voulais pas me prendre la tête alors j'ai cherché un compromis simple.



1 utilisateur(s) li(sen)t ce sujet

0 membre(s), 1 invité(s), 0 utilisateur(s) anonyme(s)