Use colecciones, columpios, hilos y otros puntos de conocimiento en el idioma Java para escribir un juego de guerra de tanques.
(1) Dibuja el principio de los tanques enemigos y estadounidenses:
Hay una variable de tipo booleana buena dentro de la clase de tanque. Solía juzgar el campamento de un tanque. Al crear un objeto de tanque, el valor del bien se pasa en el método de construcción de la clase de tanque. Al dibujar tanques, juzgue el valor del bien y distinga el color del enemigo y nosotros;
(2) Principio del movimiento del tanque:
El evento de respuesta de la presión del teclado del monitor está escrito en la clase del tanque, se registran las teclas monitoreadas hacia arriba, hacia abajo, izquierda y derecha, y se sintetizan las variables en ocho direcciones del movimiento del tanque. Luego, los cambios correspondientes a los valores de las coordenadas del tanque X e Y en cada dirección se pueden hacer para lograr el movimiento de nuestro tanque. Los tanques enemigos se mueven automáticamente, circulan aleatoriamente la dirección del movimiento del tanque enemigo a través de un número aleatorio y producen aleatoriamente el número de veces cada movimiento. La combinación de dos valores aleatorios permite el movimiento de los tanques enemigos.
(3) Principio de las balas de lanzamiento del tanque:
A través del monitoreo del teclado, después de detectar el comando Bullet-Fire, agregue una clase de bala a la colección de clase Bullet de la clase principal. Transfiera la dirección del cañón de la pistola, la posición del tanque y el campamento del tanque a las balas. En el método de dibujo de pintura principal, la colección de balas se ciclará. Si hay balas en el set, dibujas. Esto permite el lanzamiento de balas.
(4) El principio de colisión de tanques, balas y paredes:
En la clase de pared de tipo de bala tipo tanque, obtenga el método para obtener su propio rango y luego realice la detección de colisiones correspondiente cada vez que se dibuja el tanque y la bala (hay métodos para la colisión con la pared y el tanque fuera del tanque del tanque, y en la bala, hay métodos para la colisión con la pared y el tanque).). Si el rango de uno mismo y el objeto que no debe chocarse, significa que los dos objetos chocan.
(5) El principio de la circulación sanguínea del tanque:
Si los coágulos de sangre chocan con nuestro tanque, los coágulos de sangre morirán y los coágulos de sangre se recuperarán completamente.
(6) El principio de la resurrección del tanque:
Después de detectar la orden de resurrección de nuestro tanque mediante el monitoreo del teclado, si nuestro tanque está en un estado muerto, nuestro estado de inventario del tanque se cambiará vivo y el volumen de sangre de nuestro tanque se restaurará a la salud completa.
Ideas de programación:
La idea de programación de la guerra de tanques abre un hilo en la clase principal, y no ciclista a 50 milisegundos para dibujar el método (dibuje todo en toda la interfaz). Las cosas dibujadas incluyen tanques enemigos (distinción del color), balas, paredes, coágulos de sangre y explosiones. Entonces, en total, se escribieron varias categorías: tanques de tanques, balas de misiles, paredes de paredes, coágulos de sangre y clases principales de Tankclient. En cada clase, hay un método de dibujo escrito para realizar la función de dibujo de los atributos de esta clase. Hay un evento de escucha de teclado en la clase principal llamado Evento de escucha del teclado de esta clase de tanque. A través del monitoreo del teclado, se determina que se realiza el movimiento correspondiente del tanque, mientras que el tanque enemigo se mueve al azar. Y cada vez que se actualiza la actualización, se llaman varios métodos de colisión para determinar la situación de algunos objetos con los que no deben chocarse. La creación de cada objeto, como las balas, es agregar una nueva clase de bala a una colección de clase de bala después de activarse. Al dibujar, determine el número en el conjunto para dibujar. Si el tanque está fuera de los límites o mata el tanque, se eliminará en el set. Otras categorías también son similares, por lo que no entraré en detalles.
Cada paso en el código tiene una explicación correspondiente.
Tankclient.java
import 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.event.WindowAdapter;import java.awt.event.WindowEvent;import java.util.arrayList; import java.util.list; import javax.swing.jframe; public class TankClient extiende jframe { / ** * @param args * / imagen offscrennimage = null; // almacenamiento de imagen de memoria de doble búfer/*tamaño de juego*/public static final int game_width = 800; // Interfaz de ancho Público estático final int game_heigth = 600; // tanque de interfaz alta myTank = nuevo tanque (500,400, verdadero, color.red, tank.direction.stop, esto); // Nuestra lista de clases de tanque <Missile> Missiles = new ArrayList <Missile> (); // colección de listas de balas <Splode> Exploit = new ArrayList <Splode> (); // Explosion Set List <Ank> TankS = New ArrayList <Kank> (); // Tank Set Wall Wall1 = New Wall (150,200,20,300, esto); // pared 1 pared de pared2 = nueva pared (250,500,300,20, esto); // pared 2 pared de pared3 = nueva pared (650,200,20,300, esto); // pared 2 pared de pared4 = nueva pared (250,300,300,20, esto); // pared 2 pared wb = nueva pared (750,550,40,40, esto); // Wall2 Blood B = New Blood (); // Clase de sangre pública Public static void main (string [] args) {// toDo método generado automático stub TankClient tc = new TankClient (); tc.lauchframe (); } private void lauchframe () {// TODO Auto Generated Method Stub for (int i = 0; i <10; i ++) {tanks.Add (nuevo tanque (50+40*(i+1), 50, falso, color.blue, tank.direction.d, esto)); } this.setLocation (100, 100); // Punto de coordenada inicial de la ventana. // Tamaño inicial de la ventana. // Nombre de la ventana/*Window Listening*/this.addwindowlistener (new WindowAdapter () {@Override/*El punto de ejecución de la bifurcación*/public void WindowClosing (WindowsEvent E) {// TODO Auto Generado Método STUB System.Exit (0); // Salida}}); this.addkeylistener (nuevo kymoniton ()); // Establezca el teclado para escuchar esto.setVisible (true); // Establecer la ventana para mostrar este.setResizable (falso); // Establezca la ventana para no cambiar el tamaño this.getContentPane (). SECUPTERGROME (color.green); // Establecer el color de primer plano de la ventana en el nuevo hilo verde (nuevo PaintThread ()). Start (); // Inicie la clase PaintThread ejecutada} @Override public void Paint (Graphics g) {// TODO Método Generado automático stub // Graphics es la clase de pincel 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); /*Colección de balas de ciclo*/ for (int i = 0; i <missiles.size (); i ++) {misil m = misiles.get (i); // Obtener la bala actual M.Hittanks (tanques); // Tu propia bala mata al tanque enemigo M.Hitwall (Wall1); // bala y pared m.hitwall (wall2); M.HitWall (Wall3); M.HitWall (Wall4); M.Hittank (MyTank); // La bala enemiga golpea su propio tanque M.Draw (g); // dibujar bala} para (int i = 0; i <explore.size (); i ++) {exploit.get (i) .draw (g); // dibujar explosión} para (int i = 0; i <tanks.size (); i ++) {tanque t = tanks.get (i); T.Draw (g); // dibujar tanques enemigos T.Hittanks (tanques); T.HitWall (Wall1); // tanques y paredes t.hitwall (wall2); T.HitWall (Wall3); T.HitWall (Wall4); } //g.setfont(new font ("宋体", font.bold, 20)); G.DrawString ("Conteo de misiles:"+misiles.size (), 10, 50); // show g.DrawString ("Explode Count:"+Explode.size (), 10, 80); // show g.drawstring ("Tanks Count:"+Tanks.size (), 10, 110); G.DrawString ("Mytank Life:"+myTank.getLife (), 10, 130); G.DrawString ("Recuperación de sangre:", 750, 540); G.DrawString ("Dirección de movimiento de clave de directorio; E: liberar sangre de movimiento rápido", 10, 590); G.DrawString ("Z: Lanzar Dongfeng-31; A: Lanzar Dongfeng-41;", 10, 570); G.DrawString ("F2: Resurrección; F3: Resurrección del enemigo (a la máximo 20)", 10, 550); G.DrawString ("R: Restauración de posición; P: Lleno de sangre", 10, 530); } @Override /*Repaint-> Update-> Paint* / public void Update (Graphics G) {// TODO Método generado automático stub super.update (g); if (offScrennImage == null) OffScrennImage = this.createImage (game_width, game_heigth); Graphics goffscrenn = OffScrennImage.getGraphics (); // Establecer un color de pincel de memoria en el color de la imagen en primer plano C color c = goffscrenn.getColor (); // Guardar el color de primer plano primero, GoffScrenn.SetColor (color.green); // Establezca el color del pincel de memoria en verde goffscrenn.fillrect (0, 0, game_width, game_heigth); // Dibuja la imagen como el tamaño del tamaño del juego GoffScrenn.SetColor (C); // restaurar el color G.DrawImage (OffScrennimage, 0, 0, nulo); // Dibuja la imagen guardada en la pintura de la interfaz (GoffScrenn); // Llame al pincel de memoria para pintar} La clase privada pintThread implementa runnable {@Override public void run () {// toDO Stub de método generado automático while (true) {repaint (); // ejecutar la repintado de pedidos-> update-> pintar try {thread.sleep (50); // Actualiza la pantalla cada 50 milisegundos} captura (excepción e) {E.PrintStackTrace (); }}}} /*Respuesta del teclado* / Private Class Kymoniton extiende KeyAdapter { /*Presione la respuesta del teclado* / @Override public void keyPressed (KeyEvent E) {// TODO Método Generado automático stub Super.KeyPissed (e); myTank.KeyPissed (e); } /*Sube la respuesta del teclado* / @Override public void KeyReleaded (KeyEvent E) {// TODO Método Generado automático super.KeyReleed (e); myTank.keyReleed (e); }}}Tanque.java
import java.awt.color; import java.awt.graphics; import java.awt.image; import java.awt.rectangle; import java.awt.event.keyevent; import java.util.list; import java.util.random; import javax.swing.imageicon; Tank de clase pública {/*Tank/Tank. Coordina privado int Oldx, Oldy; // COORDINACIÓN ANTERIOR DE TANQUE PUBLICACIÓN PUBLICATA FINAL INT WHITH = 30; // ancho del tanque público estático final int higth = 30; // tanque alto público estático final int xspeed = 5; // Velocidad de movimiento direccional de longitud Pública estática final int yspeed = 5; // Velocidad de movimiento de longarogue Color de color privado; // Color de tanque Booleano privado bl = false, bu = false, br = false, bd = false; // Valores de control de cuatro direcciones en la dirección {L, Lu, U, Ru, R, Rd, D, Ld, Stop}; // El movimiento de ocho direcciones se compone de cuatro valores de dirección de dirección privada dir = direction.stop; // dirección de salida dirección privada ptdir = direction.d; // Dirección original del booleano privado de cañón; // juzga el campamento del tanque privado booleano en vivo = verdadero; // juzga si el tanque está vivo está vivo static random r = new Random (); // Establecer una variable de valor aleatorio Private static int step = R.NextInt (12) +3; // enemigo del tanque de movimiento aleatorio Pasos 3-14 Private Int Life = 100; // Volumen de salud Bloodbar BB = new BloodBar (); // Cleck // Imageicon icon = new Imageicon ("Res // mytank.jpg"); // Imageicon icon2 = new ImageiCon ("Res // enemyTank.jpg"); // Image Image = icon.getImage (); // Image2 = icon2.getImage (); Tankclient privado TC; // Permisos de clase principal Tank (Int X, Int Y, Boolean Good, Color Color) {super (); this.x = x; this.y = y; this.color = color; this.bood = bueno; } tanque público (int x, int y, bien booleano, color color, directora dir, tankclient tc) {this (x, y, buena, color); 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; } /*Set Tank Camp* / public void setGood (boolean good) {this.good = bueno; } /*Obtener el estado de supervivencia del tanque* / public boolean isLive () {return Live; } /*Establezca el estado de supervivencia del tanque* / public void setLive (boolean live) {this.live = live; } /*Draw Tank* / public void Draw (Graphics g) {if (! Live) {if (! Good) {tc.tanks.remove (this); // Eliminar en el set cuando el tanque enemigo muere // tc.tanks.add (nuevo tanque (R.NextInt (700), R.NextInt (500), falso, color.blue, dirección.d, this.tc)); } devolver; } /*Guardar primero el color del pincel anterior y restaurar el color del pincel después de dibujar* / color c = g.getColor (); // Obtener el color de pincel actual G.SetColor (color); // Coloque el color del cepillo en rojo/*Dibujar tanque*/g.filloval (x, y, con whith, alto); /*Dos métodos para dibujar tanques enemigos y estadounidenses, use las imágenes o colores agregados previamente para distinguir*/// if (bueno) // g.drawimage (imagen, x, y, con whith, high, null); // else // G.DrawImage (Image2, X, Y, Whith, High, Null); if (bueno) bb.draw (g); // Nuestro tanque dibuja la barra de sangre G.SetColor (color.black); /*Dibuja el barril de la pistola a través de la dirección del barril de la pistola*/Switch (Ptdir) {Case L: G.Drawline (X+Tank.Whith/2, Y+Tank.Higth/2, X, Y+Tank.Higth/2); romper; Case Lu: G.Drawline (X+Tank.Whith/2, Y+Tank.Higth/2, X, Y); romper; Caso Ru: G.Drawline (X+Tank.Whith/2, Y+Tank.Higth/2, X+Tank.Whith/2, Y); romper; Caso R: G.Drawline (X+Tank.Whith/2, Y+Tank.Higth/2, X+Tank.Whith, Y+Tank.Higth/2); romper; Case Rd: G.Drawline (X+Tank.Whith/2, Y+Tank.Higth/2, X+Tank.Whith, Y+Tank.Higth); romper; Caso D: G.Drawline (X+Tank.Whith/2, Y+Tank.Higth/2, X, Y+Tank.Higth); romper; } G.SetColor (c); // restaurar el color de color de pincel (); // mover}/*monitoreo del teclado; clave*/ public void keyPressed (keyEvent e) {int key = e.getKeyCode (); // Guardar las teclas escuchadas por el teclado como Integers/*Keyboard Mobile Tank*/Switch (Key) {/*Mover Key*/Case KeyEvent.vk_Up: bu = true; romper; caso KeyEvent.vk_down: bd = true; romper; Case KeyEvent.vk_right: br = true; romper; caso KeyEvent.vk_left: bl = true; romper; } localización (); } /*Monitoreo del teclado; Levante la tecla*/ public void KeyReleaded (KeyEvent E) {int Key = E.getKeyCode (); // Guardar las teclas escuchadas por el teclado como Integers/*Keyboard Moving Tank*/Switch (Key) {Case KeyEvent.vk_up: Bu = false; romper; caso KeyEvent.vk_down: bd = false; romper; caso KeyEvent.vk_right: br = falso; romper; caso KeyEvent.vk_left: bl = false; romper; caso KeyEvent.vk_z: // Bullet Single if (Live) Fire (); romper; Caso KeyEvent.vk_f2: // nuestra resurrección if (! this.live) {this.live = true; this.setLife (100); } romper; case keyEvent.vk_f3: // Enemesis Resurrection fuhuo (); romper; case keyEvent.vk_a: // Invincible Missile superfire (); romper; caso KeyEvent.vk_q: // Recover if (this.live) this.life = 100; romper; case keyEvent.vk_e: // libere el clot de sangre tc.b.fh (); romper; /*Clave de posición de restauración*/ case keyEvent.vk_r: x = 50; y = 50; romper; } localización (); // Dirección de composición}/*Dirección de movimiento de composición*/void ubicación () {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/*Registre la posición del paso anterior*/Oldx = x; viejo = y; switch (dir) {Case L: x- = xspeed; romper; caso lu: x- = xspeed; y- = yspeed; romper; caso u: y- = yspeed; romper; Caso Ru: x+= xspeed; y- = yspeed; romper; Caso R: x+= xspeed; romper; caso rd: x+= xspeed; y+= yspeed; romper; Caso D: Y+= yspeed; romper; case ld: x- = xspeed; y+= yspeed; romper; case ld: x- = xspeed; y+= yspeed; romper; parada de casos: descanso; } /*Juez Movimiento del tanque fuera de los límites (límite del juego)* / if (x <5) x = 5; if (y <25) y = 25; if (x+whith> tc.game_width-5) x = tc.game_width-whith-5; if (y+higth> tc.game_heigth-5) y = tc.game_heigth-higth-5; if (dir! = direction.stop) // Si el tanque no está estacionario, cambie la dirección del barril ptdir = dir; /*El tanque enemigo se mueve automáticamente*/ if (! Good) {Direction [] dirs = Direction.Values (); // Establezca la variable de dirección en una matriz if (step == 0) {step = r.nextint (12) +3; // paso de movimiento aleatorio int randomNumber = R.NextInt (dirs.length); // dirección de movimiento aleatorio dir = dirs [randomNumber]; } paso--; if (R.NextInt (40)> 30) this.fire (); // ¿Se disparan los conchas al azar}}/*resurrección del tanque enemigo*/public void fuhUo () {if (tc.tanks.size () <20) while (true) {int x = r.nextint (700); int y = R.NextInt (500); Tanque t = tanque nuevo (x, y, falso, color.blue, direction.d, tc); /*Si el tanque coincide con la pared, vuelva a calmar la posición hasta que no se superponga el nuevo tanque se agrega al set*/ if (t.getRect (). Intersects (tc.wall1.getRect ()) || t.getRect (). Intersects (tc.wlall2.getRect ()) || t.getRect (). Intersects (tc.wall3.) || t.getRect (). Intersects (tc.wall4.getRect ())) {continuar; } else {tc.tanks.add (t); romper; }}}/*Lanzamiento de balas*/public void fire () {int x = this.x + whith/2 - misil.whith/2; // Controle la dirección de la bala al centro del tanque int y = this.y + higth/2 - misil.higth/2; tc.missiles.add (nuevo misil (ptdir, color, x, y, bueno, tc)); // Cree una nueva clase de bala para unir la colección de balas} /*colisión; Obtenga el rango del tanque*/ public rectangle getRect () {return new rectangle (x, y, whith, higth); } /*La posición de paso anterior del recibo* / private nulo stay () {x = oldx; y = viejo; } /*Si presiona la pared, llame al método de estadía y vuelva a la posición del paso anterior* / public Boolean Hitwall (wall w) {if (this.live && this.getRect (). Intersects (w.getRect ())) {this.stay (); devolver verdadero; } return false; } /*Evento de colisión de tanque* / public boolean hittanks (List <Tank> Tanks) {for (int i = 0; i <tanks.size (); i ++) {tank t = tanks.get (i); if (this! = t) {// no puede cazar consigo mismo/*Si chocan, regrese a la posición anterior*/if (this.live && t.islive () && this.getRect (). Intersects (t.getRect ())) {this.stay (); t.stay (); devolver verdadero; }} return false; } /*Función de emisión con dirección de fuego* / Fuego de misiles públicos (dirección de dirección) {if (! Live) return null; int x = this.x+whith/2-misil.whith/2; int y = this.y+higth/2-misil.higth/2; Misil m = nuevo misil (dir, color, x, y, bueno, this.tc); tc.missiles.add (m); regresar m; } /*Misil superfire* / private void superfire () {direction [] dirs = direction.values (); for (int i = 0; i <8; i ++) {fire (dirs [i]); // ciclismo ocho direcciones}}/*Se agregó clase de clots de sangre*/private class BloodBar {/*Draw Blood Bar*/public void Draw (Graphics g) {color c = g.getColor (); G.SetColor (Color.Red); G.Drawrect (x, y-10, con whith, 10); int w = whith*vida/100; G.FillRect (X, Y-10, W, 10); G.SetColor (C); }} /*Método de comidas de sangre* / public boolean eatblood (sangre b) {if (this.live && b.islive () && this.isgood () && this.getrect (). Intersects (b.getRect ())) {this.setLife (100); B.SetLive (falso); devolver verdadero; } if (this.getRect (). Intersects (tc.wb.getRect ()))) this.life = 100; devolver falso; }}Misil.java
import java.awt.color; import java.awt.graphics; import java.awt.rectangle; import java.util.list; public class Missile { /*Bullet Data* / Tank.Direction Dir; // Color de dirección de bala C; // color de bala int x, y; // Posición de bala pública estática final int xspeed = 15; // Velocidad de movimiento de longitud pública estática final int yspeed = 15; // Velocidad de movimiento de longitud pública estática final int whith = 10; // Ancho de bala Pública estática final int higth = 10; // Bullet High Private Boolean Live = True; // juzga la supervivencia del bien de la bala privada booleana; // juzga la bala y el campamento privado Tankclient TC; // Permisos de clase principal misil público (tank.direction dir, color c, int x, int y) {super (); this.dir = dir; this.x = x; this.y = y; this.c = c; } MISIAL PÚBLICO (Tank.Direction Dir, Color C, Int X, Int Y, Boolean Good, Tankclient TC) {this (dir, c, x, y); this.bood = bueno; this.tc = tc; } /*Obtenga la supervivencia de la bala* / public boolean islive () {return Live; } /*Establezca la supervivencia de la bala* / public void setLive (boolean live) {this.live = live; } public void Draw (Graphics g) { /*Si la bala muere, elimine la bala en la colección de balas* / if (! live) {tc.missiles.remove (esto); // Eliminar la devolución en la colección; } /*Guardar primero el color del pincel anterior y restaurar el color del pincel después de dibujar* / color d = g.getColor (); // Obtener el color del pincel actual G.SetColor (C); // establecer el color del cepillo en rojo/*imprimir bala*/g.filloval (x, y, con whith, alto); G.SetColor (D); // Restaurar el color de color del pincel (); // Move} public void Move () {/*juzga la dirección de movimiento y la posición del tanque*/switch (dir) {case l: x- = xspeed; romper; caso lu: x- = xspeed; y- = yspeed; romper; caso u: y- = yspeed; romper; Caso Ru: x+= xspeed; y- = yspeed; romper; Caso R: x+= xspeed; romper; caso rd: x+= xspeed; y+= yspeed; romper; Caso D: Y+= yspeed; romper; case ld: x- = xspeed; y+= yspeed; romper; parada de casos: descanso; } /*Juzga la situación saliente de la bala; Si sale, la bala morirá, la eliminará en la colección de balas*/ if (x <0 || y <0 || x> tankclient.game_width || y> tankclient.game_heigth) live = false; } /*Colisión; Obtenga el rango de la bala*/ public rectangle getRect () {return new rectangle (x, y, whith, higth); } /*Proceso de colisión entre balas y tanques* /public boolean hittank (tanque t) { /*Si la bala y el tanque están en el mismo rango, la bala y el tanque morirán al mismo tiempo; y la bala solo puede matar al tanque del oponente*/if (this.live && this.getrect (). intersects (t.getrect ()) && t.islive () && this.good! = t.isgood ()) {if (t.isgood ()) {// buen tanque/*nuestro tanque reducirá los puntos de salud cuando se ve T.SetLife (t.getLife ()-20); if (t.getLife () <= 0) t.setLive (falso); } else {// Bad Tank T.SetLive (false); // Death} this.live = false; // Bullet Death tc.explode.add (new Explode (x, y, tc)); // nueva explosión agregar set return true; } return false; } /*El tanque de colapso se establece para juzgar la colisión de balas* / public boolean hittanks (list <kank> tanks) {for (int i = 0; i <tanks.size (); i ++) {if (hittank (tanks.get (i))) return true; } return false; } /*El proceso de colisión entre balas y pared* / public Boolean Hitwall (Wall W) { /*Si el rango de balas y la pared se superpone con la muerte de la bala* / if (this.live && this.getRect (). Intersects (w.getRect ()) {this.live = false; // Bullet Death Return True; } return false; }} Wall.java
import java.awt.graphics; import java.awt.rectangle; public class wall { /*wall data* / int x, y, w, h; // Posición y ancho y altura Tank Client TC; // Permisos de clase principal Public Wall (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; } /*Obtenga el alcance de la pared* / public rectangle getRect () {return new rectangle (x, y, w, h); } /*Draw Wall* / public void Draw (Graphics g) {G.Fillrect (x, y, w, h); }}Explotar.java
import java.awt.color; import java.awt.graphics; public class Explode { /*Tank Explosion Attribute* / int x, y; // Posición de explosión boolean privado live = true; // ¿Hay una explosión int step = 0; // Control de tiempo de explosión int [] diámetro = nuevo int [] {4, 7, 12, 18, 26, 32, 49, 56, 65, 77, 80, 50, 40, 30, 14, 6}; // explosion rango de tanque privado Tankclient TC; // Permiso de clase principal Public Explode (int x, int y, tankclient tc) {super (); this.x = x; this.y = y; this.tc = tc; } /*Dibujar explosión* / public void Draw (Graphics g) {if (! Live) return; // Si el estado de muerte por explosión no termina/*Si termina el tiempo de explosión, la explosión no existe y la elimina en el conjunto*/if (step == diameter.length) {live = false; // Paso de muerte de explosión = 0; // El tiempo de paso es 0 tc.explode.remove (esto); // Eliminar retorno en el conjunto; } /*Dibujar explosión* / color c = g.getColor (); G.SetColor (color.orange); G.Filloval (x, y, diámetro [paso], diámetro [paso]); G.SetColor (C); paso ++; }}Sangre.java
import java.awt.color; import java.awt.graphics; import java.awt.rectangle; import java.util.random; public class Blood {/* Datos de coágulos de sangre*/ int x, y, w, h; // ubicación de clot de sangre y tamaño de tanque privado TC; TC; // Permiso de clase principal Boolean privado live = true; // Blood Clat Supervival Private Static Random r = new Random (); // Establezca una variable de valor aleatorio/* Obtenga el estado de supervivencia del clot de sangre*/ public boolean isLive () {return live; } /* Establezca el estado de supervivencia del coágulo de sangre* / public void setLive (boolean live) {this.live = live; } /*El valor inicial de la posición del coágulo de sangre es aleatoriamente un valor* / public Blood () {x = R.NextInt (600) +100; y = R.NextInt (400) +100; w = h = 15; } /*Dibuje el clot de sangre* / public void Draw (Graphics g) {if (! Live) return; Color c = g.getColor (); G.SetColor (color.magenta); G.FillRect (x, y, w, h); G.SetColor (C); } /*Release Blood Clot* / public void fh () {if (! Live) {x = R.NextInt (600) +100; y = R.NextInt (400) +100; en vivo = verdadero; }} /*Obtenga el rango de coágulos de sangre* / public rectangle getRect () {return new rectangle (x, y, w, h); }}Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.