Actionscript 3.0 für Anfänger: Lektion # 3

Wir werden weiterhin die Analyse des Beispiels des Spiels Tic Tac Toe, in vorgestellt Actionscript 3.0 für Anfänger: Lektion # 2 . Wir kamen auf die Funktion, dass das Spiel Raster erstellt:

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

/ **
* Grafische Gestaltung Raster (3x3) auf dem Bildschirm
*
* @ Param void
* @ Return void
* @ Private
* /
createGrid ( ) : void { private function createGrid (): void {
/ / Temporäre Zeiger auf eine MovieClip
/ / Anmerkung: Hier könnte auch ein Sprite
/ / Aber in diesem Fall brauche ich, um das Objekt zu erweitern
/ / Hinzufügen einiger persönlicher proproetà. Die Sprite
/ / Ist eine geschlossene Klasse und daher nicht erweiterbare Laufzeit, während
/ / Der MovieClip-Klasse ist eine dynamische Klasse und macht dann
/ / Mögliche hinzufügen Laufzeiteigenschaften
MovieClip , i : uint = 0 ; var tm: MovieClip , i: uint = 0;
/ / Fügen Sie die MovieClip in einem 3x3-Muster
; 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 . floor (i / 3) * (+ PLAYER_HEIGHT PLAYER_OFFSET)
tm _index = i.;
0 ) ; drawPlayer (tm, 0);
}
/ / Zeichnen Sie die 2 Zeilen und 2 horizontalen Bereiche adressierbar
this . graphics ) { mit (this. Grafiken) {
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));
}
}

Diese meotdo erfüllt zwei Aufgaben: So fügen Sie einem MovieClip verwendet, um die mit einem Mausklick (das Feld "Kreis" oder "Zahl") abfangen und ziehen die zwei horizontale und zwei vertikale Linien stellen die Graglia (wenn Sie stanghezza klassischen Bleistift ). , perchè quest'ultimo non permette l'aggiunta di proprietà o metodi in fase di runtime. Wie im Kommentar der Methode angegeben, wurde das Objekt ausgewählt MovieClip anstelle der einfachen Sprite , weil es nicht erlaubt das Hinzufügen Eigenschaften oder Methoden zur Laufzeit.
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 . Nach dem Erstellen der MovieClip ist eine spezielle Funktion namens drawPlayer() die Aufgabe, die hat MovieClip Sie gerade erstellt eine Last von Spielern (the box "Kreis" oder "Zahl"), nach dem zweiten Parameter in den Eingängen geleitet.

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

/ **
* Zeichne einen Kreis oder ein Kreuz je nach Spieler
*
* @ Param (Movieclip) w = wo ziehen die MovieClip
* @ Param (uint) pl = Anzahl der Spieler: 1 oder 2 bis 0, wenn Sie ein Rechteck zeichnen abzufangen das Click-Ereignis
* /
drawPlayer ( p : MovieClip , pl : uint ) : void { drawPlayer private Funktion (p: MovieClip , pl: uint ): void {
pl ) { switch (pl) {
/ / Dies ist ein spezieller Fall: ein Rechteck gezeichnet wird
/ / Wird verwendet, um mit der Maus klicken zu erkennen
: case 0:
p . graphics ) { mit (S. Grafik) {
; 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 ; S. useHandCursor = p. buttonMode = true;
/ / Fügen Sie das Click-Ereignis dieser Box
( MouseEvent . CLICK , onCellClick ) ; S. addEventListener ( MouseEvent CLICK, onCellClick.);
break;
/ / Spieler 1 (oder)
: Fall 1:
p . graphics ) { mit (S. Grafik) {
; clear ();
PLAYER_LINE_WIDTH , PLAYER_1_COLOR ) ; lineStyle (PLAYER_LINE_WIDTH, PLAYER_1_COLOR);
30 , 30 , 30 ) ; drawCircle (30, 30, 30);
}
= p . buttonMode = false ; S. useHandCursor = p. buttonMode = false;
/ / Entfernen Sie das Click-Ereignis dieser Box
( MouseEvent . CLICK , onCellClick ) ; S. removeEventListener ( MouseEvent CLICK, onCellClick.);
break;
/ / Spieler 2 (x)
: Fall 2:
p . graphics ) { mit (S. Grafik) {
; 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 ; S. useHandCursor = p. buttonMode = false;
/ / Entfernen Sie das Click-Ereignis dieser Box
( MouseEvent . CLICK , onCellClick ) ; S. removeEventListener ( MouseEvent CLICK, onCellClick.);
break;
}
}

Der case 0 entspricht dem leeren Kasten. : Dieser Zustand tritt auf, wenn die Initialisierung des Spiels: In der Tat sehen den Anruf zu drawPlayer() -Methode in createGrid() :

1	0 ) ; drawPlayer (tm, 0);

In diesem Zustand der Box ist bereit, auf Benutzereingaben zu reagieren. In der Tat ist ein Listener hinzugefügt, um den Maus-Klick Falle. Beachten Sie, dass, wenn gezeichnet einer von zwei Spielern (Fall 1 und 2, Spieler "Kreis" und "Kreuz"), den Hörer einfach entfernt wird, so dass ein "Double-Play" zu vermeiden!

Events

Wie wir oben gesehen haben, reagiert der "leeren" auf Mausklicks:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

/ **
* Diese Veranstaltung wird freigegeben, wenn Sie auf eine Zelle Spiel klicken
* /
onCellClick ( e : MouseEvent = null ) : void { onCellClick private function (e: MouseEvent = null): void {
/ / Sicherstellen, dass das Spiel nicht pausiert oder gestoppt
! __stop ) { if (! __stop) {
/ / Erhöhe den Zähler Klicks
__clickNumber + +;
/ / Holt den Zeiger auf die Spieler "angeklickt"
MovieClip = e . currentTarget as MovieClip ; var p: MovieClip = und currentTarget wie. MovieClip ;
/ / Drawing (o) oder (x)
__player ) ; drawPlayer (p, __player);
/ / Play spiegelt die Linear-Array
_index ] = ( __player== 1 ) ? PLAYER_1_WIN : PLAYER_2_WIN ; __cell [S. _index] = (__player == 1) PLAYER_1_WIN: PLAYER_2_WIN;
/ / Prüfen, ob jemand gewonnen hat
CheckCell ();
/ / Shift ändern: wenn der Spieler spielten bisher 1 verhängte die Spieler 2 und umgekehrt
) ? 2 : 1 ; __player = (__player == 1) 2: 1;?
/ / Video Signal an die neuen Spieler an der Reihe
= "PLAYER " + __player ; . turno_txt text = "Player" + __player;
}
}

Die Flagge __stop , die auf eine globale Variable innerhalb unserer Klasse entspricht, ist ein Standardverfahren, dass Sie den Status des Spiels überprüfen können. . In unserem Fall habe ich, wie das "Spiel" zu sagen __stop = false , und wie "Pause" __stop = true . Bei der Aufnahme der Veranstaltung onCellClick() , mit der Maus auf das Feld klicken, nur überprüfen, ob das Spiel "angehalten". Wenn wir erhöhen die variable spielen __clickNumber dass berücksichtigt die Anzahl der Klicks (oder spielen) durchgeführt. Das "Counter" wird es nützlich sein, später, um zu sehen, wenn alle Kästchen markiert sind.
; utilizzando sempre il meotdo drawPlayer() . Durch die Eigenschaft e.currentTarget Erholung der Zeiger auf das Feld, wo Sie klicken und fertig auf diesem Entwurf einen von zwei möglichen Zeichen ("Kreis" oder "Zahl") auf der aktiven Spieler auf angegeben __player , immer mit dem meotdo drawPlayer() . Die Zeile:

1	_index ] = ( __player== 1 ) ? PLAYER_1_WIN : PLAYER_2_WIN ; __cell [S. _index] = (__player == 1) PLAYER_1_WIN: PLAYER_2_WIN;

ist wichtig, weil sie die Wette lineare logische Array verwendet reflektiert - siehe unten - an die Gewinner eines von zwei Spielern zu bestimmen. (valore 10) indicano nell'array lineare chi ha effettuato la giocata. Die Konstanten PLAYER_1_WIN (Wert 1) und PLAYER_2_WIN (Wert 10) Linear-Array zeigen, wer die Wette.

Für weitere Informationen siehe: Undolibrary MatrixArray: eine Erweiterung der Array-Klasse

CheckCell (): The Core

Deich einen Absatz auf diese Methode, weil im Rahmen dieses Beispiels, das wahre Herz des Spiels. Die Methode checkCell() , in der Tat sehen, ob es einen Sieg von beiden Spielern:

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

/ **
* Diese Funktion prüft das Array zu sehen, ob
* Spieler gewonnen hat. Ist jedes Mal aufgerufen, ein Spieler
* Marks eine Box mit einem (x) oder (o).
* Auch, wenn die Variable gleich 9 __clickNumber bedeutet
* Dass alle Felder ausgefüllt sind und, da es keine
* Sieger, gewann niemand!
*
* @ Private
* /
checkCell ( ) : void { private function CheckCell (): void {
/ / Auf der Grundlage der Wert __player gesetzt
/ / Check-Wert in einen Sieg zu gewährleisten
uint = ( __player== 1 ) ? 3 * PLAYER_1_WIN : 3 * PLAYER_2_WIN ; var winValue: uint = (__player == 1) PLAYER_1_WIN * 3: * 3 PLAYER_2_WIN;
/ / Überprüfen Sie alle Zeilen, Spalten und Diagonalen
: Array = __cell ; var c: Array = __cell;
/ / Überprüfen Sie die ersten 3 Zeilen
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 | |
/ / Die 3 Säulen
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 | |
/ / Die 2 diagonal
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) {
/ / Wenn eine dieser Bedingungen überprüft
/ / Jemand hat gewonnen, und dann zeigen die Platte
/ / Von "Sieg" (1)
) ; showPanel (1);
{ Else {}
/ / Wenn niemand hat gewonnen, wenn Sie überprüfen alle Boxen
/ / Sind gefüllt. Wenn dem so ist, zeigen die Platte
/ / Ende des Spiels und "keine Gewinner" (0)
__clickNumber == 9 ) { if (__clickNumber == 9) {
) ; showPanel (0);
}
}
}

Die Methode, in seiner Einfachheit, spricht für sich. Es ist für jeden Klick auf das Brett über das Schicksal des Spiels aufgerufen! Die Logik-Array wird benutzt, um "add" Zeilen, Spalten und Diagonalen auf der Suche nach einem möglichen "Tris" von der aktuellen Spieler, die Variable angegeben __player . Darüber, wie kann es passieren, __clickNumber berücksichtigt die Klicks gemacht. Diese Variable sollte niemals erreichen den Wert 9, es sei denn keiner der Spieler gewonnen hat.

Nächstes Mal werden wir einige Besonderheiten der Sprache Actionscript 3.0 in dieser Demo verwendet.