Utilisez des collections, des balançoires, des fils et d'autres points de connaissance de la langue Java pour écrire un jeu de guerre de tank.
(1) Dessinez le principe des réservoirs ennemis et américains:
Il existe une variable de type booléen bien à l'intérieur de la classe de réservoir. Utilisé pour juger le camp d'un réservoir. Lors de la création d'un objet de réservoir, la valeur du bien est passée dans la méthode de construction de la classe de réservoir. Lorsque vous dessinez des réservoirs, jugez la valeur du bien et distinguez la couleur de l'ennemi et des États-Unis;
(2) Principe du mouvement du réservoir:
L'événement de réponse de la presse à clé du clavier de moniteur est écrit dans la classe du réservoir, les touches surveillées, bas, gauche et droite sont enregistrées et les variables dans huit directions du mouvement du réservoir sont synthétisées. Ensuite, les modifications correspondantes des valeurs du réservoir coordonnent x et y dans chaque direction peuvent être apportées pour réaliser le mouvement de notre réservoir. Les réservoirs ennemis se déplacent automatiquement, circulant au hasard dans la direction du mouvement du réservoir ennemi à travers un nombre aléatoire, et sortent au hasard le nombre de fois chaque mouvement. La combinaison de deux valeurs aléatoires permet le mouvement des réservoirs ennemis.
(3) Principe des balles de lancement de chars:
Grâce à la surveillance du clavier, après avoir détecté la commande Bullet-Fire, ajoutez une classe de balles à la collection de classe de balles de la classe principale. Transférer la direction du canon du pistolet, la position du réservoir et le camp du réservoir aux balles. Dans la méthode de dessin de la peinture principale, la collection de balles sera à vélo. S'il y a des balles dans l'ensemble, dessinez-les. Cela permet le lancement de balles.
(4) Le principe de collision des réservoirs, balles et murs:
Dans la classe de mur de type balle de type réservoir, la méthode GetRect pour obtenir sa propre gamme, puis effectuer une détection de collision correspondante à chaque fois que le réservoir et la balle sont dessinés (il existe des méthodes de collision avec le mur et le réservoir à l'extérieur du réservoir dans le réservoir, et dans la balle, il existe des méthodes de collision avec le mur et le réservoir.). Si la plage de soi et l'objet qui ne devait pas être colladé, cela signifie que les deux objets entrent en collision.
(5) Le principe de la circulation sanguine du réservoir:
Si les caillots sanguins entrent en collision avec notre réservoir, les caillots sanguins mourront et les caillots sanguins seront complètement récupérés.
(6) Le principe de la résurrection des réservoirs:
Après avoir détecté l'ordre de résurrection de notre réservoir par surveillance du clavier, si notre réservoir est dans un état mort, notre statut d'inventaire de réservoir sera changé en vivant et que le volume sanguin de notre réservoir sera restauré en pleine santé.
Idées de programmation:
L'idée de programmation de Tank War ouvre un fil dans la classe principale et ne fait pas de vélo à 50 millisecondes pour dessiner la méthode (dessiner tout dans toute l'interface). Les choses tirées comprennent des réservoirs ennemis (distinction de couleur), des balles, des murs, des caillots sanguins et des explosions. Donc, au total, plusieurs catégories ont été écrites: réservoirs de chars, balles de missiles, murs muraux, caillots sanguins et cours principaux de chars à chars. Dans chaque classe, il existe une méthode de dessin écrite pour réaliser la fonction de dessin des attributs de cette classe. Il y a un événement d'écoute du clavier dans la classe principale appelée l'événement d'écoute du clavier de cette classe Tank. Grâce à la surveillance du clavier, il est déterminé que le mouvement correspondant du réservoir est fabriqué, tandis que le réservoir ennemi se déplace de manière aléatoire. Et chaque fois que le rafraîchissement est actualisé, diverses méthodes de collision sont appelées pour déterminer la situation de certains objets qui ne doivent pas être entrés en collision. La création de chaque objet, telles que des balles, est d'ajouter une nouvelle classe de balles à une collection de classe de balles après sa déclenchement. Lors du dessin, déterminez le numéro dans l'ensemble à dessiner. Si le réservoir est hors limites ou tue le réservoir, il sera supprimé dans l'ensemble. D'autres catégories sont également similaires, donc je n'entrerai pas dans les détails.
Chaque étape du code a une explication correspondante.
Tankclient.java
Importer java.awt.color; import java.awt.font; import java.awt.graphics; import java.awt.image; import java.awt.event.keyadapter; import java.awt.event.keyevent; import java.awt.windowevent; import; import; java.util.arraylist; import java.util.list; import javax.swing.jframe; public class tankclient étend jframe {/ ** * @param args * / image offScrennimage = null; // Double tampon Memory Image Storage / * Taille du jeu * / public static final int game_width = 800; // Interface largeur publique statique final int game_heigth = 600; // Tank à interface élevée mytank = nouveau réservoir (500 400, true, colore.red, tank.direction.stop, this); // Notre liste de classes Tank <Missile> missiles = new ArrayList <Missile> (); // Collection de Bullets List <pleplode> exploit = new ArrayList <pleplode> (); // Liste des ensembles d'explosion <ank> tanks = new ArrayList <Sank> (); // Wall Set Wall1 = nouveau mur (150,200,20,300, ceci); // mur 1 mur mur2 = nouveau mur (250 500,300,20, ceci); // mur 2 mur mur3 = nouveau mur (650,200,20,300, ceci); // mur 2 mur mur4 = nouveau mur (250,300,300,20, ceci); // mur 2 mur wb = nouveau mur (750,550,40,40, ceci); // Wall2 Blood b = new Blood (); // Blood Class public static void main (String [] args) {// TODO Méthode générée automatique Stub TankClient tc = new TankClient (); tc.lauchframe (); } private void lauchframe () {// todo marketed method talb for (int i = 0; i <10; i ++) {tanks.add (new tank (50 + 40 * (i + 1), 50, false, colore.blue, tank.direction.d, this)); } this.setLocation (100, 100); // Point de coordonnée initiale de la fenêtre this.setSize (game_width, game_heigth); // Taille initiale de la fenêtre this.setTitle ("Tankwar"); // Nom de la fenêtre / * Écoute de la fenêtre * / this.addwindowListener (new WindowAdapter () {@Override / * Run après le point quitte la fourche * / public void windowClosing (WindowEvent e) {// TODO Generated Method Stub System.exit (0); // quitte}}); this.addkeyListener (new KeyMoniton ()); // Définissez le clavier pour écouter this.setVisible (true); // Définissez la fenêtre pour afficher ce.SetResiSable (false); // Définissez la fenêtre pour ne pas modifier la taille this.getContentPane (). SetBackground (Color.Green); // Définissez la couleur du premier plan de la fenêtre sur un nouveau fil vert (nouveau PaintThread ()). Start (); // Démarrez la classe PaintThread Run} @Override public void peinture (graphiques g) {// TODO Méthode générée automatique Stub // graphiques est la classe Brush super.paint (g); mytank.Draw (g); wall1.raw (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 <missiles.size (); i ++) {missile m = missiles.get (i); // obtient la balle actuelle M.Hittanks (réservoirs); // Votre propre balle tue le réservoir ennemi M.Hitwall (Wall1); // balle et mur M.Hitwall (wall2); M.Hitwall (Wall3); M.Hitwall (Wall4); M.Hittank (Mytank); // La balle ennemie frappe son propre tank m.raw (g); // Draw Bullet} pour (int i = 0; i <explore.size (); i ++) {exploit.get (i) .draw (g); // dessiner explosion} pour (int i = 0; i <tanks.size (); i ++) {Tank t = tanks.get (i); T.draw (g); // dessiner des chars ennemis t.hittanks (réservoirs); T.Hitwall (Wall1); // réservoirs et murs T.Hitwall (Wall2); T.Hitwall (Wall3); T.Hitwall (Wall4); } //g.setfont(New font ("宋体", font.bold, 20)); G.Drawstring ("Count des missiles:" + missiles.size (), 10, 50); // montre G.Drawstring ("EXPLODE COUNT:" + Expllode.size (), 10, 80); // montre G.Drawstring ("Count Count:" + tanks.size (), 10, 110); G.Drawstring ("Mytank Life:" + mytank.getLife (), 10, 130); G.Drawstring ("Blood Recovery:", 750, 540); G.Drawstring ("Directory Key Movement Direction; E: libérer le sang de mouvement rapide", 10, 590); G.Drawstring ("Z: Lancement de Dongfeng-31; A: Lance Dongfeng-41;", 10, 570); G.Drawstring ("F2: Resurrection; F3: Resurrection de l'ennemi (au plus 20)", 10, 550); G.Drawstring ("R: Restore de position; Q: plein de sang", 10, 530); } @Override / * Repreen-> Update-> peinture * / public void Update (Graphics G) {// TODO Méthode générée automatique Stub super.update (g); if (offsCrennimage == null) offsCrennimage = this.createImage (game_width, game_heigth); Graphics GoffsCrenn = offsCrennimage.getGraphics (); // Définissez une couleur de pinceau à mémoire sur la couleur de couleur de l'image de premier plan C = goffscrenn.getColor (); // Enregistrez d'abord la couleur de premier plan, Goffscrerenn.setColor (Color.Green); // Définissez la couleur du pinceau à mémoire sur Green Goffscrerenn.Fillrect (0, 0, Game_Width, Game_Heigth); // dessine l'image comme la taille de la taille du jeu goffscrerenn.setColor (c); // Restaurez la couleur G.DrawImage (OffsCrennimage, 0, 0, null); // dessine l'image enregistrée sur la peinture d'interface (Goffscrenn); // Appelez le pinceau à mémoire pour peindre} la classe privée PaintThread implémente Runnable {@Override public void run () {// TODO Méthode générée auto While (true) {repent (); // Exécuter l'ordre repent-> Update-> peinture try {Thread.Sleep (50); // actualiser l'écran tous les 50 millisecondes} catch (exception e) {e.printStackTrace (); }}}} / * Réponse du clavier * / Private KeyMoniton étend KeyAdapter {/ * Appuyez sur la réponse du clavier * / @Override public void keyprimred (keyEvent e) {// Todo Auto-Generated Method Stub super.KeypReprimb (e); mytank.KeyPressed (e); } / * Rise la réponse du clavier * / @Override public void keyrelent (keyEvent e) {// TODO Stub de méthode générée automatiquement Super.Keyreled (e); mytank.Keyreleased (e); }}}Tank.java
Importer java.awt.color; import java.awt.graphics; import java.awt.image; import java.awt.rectangle; import java.awt.event.keyevent; import java.util.list; Coordonne privé int oldx, oldy; // Tank Coordonnées précédentes coordonnées publiques final statique Int whith = 30; // Largeur du réservoir public statique final int higth = 30; // Tank High public static final int xspeed = 5; // longueur de mouvement directionnel vitesse publique statique final int yspeed = 5; // Longarogue Speed Speed Couleur de couleur privée; // Tank Color Boolean Boolean BL = FAUX, BU = FALSE, BR = FALSE, BD = FAUX; // Valeurs de contrôle de quatre directions Direction de l'énumération {l, lu, u, ru, r, rd, d, ld, stop}; // Le mouvement de huit directions est composé de quatre valeurs de direction Dir = direction de direction privée.stop; // Direction de sortie Direction privée PTDIR = Direction.D; // Direction originale du canon privé booléen bien; // juge le camp du réservoir Boolean Live = True; // juger si le réservoir est vivant privé statique random r = new random (); // définir une variable aléatoire de valeur privée intte statique = r.Nextint (12) +3; // Mouvement aléatoire du réservoir ennemi étapes 3-14 private int life = 100; // Volume de santé Blood Private Blood BB = New Bloodbar (); // Cleck // ImageIcon icon = new ImageIcon ("Res // mytank.jpg"); // ImageIcon icon2 = new ImageIcon ("Res // EnemyTank.jpg"); // image image = icon.getImage (); // image image2 = icon2.getImage (); Private TankClient TC; // Permissions de classe principale Public Tank (int x, int y, boolean bon, couleur couleur) {super (); this.x = x; this.y = y; this.color = couleur; this.good = bon; } Tank public (int x, int y, boolean bon, couleur couleur, direction dir, tankclient tc) {this (x, y, bonne, couleur); this.dir = dir; this.tc = tc; } / * Obtenir 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 bon; } / * Set Tank Camp * / public void setgood (boolean bon) {this.good = good; } / * Get Tank Survival Status * / public boolean isLive () {return live; } / * Définissez le statut de survie du réservoir * / public void setLive (boolean live) {this.live = live; } / * Draw Tank * / public void Draw (Graphics g) {if (! Live) {if (! Good) {tc.tanks.remove (this); // Supprimer dans l'ensemble lorsque le réservoir ennemi meurt // tc.tanks.add (nouveau réservoir (R.Nextint (700), R.Nextint (500), false, color.blue, direction.d, this.tc)); } retour; } / * Enregistrez d'abord la couleur de pinceau précédente et restaurez la couleur du pinceau après le dessin * / couleur c = g.getColor (); // obtient la couleur de pinceau actuelle g.setColor (couleur); // Réglez la couleur du pinceau sur le réservoir rouge / * Draw * / g.FillOval (x, y, whith, haut); / * Deux méthodes pour dessiner des réservoirs ennemis et américains, utilisez les images ou les couleurs ajoutées précédemment pour distinguer * /// if (bon) // g.DrawImage (image, x, y, whith, haut, null); // else // g.DrawImage (image2, x, y, whith, haut, null); si (bon) bb.draw (g); // Notre réservoir dessine la barre de sang g.setColor (Color.Black); / * Dessinez le baril du pistolet dans la direction du canon du pistolet * / commutateur (ptdir) {case l: g.drawline (x + tank.whith / 2, y + tank.higth / 2, x, y + tank.higth / 2); casser; Case Lu: G.Drawline (x + tank.whith / 2, y + tank.higth / 2, x, y); casser; Case Ru: G.Drawline (x + tank.Whith / 2, y + tank.higth / 2, x + tank.whith / 2, y); casser; Case R: G.Drawline (x + tank.whith / 2, y + tank.higth / 2, x + tank.whith, y + tank.higth / 2); casser; Case Rd: G.Drawline (x + tank.whith / 2, y + tank.higth / 2, x + tank.whith, y + tank.higth); casser; cas D: G.Drawline (x + tank.whith / 2, y + tank.higth / 2, x, y + tank.higth); casser; } g.setColor (c); // Restaurer le mouvement de la couleur de pinceau (); // déplacer} / * Surveillance du clavier; Key * / public void keyPressed (keyEvent e) {int key = e.getKeycode (); // Enregistrez les touches écoutées par le clavier comme des entiers / * Tank mobile du clavier * / commutateur (clé) {/ * Move Key * / case keyEvent.vk_up: bu = true; casser; case keyevent.vk_down: bd = true; casser; case keyevent.vk_right: br = true; casser; case keyevent.vk_left: bl = true; casser; } SiTirection (); } / * Surveillance du clavier; Soulevez la clé * / public void keyrelent (keyEvent e) {int key = e.getkeycode (); // Enregistrez les touches écoutées par le clavier comme des entiers / * Tank en mouvement du clavier * / commutateur (clé) {Case keyEvent.vk_up: bu = false; casser; case keyevent.vk_down: bd = false; casser; case keyevent.vk_right: br = false; casser; case keyevent.vk_left: bl = false; casser; case keyevent.vk_z: // Bullet unique if (live) fire (); casser; case keyevent.vk_f2: // notre résurrection if (! this.live) {this.live = true; this.setLife (100); } casser; Case keyevent.vk_f3: // ennemis résurrection fuhuo (); casser; case keyevent.vk_a: // invincible missile superfire (); casser; Case keyevent.vk_q: // récupérer if (this.live) this.life = 100; casser; case keyevent.vk_e: // libérer le caillot de sang tc.b.fh (); casser; / * Restaurer la clé de position * / Case KeyEvent.vk_r: x = 50; y = 50; casser; } SiTirection (); // Direction de la composition} / * Direction du mouvement de composition * / void SiTirection () {if (bl &&! Bu &&! Br &&! Bd) dir = direction.l; else if (bl && bu &&! br &&! bd) dir = direction.lu; else if (! bl && bu &&! bd) dir = direction.u; else if (! bl && bu && br &&! bd) dir = direction.ru; else if (! bl &&! bu && br &&! bd) dir = direction.r; else if (! bl &&! bu && br && bd) dir = direction.rd; else if (! bl &&! bu &&! br && bd) dir = direction.d; else if (! bl &&! bu &&! br && bd) dir = direction.ld; else if (! bl &&! bu &&! bd) dir = direction.stop; } void move () {// move / * enregistrer la position de l'étape précédente * / oldx = x; oldy = y; switch (dir) {case l: x- = xspeed; casser; Case Lu: x- = xspeed; y- = yspeed; casser; cas u: y- = yspeed; casser; cas ru: x + = xspeed; y- = yspeed; casser; case r: x + = xspeed; casser; Case rd: x + = xspeed; y + = yspeed; casser; cas d: y + = yspeed; casser; cas ld: x- = xspeed; y + = yspeed; casser; cas ld: x- = xspeed; y + = yspeed; casser; Arrêt du cas: pause; } / * Juge le mouvement du réservoir hors des limites (limite du jeu) * / if (x <5) x = 5; si (y <25) y = 25; if (x + whith> tc.game_width-5) x = tc.game_width-qui-5; if (y + higth> tc.game_heigth-5) y = tc.game_heigth-higth-5; if (dir! = direction.stop) // Si le réservoir n'est pas stationnaire, modifiez la direction du baril ptdir = dir; / * Le réservoir ennemi se déplace automatiquement * / if (! Bon) {Direction [] dirS = Direction.Values (); // Définissez la variable de direction sur un tableau if (Step == 0) {Step = R.Nextint (12) +3; // étape de mouvement aléatoire int randomNumber = r.Nextint (dirs.length); // Dirette de mouvement aléatoire Dir = Dirs [RandomNumber]; } étape--; if (r.Nextint (40)> 30) this.fire (); // Les coquilles sont-elles tirées au hasard}} / * Resurrection du réservoir ennemie * / public void fuhuo () {if (tc.tanks.size () <20) while (true) {int x = r.nextint (700); int y = r.Nextint (500); Tank T = nouveau réservoir (x, y, false, colore.blue, direction.d, tc); / * Si le réservoir coïncide avec le mur, la position de nouveau-aléatoire jusqu'à ce qu'elle ne chevauche pas le nouveau réservoir est ajouté à l'ensemble * / if (t.getRect (). Intersection (tc.Wall1.GetRect ()) || t.GetRect (). Intersection (tc.Wall2.GetRect ()) || t.GetRect (). || t.getRect (). Intersection (tc.Wall4.getRect ())) {continuant; } else {tc.tanks.add (t); casser; }}} / * Bullet Launch * / public void fire () {int x = this.x + whith / 2 - missile.whith / 2; // contrôle la direction de la balle au milieu du réservoir int y = this.y + higth / 2 - missile.higth / 2; tc.Missiles.add (nouveau missile (ptdir, couleur, x, y, bon, tc)); // Créez une nouvelle classe de balles pour rejoindre la collection de balles} / * collision; Obtenez la plage du tank * / public rectangle getRect () {return new rectangle (x, y, whith, higth); } / * La position d'étape précédente du reçu * / private void stay () {x = oldx; y = oldy; } / * Si vous appuyez sur le mur, appelez la méthode de séjour et revenez à la position d'étape précédente * / public boolean hitwall (wall w) {if (this.live && this.getRect (). Intersects (w.getRect ())) {this.stay (); Retour Vrai; } return false; } / * Tank Collision Event * / public boolean hittanks (list <ank> tanks) {for (int i = 0; i <tanks.size (); i ++) {tank t = tanks.get (i); if (this! = t) {// Vous ne pouvez pas entrer en collision avec vous-même / * si vous entrez en collision, revenez à la position précédente * / if (this.live && t.islive () && this.getRect (). intersection (t.getRect ())) {this.stay (); t.stay (); Retour Vrai; }} return false; } / * Fonction d'émission avec la direction du feu * / Missile public Fire (Direction de direction) {if (! Live) RETOUR NULL; int x = this.x + whith / 2-missile.whith / 2; int y = this.y + higth / 2-missile.higth / 2; Missile m = new missile (dir, couleur, x, y, bon, this.tc); tc.Missiles.add (m); retour m; } / * Superfire missile * / private void superfire () {direction [] dirs = direction.values (); pour (int i = 0; i <8; i ++) {feu (dirs [i]); // cyclisme huit directions}} / * Classe de caillot de sang ajouté * / classe privée Bloodbar {/ * Draw Blood Bar * / public void Draw (Graphics G) {couleur c = g.getColor (); g.setColor (Color.Red); G.Drawrect (X, Y-10, Whith, 10); int w = whith * life / 100; G.Fillrect (X, Y-10, W, 10); g.setColor (c); }} / * Méthode des mangeurs de sang * / public boolean eatblood (sang b) {if (this.live && b.islive () && this.isgood () && this.getRect (). intersection (b.getRect ())) {this.setLife (100); B.SetLive (false); Retour Vrai; } if (this.getRect (). intersection (tc.wb.getRect ()))) this.Life = 100; retourne false; }}Missile.java
import java.awt.color; import java.awt.graphics; import java.awt.rectangle; import java.util.list; public class missile {/ * data * / tank.direction dir; // Couleur de direction de la balle C; // couleur de balle int x, y; // position de balle publique statique final int xSpeed = 15; // Longueur Speed Speed public static final int ySpeed = 15; // Longueur Speed Speed public static final int whith = 10; // Bullet Largeth Public Static Final int Higth = 10; // Bullet High Private Boolean Live = True; // juge la survie du bien booléen privé de la balle; // Jugez la balle et le camp privé Tankclient TC; // Permissions de classe principale Missile public (Tank.Direction Dir, Color C, int x, int y) {super (); this.dir = dir; this.x = x; this.y = y; this.c = c; } missile public (tank.direction dir, couleur c, int x, int y, boolean bon, tankclient tc) {this (dir, c, x, y); this.good = bon; this.tc = tc; } / * Obtenez la survie de la balle * / public boolean isLive () {return live; } / * Définissez la survie de la balle * / public void setLive (boolean live) {this.live = live; } public void draw (graphics g) {/ * Si la balle meurt, supprimez la balle dans la collection de balles * / if (! live) {tc.Missiles.Remove (this); // supprime le retour dans la collection; } / * Enregistrez d'abord la couleur de pinceau précédente et restaurez la couleur du pinceau après le dessin * / couleur d = g.getColor (); // obtient la couleur de pinceau actuelle g.setColor (C); // Réglez la couleur du pinceau sur le rouge / * imprimer Bullet * / g.Filloval (x, y, whith, haut); g.setColor (d); // Restaurer le mouvement de la couleur du pinceau (); // Move} public void move () {/ * juge la direction de mouvement et la position du réservoir * / commutateur (dir) {cas l: x- = xspeed; casser; Case Lu: x- = xspeed; y- = yspeed; casser; cas u: y- = yspeed; casser; cas ru: x + = xspeed; y- = yspeed; casser; case r: x + = xspeed; casser; Case rd: x + = xspeed; y + = yspeed; casser; cas d: y + = yspeed; casser; cas ld: x- = xspeed; y + = yspeed; casser; Arrêt du cas: pause; } / * Juger la situation sortante de la balle; Si sortant, la balle mourra, supprimez-la dans la collection de balles * / if (x <0 || y <0 || x> tankclient.game_width || y> tankclient.game_heigth) live = false; } / * Collision; Obtenez la plage de la balle * / public rectangle getRect () {return new rectangle (x, y, whith, higth); } / * Processus de collision entre les balles et les réservoirs * / public booléen hittank (réservoir T) {/ * Si la balle et le réservoir sont dans la même plage, la balle et le réservoir mourront en même temps; et la balle ne peut que tuer le réservoir de l'adversaire * / if (this.live && this.getRect (). intersection (t.getRect ()) && t.islive () && this.good! = t.isgood ()) {if (t.isgood ()) {// bon réservoir / * Notre réservoir réduira les points de santé quand il frappe le ballon et les dies quand il se fait 0 * / t.setLife (t.getLife () - 20); if (t.getLife () <= 0) t.setLive (false); } else {// bad tank t.setLive (false); // Death} this.live = false; // de mort de balle tc.explode.add (new Expllode (x, y, tc)); // nouvelle explosion ajoute set return true; } return false; } / * Effondrement du réservoir pour juger la collision des balles * / booléen public hittanks (list <ank> chars) {for (int i = 0; i <tanks.size (); i ++) {if (hittank (tanks.get (i))) return true; } return false; } / * Le processus de collision entre les balles et le mur * / public booléen hitwall (mur w) {/ * Si la plage de balles et de mur se chevauche avec la mort des balles * / if (this.live && this.getRect (). Intersects (w.getRect ())) {this.live = false; // Death Bullet Return True; } return false; }} Wall.java
import java.awt.graphics; import java.awt.rectangle; public class wall {/ * wall data * / int x, y, w, h; // Position et largeur et hauteur Private TankClient TC; // Permissions de classe principale Mur public (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; } / * Obtenez la portée du mur * / public rectangle getRect () {return new rectangle (x, y, w, h); } / * Draw Wall * / public void Draw (Graphics g) {g.FillRect (x, y, w, h); }}Exploser.java
Importer java.awt.color; Importer java.awt.graphics; classe publique Explose {/ * Tank Explosion Attribut * / int x, y; // Position d'explosion privé booléen en direct = true; // y a-t-il une explosion int step = 0; // Contrôle du temps d'explosion int [] diamètre = nouveau int [] {4, 7, 12, 18, 26, 32, 49, 56, 65, 77, 80, 50, 40, 30, 14, 6}; // Explosion Private Tankclient TC; // Permission de classe principale Explose publique (int x, int y, tankclient tc) {super (); this.x = x; this.y = y; this.tc = tc; } / * Draw Explosion * / public void Draw (Graphics g) {if (! Live) return; // Si l'état de mort d'explosion ne se termine pas / * Si le temps d'explosion se termine, l'explosion n'existe pas et le supprime dans l'ensemble * / if (Step == diamètre.length) {live = false; // Étape de mort d'explosion = 0; // Le temps de pas est 0 tc.Explode.Remove (this); // Supprimer le retour dans l'ensemble; } / * Draw Explosion * / Color C = g.getColor (); g.setColor (colore.orange); G.Filloval (x, y, diamètre [étape], diamètre [étape]); g.setColor (c); Step ++; }}Sang.java
import java.awt.color; import java.awt.graphics; import java.awt.rectangle; import java.util.random; public class blood {/ * Blood clot data * / int x, y, w, h; // blood clot location et taille private tankclient tc; // Permission de classe principale private booléen live = true; // Blood Clot Survival Private Static Random r = new Random (); // définir une variable de valeur aléatoire / * Obtenez le statut de survie du caillot de sang * / public boolean isLive () {return live; } / * Définissez le statut de survie du caillot de sang * / public void setLive (booléen live) {this.live = live; } / * La valeur initiale de la position du caillot sanguin est aléatoirement une valeur * / blood public () {x = r.nextint (600) +100; y = R.Nextint (400) +100; w = h = 15; } / * Draw Blood Clot * / public void Draw (Graphics g) {if (! Live) return; Couleur c = g.getColor (); g.setColor (Color.magenta); G.Fillrect (x, y, w, h); g.setColor (c); } / * Libérer le caillot de sang * / public void fh () {if (! Live) {x = r.nextint (600) +100; y = R.Nextint (400) +100; Live = true; }} / * Obtenez la plage de caillot de sang * / public rectangle getRect () {return new rectangle (x, y, w, h); }}Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.