Verwenden Sie Kollektionen, Schaukeln, Themen und andere Wissenspunkte in der Java -Sprache, um ein Panzerkriegsspiel zu schreiben.
(1) Zeichnen Sie das Prinzip des Feindes und der US -Panzer:
In der Tankklasse befindet sich ein boolescher Variabler gut. Früher, um das Lager eines Panzers zu beurteilen. Beim Erstellen eines Tankobjekts wird der Wert des Guten in die Konstruktionsmethode der Panzerklasse weitergegeben. Beurteilen Sie beim Zeichnen von Panzern den Wert des Guten und unterscheiden Sie die Farbe des Feindes und uns;
(2) Prinzip der Panzerbewegung:
Das Antwortereignis der Tastatur der Monitor -Tastatur ist in der Tankklasse geschrieben, die überwachten, nach oben, linken und rechten Tasten werden aufgezeichnet, und Variablen in acht Richtungen der Tankbewegung werden synthetisiert. Anschließend können die entsprechenden Änderungen an den Werten des Tanks x und y in jede Richtung koordiniert, um die Bewegung unseres Tanks zu erreichen. Die feindlichen Panzer bewegen sich automatisch, zirkulieren zufällig die Richtung der Bewegung des feindlichen Panzers durch eine Zufallszahl und geben zufällig die Anzahl der Zeiten jeder Bewegung aus. Die Kombination von zwei zufälligen Werten ermöglicht die Bewegung feindlicher Panzer.
(3) Prinzip der Tank -Start -Kugeln:
Fügen Sie durch die Tastaturüberwachung nach Erkennung des Bullet-Fire-Befehls eine Kugelklasse zur Kollektion der Hauptklasse hinzu. Übertragen Sie die Richtung des Waffenfasss, die Position des Panzers und das Lager des Panzers in die Kugeln. In der Hauptlackierungsmethode wird die Bullet -Sammlung gefahren. Wenn es im Set Kugeln gibt, ziehen Sie sie aus. Dies ermöglicht den Start von Kugeln.
(4) Das Kollisionsprinzip von Panzern, Kugeln und Wänden:
In der Tank-Bullet-Wandklasse vom Typ GetRect-Methode, um einen eigenen Bereich zu erhalten und dann jedes Mal, wenn der Tank und die Kugel gezogen werden, entsprechende Kollisionserkennung durchzuführen (es gibt Methoden zur Kollision mit der Wand und dem Tank außerhalb des Tanks im Tank und in der Kugel, kollisionsmodell mit der Wand und dem Tank.). Wenn der Bereich von sich selbst und dem Objekt, das nicht kollidiert werden sollte, bedeutet, dass die beiden Objekte kollidieren.
(5) Das Prinzip der Panzerblutung:
Wenn die Blutgerinnsel mit unserem Tank kollidieren, sterben die Blutgerinnsel und die Blutgerinnsel werden vollständig erholt.
(6) Das Prinzip der Tankauferstehung:
Nachdem die Auferstehungsreihenfolge unseres Tanks durch Tastaturüberwachung erkannt wurde, wird unser Tank -Inventarstatus in einem toten Zustand in lebendig und das Blutvolumen unseres Tanks auf volle Gesundheit wiederhergestellt.
Programmierideen:
Die Programmierungsidee des Panzerkrieges öffnet einen Faden in der Hauptklasse und fährt nicht bei 50 Millisekunden, um die Methode zu zeichnen (alles in der gesamten Schnittstelle zeichnen). Zu den gezogenen Dingen gehören feindliche Panzer (Farbunterscheidung), Kugeln, Wände, Blutgerinnsel und Explosionen. Insgesamt wurden also mehrere Kategorien geschrieben: Tankpanzer, Raketenkugeln, Wandwände, Blutgerinnsel und Hauptklassen Tankclient. In jeder Klasse wird eine Zeichenmethode geschrieben, um die Zeichenfunktion der Attribute dieser Klasse zu realisieren. In der Hauptklasse namens Tastaturhörereignis dieser Tankklasse gibt es ein Tastatur -Hörereignis. Durch die Überwachung der Tastatur wird festgestellt, dass die entsprechende Bewegung des Panzers durchgeführt wird, während sich der feindliche Panzer zufällig bewegt. Und jedes Mal, wenn die Aktualisierung der Aktualisierung erstellt wird, werden verschiedene Kollisionsmethoden aufgerufen, um die Situation einiger Objekte zu bestimmen, mit denen nicht kollidiert werden sollte. Die Erstellung jedes Objekts, wie z. B. Kugeln, besteht darin, eine neue Kugelklasse zu einer Kugelklassensammlung hinzuzufügen, nachdem sie ausgelöst wurde. Bestimmen Sie beim Zeichnen die Nummer im Zeichnen. Wenn der Tank außerhalb der Grenzen ist oder den Tank tötet, wird er im Set gelöscht. Andere Kategorien sind ebenfalls ähnlich, daher werde ich nicht auf Details eingehen.
Jeder Schritt im Code hat eine entsprechende Erklärung.
Tankclient.java
Import Java.awt.Color; Import Java.awt.font; Import Java.awt.graphics; Import Java.awt.image; Import Java.awt.event.keyadapter; Java.util.ArrayList; Import Java.util.List; import Javax.swing.jframe; public class Tankclient erweitert JFrame { / ** * @param args * / image offscrennimage = null; // Doppelpufferspeicher Bildspeicher/*Spielgröße*/public static final int game_width = 800; // Width Interface Public static Final int game_hieth = 600; // High Interface Tank mytank = neuer Tank (500.400, true, color.red, Tank.Direction.stop, this); // Unsere Tankklassenliste <Rakete> missile = new ArrayList <Rakete> (); // Sammlung der Kugelnliste <Explode> exploit = new ArrayList <Explode> (); // Explosionssatzliste <Tank> Tanks = New ArrayList <Tank> (); // Tankset Wall Wall1 = neue Wand (150.200,20.300, dies); // Wand 1 Wand Wall2 = neue Wand (250.500.300,20, dies); // Wand 2 Wandwand3 = neue Wand (650.200,20.300, dies); // Wand 2 Wandwand 4 = neue Wand (250.300.300,20, dies); // Wand 2 Wand WB = neue Wand (750.550,40,40, dies); // Wall2 Blood B = neues Blut (); // Blutklasse Public static void main (String [] args) {// Todo automatisch generierte Methode Stub Tankclient tc = new TankClient (); tc.lauchframe (); } private void lauchframe () {// todo automatisch generierte Methode Stub für (int i = 0; i <10; i ++) {tanks.add (neuer Tank (50+40*(i+1), 50, false, color.blue, Tank.Direction.d, this this); } this.setLocation (100, 100); // Fenster für den ersten Koordinatenpunkt this.setSize (Game_width, Game_Heigth); // Fenster initiale Größe this.settitle ("Tankwar"); // Fenstername/*Fensteranhören*/thddwindowlistener (neuer Fensteradapter () {@Override/*Laufen Sie nach dem Punkt die Gabel*/public void WindowsClosing (windowEvent e) {// todo auto-generierter Methode Stub System.exit (0); // exit}}); this.addKeyListener (neuer Keymoniton ()); // Setzen Sie die Tastatur so ein. SetVisible (True); // das Fenster festlegen, um dies anzuzeigen. // das Fenster festlegen, um die Größe nicht zu ändern. // Setzen Sie die Fenster -Vordergrundfarbe auf grünen neuen Faden (neuer Pinnerad ()). Starten (); // Starten Sie die Painthread Class Run} @Override public void Paint (Grafik g) {// Todo automatisch generierte Methode Stub // Grafik ist die Pinselklasse Super.paint (g); mytank.draw (g); Wall1.Draw (g); Wall2.Draw (g); Wall3.Draw (g); Wall4.Draw (g); wb.draw (g); b.draw (g); mytank.eatblood (b); mytank.hitwall (wall1); mytank.hitwall (Wall2); mytank.hitwall (Wall3); mytank.hitwall (Wall4); /*Cycle Bullet Collection*/ for (int i = 0; i <missies.size (); i ++) {Rakete m = missiles.get (i); // die aktuelle Kugel M.Hittanks (Tanks) erhalten; // Ihre eigene Kugel tötet den feindlichen Panzer M.Hitwall (Wall1); // Bullet and Wall M.Hitwall (Wall2); M.Hitwall (Wall3); M.Hitwall (Wall4); M.Hittank (Mytank); // feindliche Kugel trifft seinen eigenen Panzer M.Draw (G); // Bullet} für (int i = 0; i <explore.size (); i ++) {exploit.get (i) .draw (g); // Explosion zeichnen} für (int i = 0; i <tanks.size (); i ++) {Tank t = tanks.get (i); t.draw (g); // feindliche Panzer zeichnen T.hittanks (Tanks); t.hitwall (Wall1); // Tanks und Wände T.Hitwall (Wall2); t.hitwall (Wall3); t.hitwall (Wall4); } //g.setfont(new Font ("宋体", font.bold, 20)); g.drawstring ("Raketen zählen:"+missies.size (), 10, 50); // G.Drawstring anzeigen ("Explode Count:"+explode.size (), 10, 80); // G.Drawstring ("Tanks zählen:"+tanks.size (), 10, 110); G.Drawstring ("Mytank Life:"+mytank.getLife (), 10, 130); G.Drawstring ("Blutwiederherstellung:", 750, 540); G.Drawstring ("Verzeichnisschlüsselbewegungsrichtung; E: Fertig -Movement Blood", 10, 590); g.drawstring ("z: starten dongfeng-31; a: starten dongfeng-41", 10, 570); G.Drawstring ("F2: Auferstehung; F3: Auferstehung des Feindes (zu den meisten 20)", 10, 550); G.Drawstring ("R: Positionswiederherstellung; q: voller Blut", 10, 530); } @Override /*repaint-> update-> malen* / public void update (grafik g) {// Todo automatisch generierte Methode Stub Super.update (g); if (offscrennimage == null) offscrennimage = this.createimage (game_width, game_higth); Grafik goffscrenn = offscrennimage.getGraphics (); // Setzen Sie eine Speicherpinselfarbe auf die Vordergrundbildfarbe C = goffscrenn.getColor (); // Zuerst die Vordergrundfarbe speichern, goffscrenn.setColor (color.green); // Setzen Sie die Farbe des Speicherpinsels auf Green Goffscrenn.FillRect (0, 0, Game_Width, Game_Higth); // Zeichnen Sie das Bild als Größe der Spielgröße goffscrenn.setColor (c); // die Farbe G.Drawimage (offscrennimage, 0, 0, null) wiederherstellen; // Zeichnen Sie das gespeicherte Bild auf der Schnittstellenfarbe (Goffscrenn); // Die Speicherpinsel auf malen} private Klasse Painthread implementiert runnable {@Override public void run () {// Todo automatisch generierte Methode Stub während (true) {repaint (); // Bestellung repaint-> update-> malen try {thread.sleep (50); // den Bildschirm alle 50 Millisekunden aktualisieren} catch (Ausnahme e) {e.printstacktrace (); }}}} /*Antwort Antwort* / private Klasse Keymoniton erweitert den Keyadapter { /*Drücken Sie die Tastaturantwort* / @Override public void keypressed (keyEvent e) {// toDo auto-generierter Methode Stub Super.KeyPressed (e); mytank.keypresse (e); } /*Steig die Tastaturantwort* / @Override public void keyRepest (keyEvent e) {// Todo automatisch generierter Methode Stub Super.Keyrelest (e); mytank.keyRelease (e); }}}Tank.java
Import Java.awt.Color; Import Java.awt.graphics; Import Java.awt.image; Import Java.awt.Rectangle; Import Java.awt.event.keevent; koordiniert private int oldx, Oldy; // Panzer frühere Koordinaten öffentlich statische endgültige int whith = 30; // Panzerbreite öffentliche statische endgültige int higth = 30; // Tank High Public statische endgültige int xspeed = 5; // Länge Richtungsbewegungsgeschwindigkeit öffentliche statische endgültige int yspeed = 5; // Longarogue Movement Speed Private Color; // Panzerfarbe Private boolean BL = false, bu = false, br = false, bd = false; // Vier Richtungssteuerungswerte Enum Direction {l, lu, u, ru, r, rd, d, ld, stop}; // Die Bewegung von acht Richtungen besteht aus vier Richtungswerten Private Direction Dir = Direction.stop; // Ausgangsrichtung private Richtung ptdir = Richtung.d; // Originalrichtung des Cannon Private Boolean Good; // Beurteilen Sie das Camp des Panzers privat boolean live = true; // beurteilen, ob der Panzer lebendig ist. // feindliche Tank zufällige Bewegung 3-14 Private int Life = 100; // Gesundheitsvolumen privates Blutleiste BB = neue Blutstange (); // cleck // imageicon icon = new ImageCon ("res // mytank.jpg"); // imageicon icon2 = new ImageCon ("res // fegeTank.jpg"); // Image Image = icon.getimage (); // Bild 2 = icon2.getimage (); Privat Tankclient TC; // Hauptklassenberechtigungen öffentlicher Panzer (int x, int y, boolean gut, Farbe Farbe) {Super (); this.x = x; this.y = y; this.color = color; this.good = gut; } public Tank (int x, int y, boolean good, farbefarben, richtungsdire, panzerklient tc) {this (x, y, gut, Farbe); this.dir = dir; this.tc = tc; } /*Get Tank Health* / public int getLife () {return Life; } /*Set Tank Health* / public void setLife (int Life) {this.life = Life; } /*Get Tank Camp* / public boolean isgood () {return Good; } /*Tankcamp* / public void setgood (boolean good) {this.good = good; } /*Get Panzerüberlebensstatus* / public boolean iSlive () {return live; } /*Setzen Sie den Überlebensstatus des Panzers* / public void setlive (boolean live) {this.live = live; } /*Tank zeichnen* / public void draw (Grafik g) {if (! Live) {if (! Good) {tc.tanks.remove (this); // Löschen im Set, wenn der feindliche Panzer stirbt // tc.tanks.add (neuer Tank (R.Nextint (700), R.Nextint (500), False, Color.Blue, Direction.d, this.tc)); } zurückkehren; } /*Speichern Sie zuerst die vorherige Pinselfarbe und stellen Sie die Pinselfarbe nach dem Zeichnen wieder her* / Farbe c = g.getColor (); // Die aktuelle Pinselfarbe G.SetColor (Farbe) erhalten; // Die Bürstenfarbe auf rot einstellen/*Tank zeichnen*/g.filloval (x, y, whith, hoch); /*Zwei Methoden zum Zeichnen von Feind und US -Panzern, verwenden Sie die zuvor hinzugefügten Bilder oder Farben, um*//// if (gut) // g.drawimage (Bild, x, y, whit, hoch, null) zu unterscheiden; // else // g.drawimage (Bild2, x, y, whit, hoch, null); if (gut) bb.draw (g); // unser Tank zeichnet den Blutstab G.SetColor (color.black); /*Zeichnen Sie den Waffenlauf durch die Richtung des Waffenlaufs*/Switch (ptdir) {case l: g.drawline (x+tank.with/2, y+tank. brechen; Case Lu: G.Drawline (x+Tank.Whith/2, y+Tank.Higth/2, x, y); brechen; Case Ru: G.Drawline (x+Tank.Whith/2, y+Tank.Higth/2, x+Tank.Whith/2, y); brechen; Fall R: G.Drawline (x+Tank.Whith/2, y+Tank. brechen; Case Rd: G.Drawline (x+Tank.Whith/2, y+Tank.Higth/2, x+Tank.Whith, y+Tank.Higth); brechen; Fall D: G.Drawline (x+Tank.Whith/2, y+Tank. brechen; } G.SetColor (c); // die Pinselfarbe wiederherstellen (); // Move}/*Tastaturüberwachung; Schlüssel*/ public void kectored (keyEvent e) {int key = e.getKeyCode (); // Speichern Sie die Tasten, die von der Tastatur als Ganzzahlen angehört werden. brechen; case keyEvent.vk_down: bd = true; brechen; case keyEvent.vk_right: br = true; brechen; case keyEvent.vk_left: bl = true; brechen; } gelandtheit (); } /*Tastaturüberwachung; Heben Sie den Schlüssel an*/ public void keyRepest (keyEvent e) {int key = e.getKeyCode (); // Speichern Sie die Tasten, die von der Tastatur als Ganzzahlen angehört werden. brechen; case keyEvent.vk_down: bd = false; brechen; case keyEvent.vk_right: br = false; brechen; case keyEvent.vk_left: bl = false; brechen; case keyEvent.vk_z: // Single Bullet if (live) fire (); brechen; case keyEvent.vk_f2: // unsere Auferstehung if (! this.live) {this.live = true; this.setLife (100); } brechen; case keyEvent.vk_f3: // feindliche resurrection fuhuo (); brechen; case keyEvent.vk_a: // Invincible Rissile Superfire (); brechen; case keyEvent.vk_q: // wiederherstellen, wenn (this.live) this.life = 100; brechen; case keyEvent.vk_e: // Blutgerinnsel tc.b.fh () freigeben; brechen; /*Positionstaste wiederherstellen*/ case keyEvent.vk_r: x = 50; y = 50; brechen; } gelandtheit (); // Kompositionsrichtung}/*Kompositionsbewegungsrichtung*/void lokaleRection () {if (bl &&! Bu &&! Br &&! Bd) Dir = Direction.l; sonst if (bl && bu &&! br &&! bd) dir = Direction.lu; sonst if (! bl && bu &&! bd) dir = Direction.U; sonst wenn (! bl && bu && br &&! bd) dir = Direction.ru; sonst wenn (! bl &&! bu && br &&! bd) dir = Direction.r; sonst wenn (! bl &&! bu && br && bd) dir = Direction.rd; sonst wenn (! bl &&! bu &&! br && bd) dir = Direction.d; sonst wenn (! bl &&! bu &&! br && bd) dir = Direction.ld; sonst wenn (! bl &&! bu &&! bd) dir = Direction.Stop; } void move () {// move/*zeichnen Sie die Position des vorherigen Schritts auf*/oldx = x; Oldy = y; Switch (Dir) {case L: x- = xspeed; brechen; Fall Lu: x- = xSpeed; y- = yspeed; brechen; Fall U: y- = yspeed; brechen; case ru: x+= xspeed; y- = yspeed; brechen; Fall R: x+= xSpeed; brechen; case rd: x+= xspeed; y+= yspeed; brechen; Fall D: y+= yspeed; brechen; Fall LD: X- = XSPEED; y+= yspeed; brechen; Fall LD: X- = XSPEED; y+= yspeed; brechen; Fallstopp: Break; } /*Richter Panzerbewegung außerhalb der Grenzen (Spielgrenze)* / if (x <5) x = 5; if (y <25) y = 25; if (x+whit> tc.game_width-5) x = tc.game_width-whith-5; if (y+higth> tc.game_hieth-5) y = tc.game_higth-higth-5; if (dir! /*Feindlicher Panzer bewegt sich automatisch*/ if (! Good) {Direction [] Dirs = Direction.Values (); // Setzen Sie die Richtungsvariable auf ein Array if (Schritt == 0) {Schritt = R.Nextint (12) +3; // zufällige Bewegung Schritt int randomNumber = r.Nextint (Dirs.Length); // Zufallsbewegungsrichtung Dir = Dirs [RandomNumber]; } Schritt--; if (R.Nextint (40)> 30) this.fire (); // Werden die Shells zufällig abgefeuert? int y = r.Nextint (500); Tank T = neuer Tank (x, y, false, color.blue, Richtung.D, TC); /*Wenn der Tank mit der Wand zusammenfällt, randomieren Sie die Position, bis er den neuen Tank nicht überlappt. || T.GetRect (). Schnreißt (tc.wall4.getRect ()) {Fortsetzung; } else {tc.tanks.add (t); brechen; }}}/*Bullet -Start*/public void Fire () {int x = this.x + whit/2 - missile.whith/2; // Die Kugelrichtung in die Mitte des Tanks steuern int y = this.y + higth/2 - missile.hogth/2; tc.missies.add (neue Rakete (Ptdir, Farbe, X, Y, Good, TC)); // Erstellen Sie eine neue Bullet -Klasse, um der Bullet Collection} /*Kollision beizutreten; Holen Sie sich den Bereich des Tanks*/ öffentliches Rechteck getRect () {Neues Rechteck zurück (x, y, whit, higth); } /*Die vorherige Stufenposition der Quittung* / private void stay () {x = oldx; y = Oldy; } /*Wenn Sie die Wand getroffen haben, rufen Sie die Stay -Methode an und kehren Sie zur vorherigen Stufenposition zurück* / public boolean hitwall (Wand w) {if (this.live && this.getRect (). zurückkehren; } return false; } /*Tank -Kollisionsereignis* / public boolean Hittanks (List <Tank> Tanks) {für (int i = 0; i <tanks.size (); i ++) {Tank t = Tanks.get (i); if (this! t.stay (); zurückkehren; }} return false; } /*Emissionsfunktion mit Feuerrichtung* / öffentliches Raketenfeuer (Richtung Dir) {if (! Live) return null; int x = this.x+whit/2-missile.with/2; int y = this.y+higth/2-missile. Higth/2; Rakete M = neue Rakete (Dir, Farbe, x, y, gut, this.tc); tc.missies.add (m); Rückkehr M; } /*Superfire -Rakete* / private void superfire () {Direction [] Dirs = Direction.Values (); für (int i = 0; i <8; i ++) {Fire (Dirs [i]); // Radfahrer acht Anweisungen}}/*Blutgerinnselklasse hinzugefügt*/private Klasse Blutstange G.SetColor (color.red); g.drawrect (x, y-10, whith, 10); int w = whith*Leben/100; G.FillRect (X, Y-10, W, 10); G.SetColor (c); }} /*Blutfressmethode* / public boolean eatblood (blut b) {if (this.live && b.islive () && this. B.SetLive (falsch); zurückkehren; } if (this.getRect (). Übergeht (tc.wb.getRect ())) this.life = 100; false zurückgeben; }}Missile.java
Import Java.awt.Color; Import Java.awt.Graphics; Import Java.awt.Rectangle; Import Java.util.List; öffentliche Klassenrakete { /*Bullet Data* / Tank.Direction Dir; // Kugelrichtung Farbe c; // Kugelfarbe int x, y; // Bullet Position Public Static Final int xSpeed = 15; // Längenbewegungsgeschwindigkeit öffentliche statische endgültige intyspeed = 15; // Längenbewegungsgeschwindigkeit öffentliche statische endgültige int whith = 10; // Bullet Width Public Static Final int higth = 10; // Bullet High Private Boolean Live = True; // beurteilen Sie das Überleben des Bullet Private Boolean Good; // Beurteilen Sie die Bullet and Camp Private Tankclient TC; // Hauptklassenberechtigungen öffentliche Rakete (Tank.Direktion Dir, Farbe C, int x, int y) {Super (); this.dir = dir; this.x = x; this.y = y; this.c = c; } öffentliche Rakete (Panzer. this.good = gut; this.tc = tc; } /*Das Überleben der Kugel erhalten* / public boolean iSlive () {return live; } /*Setzen Sie das Überleben der Kugel* / public void setlive (boolean live) {this.live = live; } public void Draw (Graphics g) { /*Wenn die Kugel stirbt, löschen Sie die Kugel in der Kugelsammlung* / if (! Live) {tc.missiles.remove (this); // die Rückgabe in der Sammlung löschen; } /*Speichern Sie zuerst die vorherige Pinselfarbe und stellen Sie die Pinselfarbe nach dem Zeichnen wieder her* / Farbe d = g.getColor (); // die aktuelle Pinselfarbe G.SetColor (C) erhalten; // Die Pinselfarbe auf rot einstellen/*Kugel drucken*/g.filloval (x, y, whith, hoch); G.SetColor (d); // die Pinselfarbe wiederherstellen (); // Move} public void move () {/*beurteilen Sie die Bewegungsrichtung und die Position des Tanks*/Switch (Dir) {case l: x- = xspeed; brechen; Fall Lu: x- = xSpeed; y- = yspeed; brechen; Fall U: y- = yspeed; brechen; case ru: x+= xspeed; y- = yspeed; brechen; Fall R: x+= xSpeed; brechen; case rd: x+= xspeed; y+= yspeed; brechen; Fall D: y+= yspeed; brechen; Fall LD: X- = XSPEED; y+= yspeed; brechen; Fallstopp: Break; } /*Beurteilen Sie die ausgehende Situation der Kugel; Wenn die Kugel stirbt, löschen Sie sie in der Bullet Collection*/ if (x <0 || y <0 || x> TankClient.game_width || y> TankClient.game_Heigth) Live = false; } /*Kollision; Holen Sie sich den Bereich der Kugel*/ öffentliches Rechteck getRect () {Neues Rechteck zurückgeben (x, y, whith, higth); } /*Kollisionsprozess zwischen Kugeln und Tanks* /public boolean hittank (Tank T) { /*Wenn sich die Kugel und der Tank im gleichen Bereich befinden, sterben die Kugel und der Tank gleichzeitig; und die Kugel kann nur den Panzer des Gegners töten*/if (this.live && this.getRect (). Überschneidet (T.GetRect ()) && t.islive () && this.good! T.SetLife (t.getLife ()-20); if (t.getLife () <= 0) T.SetLive (false); } else {// Bad Tank t.setLive (false); // tod} this.live = false; // Bullet Death tc.explode.add (neu explode (x, y, tc)); // Neue Explosion hinzufügen Set return true; } return false; } /*Kollaps -Tank setzt, um die Bullet -Kollision zu beurteilen. } return false; } /*Der Kollisionsprozess zwischen Kugeln und Wand* / public boolean hitwall (wand w) { /*Wenn sich der Bereich der Kugeln und Wand mit dem Kugel -Todesfall überlappt* / if (this.live && this.getRect (). // Bullet Death kehren wahr; } return false; }} Wall.java
import Java.awt.graphics; Import Java.awt.Rectangle; öffentliche Klasse Wall { /*Wanddaten* / int x, y, w, h; // Position und Breite und Höhe privat Tankclient TC; // Hauptklassenberechtigungen öffentliche Wand (int x, int y, int w, int h, Tankclient tc) {Super (); this.x = x; this.y = y; this.w = w; this.h = h; this.tc = tc; } /*Den Umfang der Wand erhalten* / öffentliches Rechteck getRect () {Neues Rechteck zurückgeben (x, y, w, h); } /*Wand zeichnen* / public void Draw (Grafik g) {G.FillRect (x, y, w, h); }}Explode.java
import Java.awt.color; Import Java.awt.Graphics; öffentliche Klasse Explode { /*Tanks -Explosionsattribut* / int x, y; // Explosionsposition Private boolean Live = True; // gibt es eine Explosion int Schritt = 0; // Explosionszeitkontrolle int [] Durchmesser = neu int [] {4, 7, 12, 18, 26, 32, 49, 56, 65, 77, 80, 50, 40, 30, 14, 6}; // Explosionsbereich privat Tankclient TC; // Hauptklasse Erlaubnis öffentlich explode (int x, int y, TankClient tc) {Super (); this.x = x; this.y = y; this.tc = tc; } /*Explosion zeichnen* / public void Draw (Grafik g) {if (! Live) return; // Wenn der Explosion -Todeszustand nicht endet/*Wenn die Explosionszeit endet, explodiert die Explosion nicht und löscht sie im Satz*/if (Schritt == Durchmesser.length) {Live = false; // Explosion Todesschritt = 0; // Schrittzeit ist 0 tc.explode.remove (this); // Rückgabe im Set löschen; } /*Explosion zeichnen* / color c = g.getColor (); G.SetColor (color.orange); G.Filloval (x, y, Durchmesser [Schritt], Durchmesser [Schritt]); G.SetColor (c); Schritt ++; }}Blut.java
Import Java.awt.Color; Import Java.awt.Graphics; Import Java.awt.Rectangle; Import Java.util.Random; Public Class Blood {/* Blutgerinnseldaten*/ int x, y, w, h; // Blutgerinnsel Ort und Größe privat Tankclient Tc; // Hauptklasse Erlaubnis private boolean Live = true; // Blutgerinnselüberleben Privat statische zufällige r = new random (); // Setzen Sie eine zufällige Wertvariable/* den Überlebensstatus des Blutgerinnsels erhalten*/ public boolean iSlive () {return live; } /* Setzen Sie den Überlebensstatus des Blutgerinnsels* / public void setlive (boolean live) {this.live = live; } /*Der Anfangswert der Blutgerinnselposition ist zufällig ein Wert* / public blood () {x = r.Nextint (600) +100; y = R.Nextint (400) +100; W = H = 15; } /*Blutgerinnsel zeichnen* / public void Draw (Grafik g) {if (! Live) return; Farbe c = g.getColor (); G.SetColor (color.magenta); G.FillRect (X, Y, W, H); G.SetColor (c); } /*Blutgerinnsel veröffentlichen* / public void fh () {if (! Live) {x = r.Nextint (600) +100; y = R.Nextint (400) +100; Live = wahr; }} /*Den Blutgerinnselbereich erhalten* / öffentliches Rechteck getRect () {Neues Rechteck zurückgeben (x, y, w, h); }}Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.