Use coleções, balanços, tópicos e outros pontos de conhecimento na língua Java para escrever um jogo de guerra de tanques.
(1) Desenhe o princípio dos tanques inimigos e dos EUA:
Há uma variável do tipo booleano boa dentro da classe de tanques. Usado para julgar o acampamento de um tanque. Ao criar um objeto de tanque, o valor do bem é passado no método de construção da classe de tanques. Ao desenhar tanques, julgue o valor do bem e distingue a cor do inimigo e nós;
(2) Princípio do movimento do tanque:
O evento de resposta da imprensa do teclado do monitor é escrito na classe de tanques, as teclas monitoradas para cima, para baixo, esquerda e direita são gravadas e as variáveis em oito direções do movimento do tanque são sintetizadas. Em seguida, as alterações correspondentes nos valores das coordenadas do tanque X e Y em cada direção podem ser feitas para alcançar o movimento do nosso tanque. Os tanques inimigos se movem automaticamente, circulando aleatoriamente na direção do movimento do tanque inimigo através de um número aleatório e produzindo aleatoriamente o número de vezes cada movimento. A combinação de dois valores aleatórios permite o movimento dos tanques inimigos.
(3) Princípio das balas de lançamento de tanques:
Através do monitoramento do teclado, depois de detectar o comando de bala, adicione uma classe de bala à coleção de classe de bala da classe principal. Transfira a direção do cano da arma, a posição do tanque e o acampamento do tanque para as balas. No método principal de desenho de tinta, a coleção de balas será ciclada. Se houver balas no set, retire -as. Isso permite o lançamento de balas.
(4) O princípio de colisão de tanques, balas e paredes:
Na classe de parede do tipo bala do tipo tanque, o método GetRect para obter seu próprio alcance e, em seguida, executar a detecção de colisão correspondente toda vez que o tanque e a bala são desenhados (existem métodos para colisão com a parede e o tanque fora do tanque no tanque e, na bala, existem métodos para colisão com o tanque e o tanque.). Se o alcance de si mesmo e do objeto que não deve ser colidido, significa que os dois objetos colidem.
(5) O princípio da circulação sanguínea do tanque:
Se os coágulos sanguíneos colidirem com o nosso tanque, os coágulos sanguíneos morrerão e os coágulos sanguíneos serão totalmente recuperados.
(6) O princípio da ressurreição do tanque:
Depois de detectar a ordem da ressurreição do nosso tanque pelo monitoramento do teclado, se nosso tanque estiver em um estado morto, nosso status de inventário de tanques será alterado para vivo e o volume de sangue do nosso tanque será restaurado à saúde total.
Idéias de programação:
A idéia de programação da Guerra do Tank abre um tópico na classe principal e não pedal a 50 milissegundos para desenhar o método (desenhe tudo em toda a interface). As coisas desenhadas incluem tanques inimigos (distinção colorida), balas, paredes, coágulos sanguíneos e explosões. Assim, no total, várias categorias foram escritas: tanques de tanques, balas de mísseis, paredes de parede, coágulos sanguíneos e classes principais do tanque. Em cada classe, existe um método de desenho escrito para realizar a função de desenho dos atributos desta classe. Há um evento de escuta no teclado na classe principal chamada Teclado de Escuta desta classe de tanques. Através do monitoramento do teclado, é determinado que o movimento correspondente do tanque é feito, enquanto o tanque inimigo está se movendo aleatoriamente. E toda vez que a atualização é atualizada, vários métodos de colisão são chamados para determinar a situação de alguns objetos que não devem ser colididos. A criação de cada objeto, como balas, é adicionar uma nova classe de bala a uma coleção de classes de bala depois de acionada. Ao desenhar, determine o número no conjunto para desenhar. Se o tanque estiver fora dos limites ou matar o tanque, ele será excluído no conjunto. Outras categorias também são semelhantes, então não vou entrar em detalhes.
Cada etapa do código tem uma explicação correspondente.
Tankclient.java
importar java.awt.color; importar java.awt.font; importar java.awt.graphics; importar java.awt.image; importar java.awt.event.keyAdApter; import.wadapter; importawt.event.keyevent; import.event.event.wadapter; importapter; java.util.ArrayList; importar java.util.list; importar javax.swing.jframe; classe pública tankclient estende jframe { / ** * @param args * / imagem OFSCRENNIMAGE = NULL; // armazenamento de imagem de memória de buffer duplo/*tamanho do jogo*/public static final int game_width = 800; // interface de largura public static final int game_heigth = 600; // tanque de alta interface mytank = novo tanque (500.400, true, color.red, tank.direction.stop, isso); // Nossa lista de tanques <missile> mísseis = new ArrayList <missile> (); // Coleção de balas na lista <plodle> exploit = new ArrayList <plorsod> (); // lista de tanques do conjunto de explosão <dank> = new ArrayList <tank> (); // parede de parede do conjunto de tanques1 = nova parede (150.200.20.300, isso); // parede 1 parede de parede2 = nova parede (250.500.300,20, isso); // Parede 2 parede da parede3 = nova parede (650.200.20.300, isso); // parede de parede 2 parede4 = nova parede (250.300.300,20, isso); // parede 2 parede wb = nova parede (750,550,40,40, isso); // Wall2 Blood B = novo sangue (); // Blood classe public static void main (string [] args) {// TODO Método Auto-Generado Stub TankClient tc = new TankClient (); tc.lauchframe (); } private void lauchframe () {// TODO Método Gerado Método Stub para (int i = 0; i <10; i ++) {tanks.add (novo tanque (50+40*(i+1), 50, falso, cor.blue, tank.direction.d, this)); } this.setLocation (100, 100); // Janela de coordenadas inicial Ponto este.SetSize (game_width, game_heigth); // janela tamanho inicial this.settitle ("tankwar"); // Nome da janela/*ENOÇÃO DE JANEIRA*/this.addwindowlistener (new WindonAdapter () {@Override/*Execute após o ponto sai do garfo*/public void Windowclosing (WindowEvent e) {// TODO Método Auto-Generated Stub System.exit (0); // Exit}}); this.addkeyListener (new Keymoniton ()); // defina o teclado para ouvir isso.setVisible (true); // Defina a janela para exibir isso.SetResizable (false); // Defina a janela para não alterar o tamanho. // Defina a cor do primeiro plano da janela como um novo thread verde (new PaintThread ()). Start (); // Inicie a classe PaintThread Run} @Override public void Paint (gráficos g) {// TODO Method Auto-Generated Stub // Graphics é a classe Brush Super.paint (g); mytank.draw (g); Wall1.Draw (G); parede2.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); /*Coleção de balas de ciclo*/ for (int i = 0; i <missiles.size (); i ++) {míssil m = missiles.get (i); // Obtenha a bala atual M.Hittancs (tanques); // Sua própria bala mata o tanque inimigo M.Hitwall (Wall1); // Bullet e Wall M.Hitwall (Wall2); M.Hitwall (Wall3); M.Hitwall (Wall4); M.Hittank (mytank); // Bullet inimigo atinge seu próprio tanque M.Draw (G); // desenhar bullet} para (int i = 0; i <explore.size (); i ++) {exploit.get (i) .draw (g); // desenhe explosão} para (int i = 0; i <tanks.size (); i ++) {tank t = tanks.get (i); T.Draw (G); // desenha tanques inimigos t.hittancs (tanques); T.Hitwall (Wall1); // tanques e paredes t.hitwall (parede2); T.Hitwall (Wall3); T.Hitwall (Wall4); } //g.setFont(new font ("宋体", font.bold, 20)); G.DrawString ("Mísseis contam:"+missiles.size (), 10, 50); // Mostra G.DrawString ("Contagem de explosão:"+explode.size (), 10, 80); // Mostra G.DrawString ("Contagem de tanques:"+tanks.size (), 10, 110); G.DrawString ("Mytank Life:"+MyTank.getLife (), 10, 130); G.DrawString ("Recuperação de sangue:", 750, 540); G.DrawString ("Direção do movimento da chave do diretório; E: libere o sangue rápido", 10, 590); G.DrawString ("Z: Lançar Dongfeng-31; A: Lançar Dongfeng-41;", 10, 570); G.DrawString ("F2: Ressurreição; F3: Ressurreição do Inimigo (ao máximo 20)", 10, 550); G.DrawString ("R: Restauração da posição; Q: cheia de sangue", 10, 530); } @Override /*RepiAnt-> Update-> Paint* / public void update (gráfico g) {// TODO Método Auto-Generado Stub Super.Update (G); if (OFFSCRENNIMAGE == NULL) OFFSCRENNIMAGE = this.createImage (game_width, game_heigth); Gráficos goffscrenn = OfScrennimage.getGraphics (); // Defina uma cor de escova de memória para a imagem da imagem em primeiro plano C = GoffScrenn.getColor (); // salve a cor do primeiro plano primeiro, GoffScrenn.setColor (color.green); // Defina a cor do pincel de memória como Green goffscrenn.fillrect (0, 0, game_width, game_heigth); // desenha a imagem como o tamanho do tamanho do jogo GoffScrenn.setColor (c); // restaurar a cor G.Drawimage (OfScrennimage, 0, 0, NULL); // desenha a imagem salva na tinta da interface (Goffscrenn); // Ligue para o pincel de memória para pintar} classe privada Paintthread implementa Runnable {@Override public void run () {// TODO Auto-Generated Method Stub while (true) {repont (); // Execute o pedido de reação-> atualização-> pintura tente {thread.sleep (50); // Atualize a tela a cada 50 milissegundos} Catch (Exceção e) {E.PrintStackTrace (); }}}} /*Resposta do teclado* / classe privada Keymoniton estende KeyAdapter { /*Pressione a resposta do teclado* / @Override public void KeyPressed (KeyEvent E) {// TODO Método Auto-Gerado Stub Super.keyPended (e); myTank.keyPepred (e); } /*Rise a resposta do teclado* / @Override public void keyreLeardeed (KeyEvent e) {// TODO Method Auto-Gerated Stub Super.KeyRelatearde (e); mytank.keyRelEase (e); }}}Tank.java
importar java.awt.color; importar java.awt.graphics; importar java.awt.image; importar java.awt.rectangle; importar java.awt.event.keyevent; import java.util.list; import java.util.random; importar javax.swing.imageicon; Coordena o Private Int Oldx, Oldy; // tanque coordenadas anteriores Public Static final int whith = 30; // Largura do tanque Public Static final int higth = 30; // tanque high público estático final int xSpeed = 5; // comprimento da velocidade do movimento direcional Public Static final Int yspeed = 5; // Velocidade de movimento de longarogue Cor de cor privada; // cor do tanque private boolean bl = false, bu = false, br = false, bd = false; // Valores de controle de quatro direção enumes de direção {l, lu, u, ru, r, rd, d, ld, stop}; // O movimento de oito direções é composto por quatro valores de direção private Direction Dir = Direction.Stop; // Direção de saída Direção privada Ptdir = Direction.D; // Direção original do canhão Private Boolean Good; // julga o acampamento do tanque Private Boolean Live = True; // julga se o tanque está vivo estático privado aleatório r = novo aleatório (); // defina uma variável de valor aleatório private estático int step = r.nextint (12) +3; // Tanque inimigo Movimento aleatório etapas 3-14 Private int vidas = 100; // volume de saúde Private BloodBar BB = New Bloodbar (); // Cleck // Imageicon ICON = new Imageicon ("res // mytank.jpg"); // imageicon icon2 = new imageicon ("res // inimytank.jpg"); // imagem de imagem = icon.getImage (); // imagem imagem2 = icon2.getimage (); Tankclient privado TC; // Classe Principal Permissões Public Tank (Int X, Int Y, Boolean Good, Color Color) {super (); this.x = x; this.y = y; this.color = cor; this.good = bom; } tanque público (int x, int y, booleano bom, cor cor, direção dir, tankclient tc) {this (x, y, boa, cor); this.dir = dir; this.tc = tc; } /*Obtenha a saúde do tanque* / public int getLife () {retornar vida; } /*Defina a saúde do tanque* / public void setLife (int vida) {this.life = Life; } /*Obtenha o tanque acampamento* / public boolean isgood () {return Good; } /*Definir acampamento de tanque* / public void setGood (booleano bom) {this.good = bom; } /*Obtenha status de sobrevivência do tanque* / public boolean islive () {return Live; } /*Defina o status de sobrevivência do tanque* / public void setLive (boolean Live) {this.live = Live; } /*Draw Tank* / public void desenho (gráficos g) {if (! Live) {if (! Good) {tc.tanks.remove (this); // exclua no conjunto quando o tanque inimigo morrer // tc.tanks.add (novo tanque (r.nextint (700), r.nextint (500), false, color.blue, direção.d, this.tc)); } retornar; } /*Salve a cor do pincel anterior primeiro e restaure a cor do pincel após o desenho* / color c = g.getColor (); // Obtenha a cor da pincel atual G.setColor (cor); // Defina a cor da escova como vermelha/*Draw tank*/g.Filoval (x, y, whith, alto); /*Dois métodos para desenhar tanques inimigos e americanos, use as imagens ou cores adicionadas anteriormente para distinguir*/// se (bom) // g.drawimage (imagem, x, y, whith, alto, nulo); // else // g.drawimage (imagem2, x, y, whith, alto, nulo); se (bom) bb.draw (g); // nosso tanque desenha barra de sangue G.SetColor (color.black); /*Desenhe o cano da arma através da direção do barril de armas*/switch (ptdir) {case l: g.drawline (x+tank.whith/2, y+tank.higth/2, x, y+tank.higth/2); quebrar; case lu: g.drawline (x+tank.whith/2, y+tank.higth/2, x, y); quebrar; case ru: g.drawline (x+tank.whith/2, y+tank.higth/2, x+tank.whith/2, y); quebrar; Caso R: G.Drawline (x+tanque.whith/2, y+tank.higth/2, x+tank.whith, y+tank.higth/2); quebrar; case rd: g.drawline (x+tank.whith/2, y+tank.higth/2, x+tank.whith, y+tank.higth); quebrar; Caso D: G.Drawline (x+tank.whith/2, y+tank.higth/2, x, y+tank.higth); quebrar; } g.setColor (c); // restaurar a cor de cor de pincel (); // mover}/*monitoramento do teclado; chave*/ public void KeyPressed (KeyEvent e) {int key = e.getKeyCode (); // Salvar as teclas ouvidas pelo teclado como números inteiros/*Tanque móvel de teclado*/switch (tecla) {/*move tecla*/case keyEvent.vk_up: bu = true; quebrar; case keyevent.vk_down: bd = true; quebrar; case keyevent.vk_right: Br = true; quebrar; case keyevent.vk_left: bl = true; quebrar; } localizador (); } /*Monitoramento do teclado; Levante a chave*/ public void keyreLeardeed (keyEvent e) {int key = e.getKeyCode (); // Salvar as teclas ouvidas pelo teclado como números inteiros/*Tanque de movimento do teclado*/switch (tecla) {case keyEvent.vk_up: Bu = false; quebrar; case keyevent.vk_down: bd = false; quebrar; case keyevent.vk_right: Br = false; quebrar; case keyevent.vk_left: bl = false; quebrar; case keyevent.vk_z: // bullet única if (vive) fogo (); quebrar; case keyevent.vk_f2: // nossa ressurreição if (! this.live) {this.live = true; this.setLife (100); } quebrar; case keyevent.vk_f3: // resurrection fuhuo (); quebrar; case keyevent.vk_a: // Invincible Missile Superfire (); quebrar; case keyevent.vk_q: // recuperar se (this.live) this.life = 100; quebrar; case keyevent.vk_e: // Libere o coágulo sanguíneo tc.b.fh (); quebrar; /*Chave de posição de restauração*/ case keyEvent.vk_r: x = 50; y = 50; quebrar; } localizador (); // Direção de composição}/*Direção do movimento da composição*/void localizado () {if (bl &&! Bu &&! Br &&! Bd) dir = direction.l; caso contrário, se (bl && bu &&! br &&! bd) dir = direção.lu; caso contrário, if (! BL && bu &&! bd) dir = direction.u; caso contrário, if (! BL && bu && br &&! bd) dir = direction.ru; caso contrário, if (! bl &&! bu && br &&! bd) dir = direção.r; caso contrário, se (! bl &&! bu && br && bd) dir = direção.rd; caso contrário, if (! bl &&! bu &&! br && bd) dir = direção.d; caso contrário, if (! bl &&! bu &&! br && bd) dir = direção.ld; caso contrário, if (! BL &&! bu &&! bd) dir = direction.stop; } void move () {// move/*Registre a posição da etapa anterior*/oldx = x; Oldy = y; switch (dir) {case l: x- = xspeed; quebrar; case lu: x- = xspeed; y- = yspeed; quebrar; caso u: y- = yspeed; quebrar; case ru: x+= xspeed; y- = yspeed; quebrar; Caso R: X+= Xspeed; quebrar; case rd: x+= xspeed; y+= yspeed; quebrar; caso d: y+= yspeed; quebrar; case ld: x- = xspeed; y+= yspeed; quebrar; case ld: x- = xspeed; y+= yspeed; quebrar; Parada do caso: quebra; } /*Juiz o movimento do tanque fora dos limites (limite do jogo)* / 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) // Se o tanque não estiver estacionário, altere a direção do barril ptdir = dir; /*Tanque inimigo se move automaticamente*/ if (! Bom) {direção [] dirs = direction.values (); // Defina a variável de direção para uma matriz se (passo == 0) {step = r.NextInt (12) +3; // Etapa de movimento aleatório int RandomNumber = R.NextInt (Dirs.Length); // Direção de movimento aleatório Dir = Dirs [RandomNumber]; } etapa--; if (r.nextint (40)> 30) this.fire (); // As conchas são disparadas aleatoriamente}}/*Ressurreição do tanque inimigo*/public void fuhuo () {if (tc.tanks.size () <20) while (true) {int x = r.nextint (700); int y = r.nextint (500); Tanque t = novo tanque (x, y, falso, color.blue, direção.d, tc); /*Se o tanque coincide com a parede, a posição re-random até que não se sobreponda, o novo tanque é adicionado ao conjunto*/ if (t.getRect (). || t.getRect (). Intersecta (tc.wall4.getRect ())) {continuação; } else {tc.tanks.add (t); quebrar; }}}/*Lançamento da bala*/public void Fire () {int x = this.x + whith/2 - míssil.whith/2; // Controle a direção da bala para o meio do tanque int y = this.y + higth/2 - míssil.higth/2; tc.missiles.add (novo míssil (ptdir, cor, x, y, bom, tc)); // Crie uma nova classe de bala para ingressar na coleção de balas} /*colisão; Obtenha o alcance do tanque*/ retângulo público getRect () {retorna novo retângulo (x, y, whith, higth); } /*A posição de passo anterior do recibo* / private void stay () {x = Oldx; y = Oldy; } /*Se você acertar a parede, chame o método Stay e retorne à posição de passo anterior* / public boolean hitwall (parede w) {if (this.live && this.getRect (). retornar true; } retornar false; } /*Evento de colisão do tanque* / public boolean hittanks (list <tank> tanks) {for (int i = 0; i <tanks.size (); i ++) {tank t = tanks.get (i); se (this! = t) {// você não pode colidir consigo mesmo/*Se colidir, retorne à posição anterior*/if (this.live && t.islive () && this.getRect (). T.Stay (); retornar true; }} retornar false; } /*Função de emissão com direção de fogo* / Fire de mísseis públicos (direção dir) {if (! LIVE) retorna nulo; int x = this.x+whith/2 missile.whith/2; int y = this.y+higth/2 missile.higth/2; Míssil m = novo míssil (dir, cor, x, y, bom, this.tc); tc.missiles.add (m); retornar m; } /*Mísseis superfire* / private void superfire () {direção [] dirs = direction.values (); para (int i = 0; i <8; i ++) {fogo (dirs [i]); // ciclando oito direções}}/*Adicionado classe de coagulação sanguínea*/classe privada Bloodbar {/*desenhe barra de sangue*/public void Draw (gráficos g) {cor c = g.getColor (); g.setColor (color.red); G.Drawrect (X, Y-10, Whith, 10); int w = whith*vida/100; G.FillRect (X, Y-10, W, 10); g.setColor (c); }} /*método de comer sangue* / public boolean Eatblood (sangue b) {if (this.live && b.islive () && this.isgood () && this.getRect (). B.SetLive (falso); retornar true; } if (this.getRect (). Intersecta (tc.wb.getRect ()))) this.life = 100; retornar falso; }}Míssil.java
importar java.awt.color; importar java.awt.graphics; importar java.awt.rectangle; importar java.util.list; míssil de classe pública { /*dados de bala* / tank.direction dir; // Direção da bala cor C; // cor de bala int x, y; // Posição da bala public static final int xSpeed = 15; // Velocidade de movimento de comprimento Public Static final Int yspeed = 15; // Velocidade de movimento de comprimento Public Static final int whith = 10; // largura de bala public static final int higth = 10; // Bullet High Private Boolean Live = True; // julga a sobrevivência do bom booleano privado; // julga a bala e o acampamento privado tankclient tc; // Mísseis públicos de permissões de classe principal (tank.direction dir, color c, int x, int y) {super (); this.dir = dir; this.x = x; this.y = y; this.c = c; } míssil público (tank.direction dir, cor c, int x, int y, boolean bom, tankcient tc) {this (dir, c, x, y); this.good = bom; this.tc = tc; } /*Obtenha a sobrevivência da bala* / public boolean islive () {return Live; } /*Defina a sobrevivência da bala* / public void setLive (boolean Live) {this.live = Live; } public void Draw (gráficos g) { /*Se a bala morrer, exclua a bala na coleção de balas* / if (! LIVE) {tc.missiles.remove (this); // excluir o retorno da coleção; } /*Salve a cor do pincel anterior primeiro e restaure a cor do pincel após o desenho* / color d = g.getColor (); // Obtenha a cor da pincel atual G.SetColor (C); // Defina a cor da escova como vermelha/*Imprima bala*/g.FILLOVAL (x, y, whith, alto); g.setColor (d); // restaurar o movimento da cor do pincel (); // move} public void move () {/*julgue a direção do movimento e a posição do tanque*/switch (dir) {case l: x- = xspeed; quebrar; case lu: x- = xspeed; y- = yspeed; quebrar; caso u: y- = yspeed; quebrar; case ru: x+= xspeed; y- = yspeed; quebrar; Caso R: X+= Xspeed; quebrar; case rd: x+= xspeed; y+= yspeed; quebrar; caso d: y+= yspeed; quebrar; case ld: x- = xspeed; y+= yspeed; quebrar; Parada do caso: quebra; } /*Julgue a situação de saída da bala; Se a saída, a bala morrerá, exclua -a na coleção de balas*/ if (x <0 || y <0 || x> tankclient.game_width || y> tankclient.game_heigth) vive = false; } /*Colisão; Obtenha o alcance da bala*/ retângulo público getRect () {retorna novo retângulo (x, y, whith, higth); } /*Processo de colisão entre balas e tanques* /public boolean hittank (tanque t) { /*se a bala e o tanque estiverem no mesmo alcance, a bala e o tanque morrerão ao mesmo tempo; e a bala só pode matar o tanque do oponente*/if (this.live && this.getRect (). cruza (t.getRect ()) && t.islive () && this.good! = t.isgood ()) {if (t.isgood) {// bom tanque/*tanques hits) {if (t.isgood) {// bom tanque/*tanques will) t.setLife (t.getLife ()-20); if (t.getLife () <= 0) t.setLive (false); } else {// tanque ruim t.setLive (false); // Death} this.live = false; // Death Bullet tc.explode.add (new Explode (x, y, tc)); // nova explosão Adicionar Definir Return true; } retornar false; } /*Conjuntos de tanques de colapso para julgar a colisão da bala* / public boolean hittanks (list <tank> tanks) {for (int i = 0; i <tanks.size (); i ++) {if (hittank (tanks.get (i))) retornar true; } retornar false; } /*O processo de colisão entre balas e parede* / public boolean hitwall (parede w) { /*se o alcance de balas e parede se sobrepõe à morte da bala* / se (this.live && this.getRect (). // Death Bullet Death Return True; } retornar false; }} Wall.java
importar java.awt.graphics; importar java.awt.rectangle; public class Wall { /*Dados da parede* / int x, y, w, h; // Posição e largura e altura Tankclient Private Client; // Principais permissões de classe 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; } /*Obtenha o escopo da parede* / retângulo público getRect () {retorna novo retângulo (x, y, w, h); } /*Desenhe Wall* / public void Draw (gráficos g) {G.FillRect (x, y, w, h); }}Explode.java
importar java.awt.color; importar java.awt.graphics; public class explode { /*attributo da explosão do tanque* / int x, y; // Posição de explosão Private boolean Live = true; // existe uma explosão int step = 0; // Explosion Time Control Int [] Diâmetro = new int [] {4, 7, 12, 18, 26, 32, 49, 56, 65, 77, 80, 50, 40, 30, 14, 6, 6}; // Faixa de explosão Tankclient TCCLIENT TC; // Principal de permissão da classe Public explode (int x, int y, tankclient tc) {super (); this.x = x; this.y = y; this.tc = tc; } /*Desenhe explosão* / public void Draw (gráficos g) {if (! Live) retornar; // Se o estado da morte de explosão não terminar/*Se o tempo de explosão terminar, a explosão não existe e a exclua no conjunto*/if (step == diâmetro.length) {vive = false; // Explosion Death Step = 0; // O tempo de passo é 0 tc.explode.remove (this); // excluir retorno no conjunto; } /*Desenhe explosão* / color c = g.getColor (); g.setColor (color.orange); G.Filloval (X, Y, Diâmetro [Etapa], Diâmetro [Etapa]); g.setColor (c); Etapa ++; }}Blood.java
importar java.awt.color; importar java.awt.graphics; importar java.awt.rectangle; importar java.util.random; public classe Blood {/* Dados do coagueiro sanguíneo*/ int x, y, w, h; // localização e tamanho de tanque privado tccient tc; // permissão de classe principal Private boolean LIVE = true; // sobrevivência do coágulo sanguíneo estático privado Random r = novo aleatório (); // Defina uma variável de valor aleatório/* Obtenha o status de sobrevivência do coágulo sanguíneo*/ public boolean islive () {return Live; } /* Defina o status de sobrevivência do coágulo sanguíneo* / public void setLive (boolean Live) {this.live = Live; } /*O valor inicial da posição do coágulo sanguíneo é aleatoriamente um valor* / public sangue () {x = r.nextint (600) +100; y = r.nextint (400) +100; w = h = 15; } /*Desenhe coaguleiro de sangue* / public void Draw (gráficos g) {if (! LIVE) retornar; Cor c = g.getColor (); g.setColor (color.magenta); G.FillRect (X, Y, W, H); g.setColor (c); } /*Libere o coágulo sanguíneo* / public void fh () {if (! LIVE) {x = r.NextInt (600) +100; y = r.nextint (400) +100; vive = true; }} /*Obtenha a faixa de coágulo sanguíneo* / public retângulo getRect () {retorna novo retângulo (x, y, w, h); }}O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.