Nous continuons l'analyse de l'exemple de la Toe jeu Tic Tac, présenté en Actionscript 3.0 pour les débutants: leçon n ° 2 . Nous étions arrivés à la fonction qui crée la grille de jeu:
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 | / ** * Grille de création graphique (3x3) à l'écran * Void * @ Param * @ Return void * @ Privé * / createGrid ( ) : void { createGrid fonction privée (): void { / / Pointeur temporaire à un MovieClip / / Remarque: ici, vous pouvez également utiliser un Sprite / / Mais dans ce cas j'ai besoin d'étendre l'objet / / Ajout d'une certaine proproetà personnelle. Le Sprite / / Est une classe fermée et donc pas d'exécution extensible, tout en / / La classe MovieClip est dynamique et permet donc / / Possible l'ajout de la propriété runtime MovieClip , i : uint = 0 ; var tm: MovieClip , i: uint = 0; / / Ajouter le MovieClip dans un modèle 3x3 ; i < 9 ; i ++ ) { for (; i <9; i + +) { ( ) ; tm = new MovieClip (); tm ) ; addChild (tm); = OFFSETX + ( ( i % 3 ) * ( PLAYER_WIDTH + PLAYER_OFFSET ) ) tm. offsetX = x + ((i% 3) * (PLAYER_WIDTH PLAYER_OFFSET +)) = OFFSETY + Math . floor ( i / 3 ) * ( PLAYER_HEIGHT + PLAYER_OFFSET ) tm. OffsetY + y = Math . étage (i / 3) * (+ PLAYER_HEIGHT PLAYER_OFFSET) tm _index = i.; 0 ) ; drawPlayer (tm, 0); } / / Dessine les lignes 2 et 2 horizontaux veriticali this . graphics ) { avec (this. graphiques) { 6 , 0x666666 ) ; lineStyle (6, 0x666666); OFFSETX , OFFSETY + ( PLAYER_HEIGHT + 15 ) ) ; moveTo (offsetX, OffsetY + (PLAYER_HEIGHT + 15)); OFFSETX + ( ( PLAYER_WIDTH + 20 ) * 3 ) , OFFSETY + ( PLAYER_HEIGHT + 15 ) ) ; lineTo (offsetX + ((PLAYER_WIDTH + 20) * 3), OffsetY + (PLAYER_HEIGHT + 15)); OFFSETX , OFFSETY + ( PLAYER_HEIGHT + 20 ) * 2 ) ; moveTo (offsetX, OffsetY + (PLAYER_HEIGHT + 20) * 2); OFFSETX + ( ( PLAYER_WIDTH + 20 ) * 3 ) , OFFSETY + ( PLAYER_HEIGHT + 20 ) * 2 ) ; lineTo (offsetX + ((PLAYER_WIDTH + 20) * 3), OffsetY + (PLAYER_HEIGHT + 20) * 2); OFFSETX + ( PLAYER_WIDTH + 15 ) , OFFSETY ) ; moveTo (offsetX + (PLAYER_WIDTH + 15), OffsetY); OFFSETX + ( PLAYER_WIDTH + 15 ) , OFFSETY + ( ( PLAYER_HEIGHT + 20 ) * 3 ) ) ; lineTo (offsetX + (PLAYER_WIDTH + 15), OffsetY + ((PLAYER_HEIGHT + 20) * 3)); OFFSETX + ( PLAYER_WIDTH + 20 ) * 2 , OFFSETY ) ; moveTo (offsetX + (PLAYER_WIDTH + 20) * 2 OffsetY); OFFSETX + ( PLAYER_WIDTH + 20 ) * 2 , OFFSETY + ( ( PLAYER_HEIGHT + 20 ) * 3 ) ) ; lineTo (offsetX + (PLAYER_WIDTH + 20) 2 * OffsetY + ((+ PLAYER_HEIGHT 20) * 3)); } } |
Cette meotdo effectue deux tâches: pour ajouter un MovieClip utilisées pour intercepter un clic de la souris (la case "cercle" ou "queues") et en tire les deux verticales et deux lignes horizontales représentent les Graglia (stanghezza classique si vous le faites avec le crayon ). , perchè quest'ultimo non permette l'aggiunta di proprietà o metodi in fase di runtime. Comme indiqué dans le commentaire de la méthode, a été choisi l'objet MovieClip au lieu de la simple Sprite , parce que ce dernier ne permet pas l'ajout de propriétés ou de méthodes à l'exécution.
che ha il compito di disegnare sul MovieClip vuoto appena creato uno dei giocatori (la casella “cerchio” o “croce”), in base al secondo parametro passato nel Inputs . Après la création du MovieClip est une fonction spéciale appelée drawPlayer() qui a la tâche de concevoir l' MovieClip vous venez de créer une charge de joueurs (cochez la case "cercle" ou "queues"), selon le deuxième paramètre passé dans les entrées.
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 | / ** * Dessinez un cercle ou une croix en fonction du joueur * * @ Param (MovieClip) p = MovieClip où tracer * @ Param (uint) pl = nombre de joueurs: 1 ou 2 à 0 si vous dessinez un rectangle pour intercepter l'événement de clic * / drawPlayer ( p : MovieClip , pl : uint ) : void { fonction drawPlayer privé (p: MovieClip , pl: uint ): void { pl ) { commutateurs (pl) { / / Ceci est un cas particulier: un rectangle est tracé / / Utilisé pour détecter le clic de souris : case 0: p . graphics ) { avec (p. graphiques) { ; clear (); CELL_EVENT_COLOR , CELL_EVENT_ALPHA ) ; beginFill (CELL_EVENT_COLOR, CELL_EVENT_ALPHA); 0 , 0 , 60 , 60 ) ; drawRect (0, 0, 60, 60); ; endFill (); } = p . buttonMode = true ; p = p useHandCursor buttonMode = true..; / / Ajouter l'événement click de cette boîte de ( MouseEvent . CLICK , onCellClick ) ; . p addEventListener ( MouseEvent CLIC, onCellClick.); break; / / Le joueur 1 (ou) : cas 1: p . graphics ) { avec (p. graphiques) { ; clear (); PLAYER_LINE_WIDTH , PLAYER_1_COLOR ) ; lineStyle (PLAYER_LINE_WIDTH, PLAYER_1_COLOR); 30 , 30 , 30 ) ; drawCircle (30, 30, 30); } = p . buttonMode = false ; p = p useHandCursor buttonMode = false..; / / Suppression de l'événement click de cette boîte de ( MouseEvent . CLICK , onCellClick ) ; . p removeEventListener ( MouseEvent CLIC, onCellClick.); break; / / Le joueur 2 (x) : cas 2: p . graphics ) { avec (p. graphiques) { ; clear (); PLAYER_LINE_WIDTH , PLAYER_2_COLOR ) ; lineStyle (PLAYER_LINE_WIDTH, PLAYER_2_COLOR); 0 , 0 ) ; moveTo (0, 0); 60 , 60 ) ; lineTo (60, 60); 60 , 0 ) ; moveTo (60, 0); 0 , 60 ) ; lineTo (0, 60); } = p . buttonMode = false ; p = p useHandCursor buttonMode = false..; / / Suppression de l'événement click de cette boîte de ( MouseEvent . CLICK , onCellClick ) ; . p removeEventListener ( MouseEvent CLIC, onCellClick.); break; } } |
Le case 0 correspond à la case vide. : Cette circonstance se produit lors de l'initialisation du jeu: voir, en fait l'appel à drawPlayer() dans la méthode createGrid() :
1 | 0 ) ; drawPlayer (tm, 0); |
Dans cet état, la boîte est prêt à répondre à une entrée utilisateur. En fait, un écouteur est ajouté à intercepter l'événement clic de souris. Notez que lorsque vous dessinez un des deux joueurs (cas 1 et 2, le joueur «cercle» et «queue»), l'auditeur est tout simplement supprimé, afin d'éviter un «double jeu»!
Événements
Comme nous l'avons vu ci-dessus, le "vide" répond aux clics de souris:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | / ** * Cet événement est libéré lorsque vous cliquez sur un jeu de cellules * / onCellClick ( e : MouseEvent = null ) : void { onCellClick fonction privée (e: MouseEvent = null): void { / / Vérifier que le jeu n'est pas en pause ou arrêté ! __stop ) { if (arrêt __!) { / / Incrémente les clics compteur __clickNumber + +; / / Retourne le pointeur sur le joueur "cliqué" MovieClip = e . currentTarget as MovieClip ; var p: MovieClip = e currentTarget que. MovieClip ; / / Dessin (o) ou (x) __player ) ; drawPlayer (p, lecteur __); / / Lecture reflète la barrette _index ] = ( __player== 1 ) ? PLAYER_1_WIN : PLAYER_2_WIN ; __cell [p _index.] = (__ joueur == 1) PLAYER_1_WIN:? PLAYER_2_WIN; / / Vérifier si quelqu'un a gagné CheckCell (); / / Changement de quart: si le joueur a joué une imposées au joueur 2 et vice-versa ) ? 2 : 1 ; __player = (__ joueur == 1) 2: 1;? / / Pour souligner la nouvelle vidéo pour le joueur = "PLAYER " + __player ; . turno_txt text = "PLAYER" + __ joueur; } } |
Le drapeau __stop , ce qui correspond à une variable globale au sein de notre classe, est une norme technique qui vous permet de vérifier l'état de la partie. . Dans notre cas, j'avais l'habitude de dire à quel point le «jeu» __stop = false , et comment "pause" __stop = true . Lorsque déclenché l'événement onCellClick() , cliquez sur la souris sur la boîte, juste vérifier que le jeu est "en pause". Si nous augmentons le jeu variable de __clickNumber qui prend en compte le nombre de clics (ou jouer) fait. Cette «contre», il sera utile plus tard pour voir si toutes les cases sont cochées.
; utilizzando sempre il meotdo drawPlayer() . Grâce à la propriété e.currentTarget pointeur de récupération de la boîte sur laquelle il a été acheté et le clic sur cette conception un des deux signes possibles («cercle» ou «queue») basé sur le joueur actif a indiqué __player , en utilisant toujours le meotdo drawPlayer() . La ligne:
1 | _index ] = ( __player== 1 ) ? PLAYER_1_WIN : PLAYER_2_WIN ; __cell [p _index.] = (__ joueur == 1) PLAYER_1_WIN:? PLAYER_2_WIN; |
est important car il reflète le pari réseau linéaire logique utilisé - voir ci-dessous - pour déterminer le gain de l'un des joueurs. (valore 10) indicano nell'array lineare chi ha effettuato la giocata. Les constantes PLAYER_1_WIN (valeur 1) et PLAYER_2_WIN (valeur 10) réseau linéaire indiquer qui a fait le pari.
Voir pour plus d'informations: Undolibrary MatrixArray: une extension de la classe Array
CheckCell (): le noyau
Deichiamo un paragraphe à ce procédé étant, dans le cadre de cet exemple, le vrai coeur du jeu. La méthode checkCell() , en fait, il vérifie si il ya eu une victoire par l'un des deux joueurs:
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 | / ** * Cette fonction vérifie le tableau pour voir si tout * Joueur a gagné. Est appelée à chaque fois qu'un joueur * Marque une boîte avec un. (X) ou (o) * En outre, si la variable __ clickNumber est égal à 9, signifie * Que toutes les cases sont remplies et sans qu'il soit * Gagnant, personne n'a gagné! * * @ Privé * / checkCell ( ) : void { CheckCell fonction privée (): void { / / Sur la base de la valeur du joueur __ est fixé à la / / Contrôle de la valeur à déterminer un gagnant uint = ( __player== 1 ) ? 3 * PLAYER_1_WIN : 3 * PLAYER_2_WIN ; var winValue: uint = (__ joueur == 1) PLAYER_1_WIN * 3:? * 3 PLAYER_2_WIN; / / Vérifier toutes les lignes, des colonnes et des diagonales : Array = __cell ; var c: tableau = __ cellule; / / Vérifier les 3 premières lignes c [ 0 ] + c [ 1 ] + c [ 2 ] == winValue || if (c [0] + c [1] + c [2] == winValue | | 3 ] + c [ 4 ] + c [ 5 ] == winValue || c [3] + c [4] + c [5] == winValue | | 6 ] + c [ 7 ] + c [ 8 ] == winValue || c [6] + c [7] + c [8] == winValue | | / / Les 3 colonnes 0 ] + c [ 3 ] + c [ 6 ] == winValue || c [0] + c [3] + c [6] == winValue | | 1 ] + c [ 4 ] + c [ 7 ] == winValue || c [1] + c [4] + c [7] == winValue | | 2 ] + c [ 5 ] + c [ 8 ] == winValue || c [2] + c [5] + c [8] == winValue | | / / La diagonale 2 0 ] + c [ 4 ] + c [ 8 ] == winValue || c [0] + c [4] + c [8] == winValue | | 2 ] + c [ 4 ] + c [ 6 ] == winValue ) { c [2] + c [4] + c [6] == winValue) { / / Si aucune de ces conditions est vérifié / / Quelqu'un a gagné, et puis afficher le panneau / / De la «victoire» (1) ) ; showPanel (1); { Else {} / / Si personne n'a gagné, vérifier si toutes les cases / / Sont remplis. Si c'est le cas monstre le panneau / / Fin du jeu et «pas de gagnant" (0) __clickNumber == 9 ) { if (__ clickNumber == 9) { ) ; showPanel (0); } } } |
La méthode, dans sa simplicité, parle pour lui-même. Il est invoquée pour chaque clic sur le conseil de décider du sort du jeu! Le réseau logique est utilisé pour "ajouter" Lignes, colonnes et diagonales à la recherche d'un possible «trois» par le joueur actuel, indiqué par la variable __player . En outre, comme cela peut arriver, __clickNumber tient compte de clics effectués. Cette variable ne doit jamais atteindre une valeur de 9, sauf que ni joueur a gagné.
La prochaine fois que nous allons examiner quelques caractéristiques spécifiques du langage Actionscript 3.0 utilisées dans cette démo.
Il n'y a aucun commentaire pour cet article
Laisser un commentaire