Share
Hallo Freunde. Das wichtigste Highlight dieses Tutorials ist genau Treffererkennung eines generierten Lasers. Diese Art von KI ist nützlich, um Action-Spiele zu erstellen, insbesondere im Falle von Sicherheitsinformationen mit Kameras, Laserpistolen usw. Setzen Sie Ihre Rakete auf den Rücken, und der Countdown beginnt?
Werfen wir einen Blick auf das Endergebnis, auf das wir hinarbeiten:
Öffnen Sie Flash und erstellen Sie ein neues Flash-Dokument (ActionScript 3.0)..
Stellen Sie die Bühnengröße auf eine beliebige Standardauflösung ein. Mein ist 500 x 350 px.
Stellen Sie die Bildrate auf 24 fps ein.
Speichern Sie die Datei in einem Ordner Ihrer Wahl.
Lassen Sie uns nun einen Lasergenerator erstellen.
Zeichnen Sie einen Kreis mit Radius 20, d.h..
Nun müssen wir diesen Kreis in ein Flash-Symbol konvertieren, damit wir ihn mit ActionScript steuern können.
Wählen Sie den Kreis und drücken Sie F8 oder gehen Sie zu Ändern> In Symbol konvertieren. Wählen Sie Movie-Clip als Symboltyp aus. Stellen Sie auch den Registrierungspunkt auf Mitte ein, damit sich der Lasergenerator von seiner Mitte aus dreht. Art laserGenerator_MC in das Instanzennamensfeld ein und klicken Sie anschließend in der Gruppe "Erweitert" auf "Export für ActionScript", damit wir auf den Lasergenerator aus unserer Dokumentenklasse zugreifen können, die wir bald treffen werden.
Nachdem Sie alle obigen Optionen eingestellt haben, drücken Sie OK. Drücken Sie erneut OK, um das Dialogfeld mit der Warnung für die Klassendefinition anzuzeigen. Dadurch wird zur Laufzeit eine Klassendefinition für den Lasergenerator erstellt.
Jetzt brauchen wir nicht laserGenerator_MC Symbol auf der Bühne, da es im Bibliotheksfenster mit dem Bezeichnernamen verfügbar ist laserGenerator_MC. Löschen Sie deshalb dieses Symbol von der Bühne. Deine Bühne sollte jetzt leer sein.
Nun werden wir diesem Generator einen Mund hinzufügen, um das Gefühl eines Gerätes zu erzeugen. Doppelklicken Sie im Bibliotheksfenster auf laserGenerator_MC Symbolsymbol (linke Seite des Symbolnamens), um in den Bearbeitungsmodus zu wechseln. Fügen Sie den Mund hinzu, wie unten gezeigt.
Fühlen Sie sich frei, Ihr eigenes Design hinzuzufügen.
Hinweis: Ändern Sie nicht die Position des Kreises, da wir ihn um seine Mitte drehen müssen.
Nachdem Sie dem Generator einen Mund hinzugefügt haben, verlassen Sie den Symbolbearbeitungsmodus und kehren Sie zur Hauptzeitleiste zurück.
Ihre Rakete hat den Boden verlassen. Der Lasergenerator ist bereit und wartet auf seine Ausführung.
Um unserer Szene ein Drama hinzuzufügen, benötigen wir ActionScript. Um klug zu handeln, brauchen wir eine Dokumentenklasse.
In diesem Schritt erstellen wir eine Grundstruktur unserer Dokumentenklasse.
Ausführliche Informationen zu Document Class finden Sie in diesem Quick Tip.
Erstellen Sie also eine neue ActionScript 3.0-Datei. Geben Sie den folgenden Code ein:
Paket öffentliche Klasse Laser_HitDetection öffentliche Funktion Laser_HitDetection () // Konstruktorcode
Speichern Sie diese Dokumentenklasse als Laser_HitDetection.as im selben Ordner, in dem Sie Ihre FLA für dieses Tutorial gespeichert haben. Nizza abheben. Ihre Basisdokumentklasse ist fertig.
Greifen Sie in Ihrer FLA-Datei auf das Eigenschaftenfenster des Dokuments zu und geben Sie den Namen der Klasse in das Feld "Dokumentklasse" ein, das in der Gruppe "Veröffentlichen" verfügbar ist.
Jetzt können wir mit FLA darüber kommunizieren Laser_HitDetection.as Dokumentenklasse.
Wir erstellen eine Instanz eines Lasergenerators aus der Bibliothek und platzieren sie in der Mitte der Bühne.
Modifiziere den Laser_HitDetection.as Dokumentenklasse wie unten gezeigt (hervorgehobene Zeilen):
package import flash.display.Sprite; public class Laser_HitDetection erweitert Sprite var laserGun: Sprite; // Instanz von laserGenerator_MC // Konstruktor public function Laser_HitDetection () CreateLaserGun (); // Holen Sie sich den Lasergenerator aus der öffentlichen Public Library-Funktion CreateLaserGun (): void laserGun = new laserGenerator_MC (); // Holen Sie es aus der Bibliothek addChild (laserGun); // Platziere den Lasergenerator in der Mitte der Bühne laserGun.x = stage.stageWidth / 2; laserGun.y = stage.stageHeight / 2;
Wenn Sie den Film jetzt testen, sehen Sie unsere Laserpistole in der Mitte der Bühne.
Accentsconagua
CreateLaserGun () MethodeIm obigen Code haben wir verwendet Sprite Klasse, um eine Instanz eines Sprite-Objekts zu erstellen, das den Laser aufnehmen kann. Dafür deklarieren wir Variable als:
var laserGun: Sprite;
Dann haben wir eine neue Methode hinzugefügt "CreateLaserGun ()"in dem wir eine Instanz von laserGenerator_MC von der Bibliothek bis zu den oben genannten Laserpistole var als:
laserGun = new laserGenerator_MC ();
Nachdem wir es zur Bühne hinzugefügt hatten, platzierten wir es in der Mitte der Bühne als:
laserGun.x = stage.stageWidth / 2; laserGun.y = stage.stageHeight / 2;
Schließlich haben wir diese Methode aus der Konstruktormethode der Dokumentklasse aufgerufen:
// Konstruktor public function Laser_HitDetection () CreateLaserGun ();
Rakete beschleunigt mit vollem Schub. Wir werden diese Laserpistole sehr bald aktivieren, wodurch der Laser projiziert wird. Davor werden wir einige Hindernisse hinzufügen. Lass uns gehen.
Um mit der Treffererkennung zu experimentieren, benötigen wir einige Hindernisse auf der Bühne. Zeichnen Sie also auf der Bühne verschiedene Formen, die konvex-konkaven Flächen, Steigungsklettern und geraden Kanten ähneln, wie unten gezeigt:
Jetzt werden wir alle diese Formen in ein Symbol setzen. Wählen Sie alle Formen gleichzeitig aus und drücken Sie F8 oder gehen Sie zu Ändern> In Symbol konvertieren. Wählen Sie als Symboltyp Movie Clip aus. Nennen Sie dieses Symbol Hindernisse_MC im Namenstextfeld. Stellen Sie den Registrierungspunkt in der Mitte ein. Aktivieren Sie auch "Export für ActionScript", damit wir von unserer Dokumentenklasse aus darauf zugreifen können.
Nach dem Konvertieren in MovieClip haben wir Hindernisse_MC in der Bibliothek mit dem gleichen Bezeichnernamen. Gleichsam als laserGenerator_MC Wir brauchen dieses Symbol nicht auf der Bühne, löschen Sie es also von der Bühne. Jetzt ist deine Bühne leer.
Die Art, wie wir unsere platziert haben laserGenerator_MC auf der bühne, in der mitte, werden wir ähnlich platzieren Hindernisse_MC Symbol auf der Bühne. Ändern Sie die Dokumentenklasse wie folgt:
package import flash.display.Sprite; public class Laser_HitDetection erweitert Sprite var laserGun: Sprite; // Instanz von laserGenerator_MC var Hindernisse: Sprite; // Instanz von obstacles_MC // Konstruktor öffentliche Funktion Laser_HitDetection () CreateLaserGun (); CreateObstacles (); // Holen Sie sich den Lasergenerator aus der öffentlichen Public Library-Funktion CreateLaserGun (): void laserGun = new laserGenerator_MC (); // Holen Sie es aus der Bibliothek addChild (laserGun); // Platziere den Lasergenerator in der Mitte der Bühne laserGun.x = stage.stageWidth / 2; laserGun.y = stage.stageHeight / 2; // Hole und stelle Hindernisse von der öffentlichen Bibliotheksfunktion CreateObstacles (): void hindacles = new obstacles_MC (); // Holen Sie es aus der Bibliothek addChild (Hindernisse); // Platziere Hindernisse in der Mitte der Bühnenhindernisse.x = stage.stageWidth / 2; Hindernisse.y = stage.stageHeight / 2;
Testen Sie den Film, um Hindernisse um die Laserpistole zu sehen.
Ihre Rakete erreicht die Endgeschwindigkeit. Jetzt ist es Zeit, die Laserpistole zu aktivieren. Es muss den Laser daraus erzeugen. Lass uns das jetzt machen.
Wie werden wir den Laser nachahmen? Irgendwelche Ideen?? Wie wäre es mit einigen Mitgliedern der Graphics-Klasse? lineStyle (), ziehen nach(), lineTo (). Wenn Sie mit diesen Methoden vertraut sind, ist Ihre Arbeit einfach. Für diejenigen, die diese Methoden nicht kennen, sind wir immer bei Ihnen. Lassen Sie uns sie im Detail sehen.
Wir werden eine neue Methode hinzufügen Projektlaser (). Lassen Sie uns unser ändern Laser_HitDetection Dokumentenklasse wie folgt:
// Konstruktorpaket import flash.display.Sprite; public class Laser_HitDetection erweitert Sprite var laserGun: Sprite; // Instanz von laserGenerator_MC var Hindernisse: Sprite; // Instanz von Hindernissen_MC var laser: Sprite; var startX: Anzahl; // x Startpunkt des Lasers var startY: Number; // y Startpunkt des Lasers var endX: Number; // x Endpunkt des Lasers var endY: Number; // y Endpunkt des Lasers // Konstruktor öffentliche Funktion Laser_HitDetection () CreateLaserGun (); CreateObstacles (); Projektlaser (); // Holen Sie sich den Lasergenerator aus der öffentlichen Public Library-Funktion CreateLaserGun (): void laserGun = new laserGenerator_MC (); // Holen Sie es aus der Bibliothek addChild (laserGun); // Platziere den Lasergenerator in der Mitte der Bühne laserGun.x = stage.stageWidth / 2; laserGun.y = stage.stageHeight / 2; // Hole und stelle Hindernisse von der öffentlichen Bibliotheksfunktion CreateObstacles (): void hindacles = new obstacles_MC (); // Holen Sie es aus der Bibliothek addChild (Hindernisse); // Platziere Hindernisse in der Mitte der Bühnenhindernisse.x = stage.stageWidth / 2; Hindernisse.y = stage.stageHeight / 2; // Projiziere einen Laser von einer öffentlichen Lasergenerator-Funktion aus ProjectLaser (): void laser = new Sprite (); addChild (Laser); // Ursprung des Lasers als Mittelpunkt der Laserpistole setzen startX = laserGun.x; startY = laserGun.y; // Endpunkt des Lasers einstellen endX = startX + 230; endY = startY; // Zeichne laser laser.graphics.lineStyle (1, 0xFF0000); laser.graphics.moveTo (startX, startY); lasergraphics.lineTo (endX, endY);
Testen Sie den Film.
Die Rakete steht ganz oben am Himmel. Die Laserpistole hat begonnen, den Laser zu projizieren. Wie ist das passiert? Versuchen wir, den obigen Code im nächsten Schritt zu verstehen.
Im obigen Schritt haben wir erfolgreich einen Laser projiziert. Dafür haben wir folgende Aufgaben ausgeführt:
Zuerst haben wir fünf neue Variablen deklariert:
Var-Laser: Sprite; var startX: Anzahl; // x Startpunkt des Lasers var startY: Number; // y Startpunkt des Lasers var endX: Number; // x Endpunkt des Lasers var endY: Number; // y Endpunkt des Lasers
Zweitens haben wir eine neue Methode hinzugefügt Projektlaser ():
öffentliche Funktion ProjectLaser (): void laser = new Sprite (); addChild (Laser); // Ursprung des Lasers als Mittelpunkt der Laserpistole setzen startX = laserGun.x; startY = laserGun.y; // Endpunkt des Lasers einstellen endX = startX + 230; endY = startY; // Zeichne laser laser.graphics.lineStyle (1, 0xFF0000); laser.graphics.moveTo (startX, startY); lasergraphics.lineTo (endX, endY);
Projektlaser () MethodeIn der obigen Methode haben wir zunächst ein leeres Sprite-Objekt zum Halten des Lasers erstellt und es wie folgt zur Bühne hinzugefügt:
Laser = neues Sprite (); addChild (Laser);
Da wir wollten, dass der Laser von der Laserpistole aus projiziert, weisen wir den X-Wert der Laserpistole zu startX und Y-Wert zu startY Wie nachfolgend dargestellt:
startX = laserGun.x; startY = laserGun.y;
(Später haben wir diese Werte zur Verfügung gestellt moveTo (startX, startY) Methode, die wir bald treffen werden.)
Dann haben wir definiert endX und endY:
endX = startX + 230; endY = startY;
Werte, die den obigen Variablen zugewiesen wurden, sind temporäre Werte. Wir haben sie nur verwendet, um die grundlegende Projektion eines Lasers zu zeigen. In den nächsten Schritten werden wir diese Werte durch einfache Berechnungen ändern. Diese Werte sind der Schlüssel für eine perfekte Treffererkennung des Lasers. Wir werden sie später in dieser Sitzung studieren.
Und jetzt der wichtige Teil dieser Methode. Zeichnen einer geraden Linie in einem Laser-Sprite-Objekt, um den projizierten Laser zu imitieren.
Zuerst haben wir den Stil der zu zeichnenden Linie wie folgt behandelt:
laser.graphics.lineStyle (1, 0xFF0000);
Diese lineStyle () -Methode wird verwendet, um die Gestaltung des Strichs des Zeichnungsobjekts wie Linie, Rechteck, Oval usw. zu steuern. Sie können maximal acht Argumente für diese Methode angeben. Wenn nicht angegeben, werden stattdessen Standardwerte zugewiesen. Für unser Beispiel benötigen wir nur zwei Argumente. Das erste Argument ist die Dicke der Linie (d. H. 1) und das zweite Argument ist die Farbe der Linie (d. H. 0xFF0000, was ist rot).
Ausführliche Informationen zu dieser Methode finden Sie in der Adobe-Hilfe unter "lineStyle (args?)".
Dann haben wir den Startpunkt der Linie wie folgt platziert:
laser.graphics.moveTo (startX, startY);
startX und startY stellt sicher, dass der Startpunkt die Mitte der Laserpistole sein muss.
Danach haben wir die Zeile aufgearbeitet:
lasergraphics.lineTo (endX, endY);
Denken Sie daran, dass diese endX und endY temporäre Werte sind, nur um die Projektion anzuzeigen. Wir müssen sie anpassen, wenn sich ein Hindernis im Weg des Lasers befindet. Wir werden das in den nächsten Schritten rechnen.
Also haben wir eine Linie aus (startX, startY) an (endX, endY).
Die Rakete geht und geht. Sehen Sie diese Landschaften, Wasserlandschaften?
Nun ist es Zeit für die wirkliche Aktion. Treffererkennung mit Hindernissen.
Jetzt sind wir mit einer Laserpistole ausgestattet. Wir haben auch mehrere Hindernisse. Wir sind auf der Ebene, wo wir eine Treffererkennung hinzufügen können, die der Szene sicherlich die Bedeutung verleiht.
Möglicherweise denken Sie, dass diese hochgenaue Treffererkennung komplexe Berechnungen erfordert. Wenn ja, dann liegen Sie falsch. Es verwendet einfach die in ActionScript eingebaute hitTestPoint () - Methode zusammen mit einer zum Schleife. Die komplexe Mathematik hinter der perfekten Treffererkennung wird mit dieser Methode behandelt. Sie müssen nur diese Methode verwenden und a zum Schleife auf intelligente Weise.
Wir werden einige wichtige Änderungen an unserer Dokumentenklasse vornehmen, hauptsächlich in Projektlaser () Methode und einige neue Vars, so beobachten und sorgfältig anwenden. Lassen Sie uns es wie gezeigt ändern:
Fügen Sie zuerst diese neuen Variablen hinzu:
var rad: Zahl = Math.PI / 180; // Wird zur Berechnung des Winkels im Bogenmaß verwendet var maxDist: Number = 250; // maximale Entfernung, die der Laser zurücklegen soll var varistedist: Anzahl; // Neue maximale Entfernung, wenn ein Hindernis in eine Richtung kommt
Dann ändern Projektlaser () Methode durch Hinzufügen zum Schleife wie unten gezeigt (auch das jetzt beachten endX und endY sind drinnen zum Schleife):
// Projiziere einen Laser vom Lasergenerator-Gerät aus public function ProjectLaser (): void laser = new Sprite (); addChild (Laser); // Ursprung des Lasers als Mittelpunkt der Laserpistole setzen startX = laserGun.x; startY = laserGun.y; für (adjustedDist = 0; adjustDist < maxDist; adjustedDist ++) //Trigonometry to aim the laser w.r.t laser gun's rotation endX = laserGun.x + Math.cos ( laserGun.rotation * rad ) * adjustedDist; endY = laserGun.y + Math.sin ( laserGun.rotation * rad ) * adjustedDist; //calculate hit test if ( obstacles.hitTestPoint ( endX, endY, true ) ) break; //Draw laser laser.graphics.lineStyle( 1, 0 x FF0000 ); laser.graphics.moveTo( startX, startY ); laser.graphics.lineTo ( endX, endY );
Testen Sie den Film.
Boom? Ich bin mir sicher. Mit diesem Effekt können Sie ein Flash-Spiel mit Sicherheitsintelligenz erstellen. Perfekte KI, um ein interessantes Spiel in Flash zu entwickeln.
Zunächst haben wir unserer Dokumentklasse neue Variablen hinzugefügt (siehe Abbildung):
Anfangs ein Winkel im Bogenmaß
var rad: Zahl = Math.PI / 180; // Wird verwendet, um den Winkel im Bogenmaß zu berechnen
Die obige Variable wird in der Formel verwendet, um einen Winkel im Bogenmaß zu berechnen.
Die Formel lautet, Bogenmaß = Grad * Math.PI / 180. Mehr Infos hier. Wir haben diese Formel in unserem Code in den folgenden Zeilen verwendet:
endX = laserGun.x + Math.cos (laserGun.rotation * rad) * adjustDist; endY = laserGun.y + Math.sin (laserGun.rotation * rad) * adjustDist;
Im laserGun.rotation * rad, grad = laserGun.rotation, und rad = Math.PI / 180.
Zweitens haben wir eine Variable für die maximale Entfernung erstellt, die der Laser zurücklegen muss:
var maxDist: Number = 250; // maximale Entfernung, die der Laser zurücklegen muss
Diese Variable bestimmt die maximale Entfernung, die der Laser zurücklegen muss. Da der Laser nicht über den sichtbaren Bereich gezogen werden muss, definieren wir einen schönen Endpunkt. Diese Var wird das tun, was benötigt wird.
Drittens haben wir eine Variation für die aktuelle Entfernung des Lasers zum Zeitpunkt der Kreuzung mit einem Hindernis.
var adjustDist: Anzahl; // Neue maximale Entfernung, wenn ein Hindernis in eine Richtung kommt
Wenn ein Hindernis auf den Weg des Lasers kommt, wird der Laser blockiert, anstatt sich in die maximale Entfernung zu bewegen.
Die Entfernung nach dem Blockieren eines Lasers ist abhängig von der Situation nichts anderes als die eingestellte Entfernung.
Das zum Schleife und hitTestPoint () Beide spielen eine wichtige Rolle bei der Berechnung dieser Entfernung.
Viertens haben wir modifiziert Projektlaser () Methode durch Hinzufügen von ActionScript hitTestPoint () zusammen mit einem zum Schleife. Wurden zugeordnet endX und endY Variablen.
für (adjustedDist = 0; adjustDist < maxDist; adjustedDist ++) //Trigonometry to aim the laser w.r.t laser gun's rotation endX = laserGun.x + Math.cos ( laserGun.rotation * rad ) * adjustedDist; endY = laserGun.y + Math.sin ( laserGun.rotation * rad ) * adjustedDist; //calculate hit test if ( obstacles.hitTestPoint ( endX, endY, true ) ) break;
Die for-Schleife stellt sicher, dass die eingestellte Entfernung bis zur maximalen Entfernung erhöht wird. Sie denken vielleicht "Was macht es Spaß, die eingestellte Entfernung gleich der maximalen Entfernung zu machen?"
Tatsächlich darf diese eingestellte Entfernung natürlich mit der maximalen Entfernung übereinstimmen, aber sobald sie auf Hindernisse trifft (die von erkannt werden) hitTestPoint () Methode) Diese Entfernung wird als maximale Entfernung für die aktuelle Situation markiert. Dank an hitTestPoint () um die Aufgabe so einfach zu machen.
Wir haben auch neu zugewiesen endX und endY Werte als:
endX = laserGun.x + Math.cos (laserGun.rotation * rad) * adjustDist; endY = laserGun.y + Math.sin (laserGun.rotation * rad) * adjustDist;
Die Trigonometrie-Funktionen Math.cos () und Math.sin () werden verwendet, um den Winkel des Lasers bei der Rotation der Laserkanone zu berechnen.
In einer einfachen Form sorgt es dafür, dass der Laser auf die Laserpistole gerichtet wird. Es ist wichtig, dass Laserpistole und Laser synchron sind. Immer wenn die Laserpistole gedreht wird, folgt der Laser der Rotation.
Weitere Informationen zur Trigonometrie finden Sie in diesem Quick Tip.
Endlich der Höhepunkt der Szene:
if (obstacles.hitTestPoint (endX, endY, true)) break;
hitTestPoint () Methode nimmt drei Parameter, von denen der erste und der zweite Parameter notwendig sind und der dritte (shapeFlag) wird als Standardeinstellung beibehalten (d. h. falsch) falls nicht angegeben.
In unserem Beispiel, shapeFlag ist eingestellt auf wahr da wir eine Treffererkennung in Bezug auf die genaue Form des Zielobjekts (d. h. Hindernisse). Wenn dieser Wert auf gesetzt ist falsch Die Treffererkennung erfolgt in Bezug auf den Begrenzungsrahmen dieses Objekts und nicht auf die genaue Form.
Der erste und der zweite Parameter von hitTestPoint () Definieren Sie einen Punkt (x, y), an dem der Schnittpunkt mit dem Anzeigeobjekt überprüft werden soll. In unserem Fall Hindernisse ist das Anzeigeobjekt und endX und endY repräsentiert den Schnittpunkt auf der Bühne.
Unklar? Recht. Zur Vereinfachung setzen wir die Logik wie folgt zusammen:
zum Schleife ermöglicht die Fortsetzung der Projektion des Lasers (durch Aktualisieren endX und endY) wenn innerhalb der maximalen Entfernung.hitTestPoint () wartet darauf, das zu brechen zum Schleife, sobald es die Kreuzung sieht. Einmal die zum Schleife ist gebrochen, endX und endY sind eingefroren.endX und endY sind an die übergeben graphics.lineTo () Methode.Um der Laserpistole Rotation hinzuzufügen, müssen wir einige wichtige Änderungen vornehmen:
Projektlaser () Methode.HitTest ().laser.graphics.clear () in dem zum Schleife.importiere flash.events.Event Zuerst werden wir das restrukturieren Projektlaser () Methode durch Verschieben der gesamten Treffererkennungslogik in der neuen Methode HitTest ().
Dann werden wir hinzufügen laser.graphics.clear () Aussage vor laser.graphics.lineStyle (1, 0xFF0000) Aussage innerhalb der zum Schleife der neuen Methode HitTest (). Dadurch wird die alte Projektion des Lasers von der Bühne entfernt, wenn sich die Laserpistole dreht.
Mal sehen, wie es nach allen vier großen Änderungen aussehen wird:
öffentliche Funktion ProjectLaser (): void laser = new Sprite (); addChild (Laser); // Ursprung des Lasers als Mittelpunkt der Laserpistole setzen startX = laserGun.x; startY = laserGun.y; // Hit test public function HitTest (): void for (adjustedist = 0; adjustedist) < maxDist; adjustedDist ++) //Trigonometry to aim the laser w.r.t laser gun's rotation endX = laserGun.x + Math.cos(laserGun.rotation * rad) * adjustedDist; endY = laserGun.y + Math.sin(laserGun.rotation * rad) * adjustedDist; //calculate hit test if (obstacles.hitTestPoint(endX,endY,true)) break; //Draw laser laser.graphics.clear(); //Removes the old laser projection laser.graphics.lineStyle( 1, 0xFF0000 ); laser.graphics.moveTo( startX, startY ); laser.graphics.lineTo ( endX, endY );
Sie fragen sich vielleicht, warum wir so große Veränderungen vorgenommen haben? Der einzige Grund ist ENTER_FRAME Veranstaltung.
Um eine kontinuierliche Rotation anzuwenden, fügen wir eine neue Methode hinzu, LaserGunRotation (evt: Event) welches von aktiviert wird ENTER_FRAME Ereignis (dh es wird 24 Mal pro Sekunde ausgeführt, da unsere Bildrate 24 Bilder pro Sekunde beträgt). Wenn dieses Ereignis verwendet wird, müssen Sie nur solche Eigenschaften hinzufügen, die Sie über einen bestimmten Zeitraum ändern möchten. Vermeiden Sie es, die Werte einzugeben, die während der Ausführung konstant bleiben.
In unserem Fall, wenn Sie alt beobachten Projektlaser () Methode hat es:
Laser = neues Sprite (); addChild (Laser); // Laserpistole drehen
Stellen Sie sich vor, Sie fügen obige Anweisungen in einer Methode ein, die verwendet ENTER_FRAME Veranstaltung; Dann wird ein neues Laser-Sprite-Objekt erstellt und wiederholt zur Bühne hinzugefügt - 24 Mal pro Sekunde.
Das ist absolut unnötig. Deshalb haben wir umstrukturiert Projektlaser () Methode und neue Methode hinzugefügt HitTest (). Sie können umbenennen Projektlaser () Methode zu InitializeLaser () da projiziert der laser nicht mehr. Jetzt wird nur noch die leere Halterung für den Laser erstellt und der Startpunkt festgelegt. Die Projektion wird in einer neuen Methode behandelt, HitTest ().
Nun sehen wir uns die neue Methode an LaserGunRotation (evt: Event). Fügen Sie zuvor die folgende Importanweisung am Anfang der Dokumentenklasse hinzu:
import flash.events.Event;
Fügen Sie die folgende Methode hinzu:
// Rotate Laser Gun öffentliche Funktion LaserGunRotation (evt: Event): void laserGun.rotation + = 0.5; HitTest ();
Vergessen Sie auch nicht, diese Methode mit einem ENTER_FRAME Ereignis innerhalb des Konstruktors funktioniert wie folgt:
// Konstruktor public function Laser_HitDetection () CreateLaserGun (); CreateObstacles (); Projektlaser (); addEventListener (Event.ENTER_FRAME, LaserGunRotation);
Damit wird es eingerichtet, das auszuführen LaserGunRotation () Funktion 24 mal pro Sekunde.
Testen Sie den Film.
Die Rakete ist bereits in Wolken eingedrungen. Sehen Sie die schöne Erde.
In diesem Schritt fügen wir ein Steuerelement hinzu, um die Genauigkeit der Treffererkennung anzupassen. Dies ist wichtig, da Sie nicht jedes Mal die genaue Treffererkennung benötigen. Möglicherweise benötigen Sie eine durchschnittliche Treffererkennung. Dies hilft auch, den CPU-Verbrauch zum Zeitpunkt der Treffererkennung zu reduzieren.
Wir werden eine neue Variable einführen Toleranz wie:
Var Toleranz: Anzahl = 1;
Dann werden wir das ändern zum Inkrement-Anweisung der Schleife als:
für (adjustedDist = 0; adjustDist < maxDist; adjustedDist += tolerance)
Nun sieht die for-Schleife so aus:
für (adjustedDist = 0; adjustDist < maxDist; adjustedDist += tolerance) //Trigonometry to aim the laser w.r.t laser gun's rotation endX = laserGun.x + Math.cos(laserGun.rotation * rad) * adjustedDist; endY = laserGun.y + Math.sin(laserGun.rotation * rad) * adjustedDist; //calculate hit test if (obstacles.hitTestPoint(endX,endY,true)) break;
Das bedeutet, dass wir nicht bei jedem Pixel der Laserlinie nach einer Kollision suchen, sondern nur bei jedem zweiten Pixel oder jedem dritten Pixel usw. auf eine Kollision.
Wenn Sie den Wert für "Toleranz" verringern, wird die Genauigkeit der Treffererkennung erhöht, es wird jedoch mehr CPU-Leistung benötigt. Versuchen Sie, mit verschiedenen Werten für "Toleranz" zu experimentieren.
Freunde, es ist Zeit, die Rakete zu verlassen und den Fallschirm zu öffnen. Landen Sie sicher auf dem Boden und verwenden Sie die oben genannte Technik in Ihren Flash-Spielen und Anwendungen. Genießen!
In diesem Tutorial haben wir hauptsächlich die perfekte Verwendung von gesehen hitTestPoint () und ein zum Schleife, um eine genaue Treffererkennung ohne komplexe Berechnungen zu erstellen.
Dieser Effekt kann in einem Sicherheitsspiel verwendet werden, bei dem Kameras und Laserpistolen benötigt werden.
