For details please refer to the note, here is not much nonsense, to achieve a childhood classic.
Blood.java
Package Com.hkm.TankWar;
Import java.awt.*; /** * Blood clots, our tanks eat can gyrus; * @author hekangmin * */public class Blood {private int x,y,w,h;//the position and width of the blood clot; private T
Ankwarclient TC;
private int step=0;//records the number of steps the blood clot moves; private Boolean live=true;
public Boolean islive () {return live;
public void Setlive (Boolean live) {this.live = live; /** * Record the position of the blood clot; * * Private int[][] pos={{400,300},{400,320},{420,320},{440,300},{440,330},{480,400},{520,
400},{540,400}};
Public Blood () {x=pos[0][0];
Y=POS[0][1];
w=h=18;
public void Draw (Graphics g) {if (!live) return;
Color C=g.getcolor ();
G.setcolor (Color.cyan);
G.filloval (x, Y, W, h);
G.setcolor (c);
Move ();
/** * Moving blood clots/public void Move () {step++;
if (step>=pos.length) step=0;
else{X=pos[step][0];
Y=POS[STEP][1]; } public Rectangle GetRect () {return new Rectangle x,Y,W,H); }
}
Explode.java
Package Com.hkm.TankWar;
Import java.awt.*;
/**
* Explosion class * @author hekangmin * * */public
class Explode {
private int x,y;//where
the explosion occurred Private Boolean live=true;
The int dia[]={4,8,12,16,32,40,20,14,4};//is modeled with a garden, representing the diameter of the circle, and the
int step=0;//The difference to the first few diameters
private tankwarclient tc;// Hold reference to public
Explode (int x,int y,tankwarclient tc)
{
this.x=x;
this.y=y;
THIS.TC=TC;
}
public void Draw (Graphics g)
{
if (! Live)
{
tc.explodes.remove (this);
return;
}
if (step==dia.length)//if to the last diameter explosion dies;
{
live=false;
Step=0;
return;
}
Color C=g.getcolor ();
G.setcolor (color.yellow);
G.filloval (x, Y, Dia[step], dia[step]);
G.setcolor (c);
step++
}
}
Missile.java
Package Com.hkm.TankWar;
Import java.awt.*;
Import java.awt.event.*;
Import java.awt.event.KeyEvent;
Import java.util.List; /** * @author hekangmin * */public class missile {private int x,y;//bullets location private tank.direction dir;
Tank direction private static final int xspeed=10;//tank x direction moving speed, private static final int yspeed=10;//tank y-direction moving speed,
public static final int width=10;
public static final int height=10;
Private Boolean live=true;//judge whether the Bullets alive private Boolean good;//distinguish enemy bullets and our bullets private tankwarclient TC;
Public missile (int x, int y, tank.direction dir) {this.x = x;
This.y = y;
This.dir = dir;
Missile (int x,int y,boolean good,tank.direction dir,tankwarclient tc) {this (x,y,dir);
this.good=good;//the property of the tank is the same as the bad property of the bullet; THIS.TC=TC; /** * Draw Bullets * @param g is the brush/public void Draw (Graphics g) {if (!
Live) {tc.missiles.remove (this); ReTurn
Color C=g.getcolor ();
if (good) {G.setcolor (Color.Blue);
else G.setcolor (Color.orange);
G.filloval (x, Y, WIDTH, HEIGHT);
G.setcolor (c);
Move ();
/** * To allow bullets to move in accordance with the direction of the tank * * private void moves () {switch (dir) {case l:x-=xspeed;
Break
Case Lu:x-=xspeed;
Y-=yspeed;
Break
Case U:y-=yspeed;
Break
Case Ru:x+=xspeed;
Y-=yspeed;
Break
Case R:x+=xspeed;
Break
Case Rd:x+=xspeed;
Y+=yspeed;
Break
Case D:y+=yspeed;
Break
Case Ld:x-=xspeed;
Y+=yspeed;
Break } if (x<0| | y<0| | x>tankwarclient.game_width| |
Y>tankwarclient.game_height)//The bullet crosses the line to let it die; {live=false;
} public boolean islive () {return Live;
Public Rectangle GetRect ()//Get the rectangular area of the bullet; {return new Rectangle (This.x,this.y,this.) Width,this.
HEIGHT);
/** * Judge bullets collided with tanks; * @param t for tank * @return return True to indicate a collision, otherwise no collision; * Public boolean Hittank (Tank t) { if (this. Live&&this.getrect (). intersects (T.getrect ()) &&t.islive () &&this.good!=t.isgood ()) {if (t).
Isgood ()) {T.setlife (T.getlife ()-10);
if (T.getlife () <=0) t.setlive (false);
}else{t.setlive (FALSE); } this.
live=false;///the bullet to death;
Explode e=new Explode (X,Y,TC);//explosion; Tc.explodes.add (e);
return true;
return false; /** * Judge bullets collided with enemy tanks; * @param tanks enemy Tank * @returntrue said the collision, false did not collide; * Public boolean hittanks (List<ta Nk> tanks) {for (int i=0;i<tanks.size (), i++) {if (Hittank (Tc.tanks.get (i))) {return T
Rue
return false; /** * To determine whether the bullet hit the wall * @param w Walls * @returntrue, crashed, false, not hit; * Public boolean Hitswall (Wall W) {if (This. live&&this.getrect (). intersects (W.getrect ())) {live=false;
return true;
return false; }
}
Tank.java
Package Com.hkm.TankWar;
Import java.awt.*;
Import java.awt.event.KeyEvent;
Import java.util.*; /** * Tank class * @author hekangmin * * * * * */public class Tank {public static final int xspeed=5;//tank x direction speed public static fi
nal int yspeed=5;
public static final int width=30;
public static final int height=30;
Private Bloodbar bb=new Bloodbar ();//blood bar private int life=100;
public int Getlife () {return life;
public void Setlife (int life) {this.life = life;
private static Random r=new Random ();
private static int Step=r.nextint (12) +3;//defines a number indicating the number of steps of an enemy tank randomly eastward; private Boolean bl=false,bu=false,br=false,bd=false;
The enum direction{l,lu,u,ru,r,rd,d,ld,stop};//defines the direction of the tank using the enumeration type; private int x,y; private int oldx,oldy;//Record the position of the tank on the previous step; private Boolean live=true;//to determine whether or not to live public boolean islive () {return Li
ve
public void Setlive (Boolean live) {this.live = live; Private Boolean good;//tank is good or bad publIC Boolean Isgood () {return good;
Private Direction ptdir=direction.d;//added the direction of the barrel;
Tankwarclient tc;//in order to hold each other's references to facilitate access to its member variables; Direction dir=direction.stop;//first set the tank direction to a STOP; public Tank (int x,int Y,boolean good,direction
ENT tc) {this.x=x;
This.y=y;
This.oldx=x;
This.oldy=y;
This.good=good;
This.dir=dir;
this.tc=tc;//hold each other's references; public void Draw (Graphics g) {if (!live)//If death is no longer draw; {if (!good) {tc.tanks.
Remove (this); if (Tc.tanks.size () <5)//Less than 5 tanks added tank; {for (int i=0;i<10;i++) {int Posx=r.nex
TINT (800);
int Posy=r.nextint (600);
Tc.tanks.add (New Tank (POSX,POSY,FALSE,DIRECTION.D,TC));//make the position of tank appear random}} return;
Color C=g.getcolor ();
if (good) {G.setcolor (color.red);
Bb.draw (g); else G.setcolor (Color.blacK);
G.filloval (x, Y, WIDTH, HEIGHT);
G.setcolor (c);
Switch (PTDIR)//Draw the direction of the barrel;
{Case L:g.drawline (X+TANK.WIDTH/2, Y+TANK.HEIGHT/2, x-10, Y+TANK.HEIGHT/2);/draw a barrel, draw a straight line instead;
Case Lu:g.drawline (X+TANK.WIDTH/2, Y+TANK.HEIGHT/2, x-7, y-7);
Break
Case U:g.drawline (X+TANK.WIDTH/2, Y+TANK.HEIGHT/2, X+TANK.WIDTH/2, y-10);
Break
Case Ru:g.drawline (X+TANK.WIDTH/2, Y+TANK.HEIGHT/2, x+tank.width+7, y-7);
Break
Case R:g.drawline (X+TANK.WIDTH/2, Y+TANK.HEIGHT/2, x+tank.width+10, Y+TANK.HEIGHT/2);
Break
Case Rd:g.drawline (X+TANK.WIDTH/2, Y+TANK.HEIGHT/2, x+tank.width+7, y+tank.height+7);
Break
Case D:g.drawline (X+TANK.WIDTH/2, Y+TANK.HEIGHT/2, X+TANK.WIDTH/2, y+tank.height+10);
Break
Case Ld:g.drawline (X+TANK.WIDTH/2, Y+TANK.HEIGHT/2, x-7, y+height+7);
Break
} move (); public void Move () {oldx=x;//record TitanOldy=y the position of the previous step;
Switch (dir) {case l:x-=xspeed;
Break
Case Lu:x-=xspeed;
Y-=yspeed;
Break
Case U:y-=yspeed;
Break
Case Ru:x+=xspeed;
Y-=yspeed;
Break
Case R:x+=xspeed;
Break
Case Rd:x+=xspeed;
Y+=yspeed;
Break
Case D:y+=yspeed;
Break
Case Ld:x-=xspeed;
Y+=yspeed;
Break
Case Stop:break;
} if (this.dir!=direction.stop) This.ptdir=this.dir;
/** * Prevent tank from crossing the line; */if (x<0) x=0;
if (y<25) y=25;
if (x+tank.width>tankwarclient.game_width) x=tankwarclient.game_width-30;
if (y+tank.height>tankwarclient.game_height) y=tankwarclient.game_height-30; if (!good) {direction[] dirs=direction.values ();//Converts an enumerated type to an array; if (step==0) {STEP=R.N
Extint (12) +3;
int Rn=r.nextint (dirs.length);//To produce a random integer within length; DIR=DIRS[RN];
} step--;
D keypressed (KeyEvent e) {int key=e.getkeycode ();
Switch (key) {case keyevent.vk_left:bl=true;
Break
Case Keyevent.vk_right:br=true;
Break
Case Keyevent.vk_up:bu=true;
Break
Case Keyevent.vk_down:bd=true;
Break
} locationdir ();
public void keyreleased (KeyEvent e) {int key=e.getkeycode ();
Switch (key) {case KeyEvent.VK_CONTROL:fire ();
Break
Case Keyevent.vk_left:bl=false;
Break
Case Keyevent.vk_right:br=false;
Break
Case Keyevent.vk_up:bu=false;
Break
Case Keyevent.vk_down:bd=false;
Break
Case KeyEvent.VK_A:superFire ();
Break
Case KeyEvent.VK_F2:reBorn ();
Break
}Locationdir ();
/** * Fired bullets * @return return Bullet type * * Public missile Fire () {if (!live) returns null;
int mx=this.x+tank.width/2-missile.width/2;//calculates the position of the projectile firing; int MY=THIS.Y+TANK.HEIGHT/2-MISSILE.HEIGHT/2;
Missile m=new Missile (MX,MY,GOOD,PTDIR,THIS.TC);////fired bullets according to barrel direction tc.missiles.add (m);
return m;
Public missile Fire (Direction dir) {if (!live) return null;
int MX=THIS.X+TANK.WIDTH/2-MISSILE.WIDTH/2;
int MY=THIS.Y+TANK.HEIGHT/2-MISSILE.HEIGHT/2;
Missile m=new Missile (MX,MY,GOOD,DIR,THIS.TC);//Fired bullets according to the direction of the tank; Tc.missiles.add (m);
return m;
public void Superfire () {direction[] dirs=direction.values ();
for (int i=0;i<8;i++) {fire (dirs[i]);
} public void Locationdir () {if (BL&&!BU&&!BR&&!BD) DIR=DIRECTION.L;
else if (BL&&BU&&!BR&&!BD) dir=direction.lu; else if (!bl&&bu&&!br&&!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&&!BR&&!BD) dir=direction.stop; The public Rectangle getrect ()//Gets the rectangular region of tank {return new Rectangle this.x,this.y,this. Width,this.
HEIGHT);
/** * Tank Wall * @param w Wall * @returntrue hit, false not hit; * Public boolean Colliedswithwall (Wall W) {
if (This.live&&this.getrect (). intersects (W.getrect ())) {This.stay ();
return true;
return false; /** * Handling tanks collided with tanks to prevent them from crossing each other; * @param tanks enemy Tanks; * @return true hit, false not hit;/public BooleaN Colliedswithtanks (java.util.list<tank> tanks) {for (int i=0;i<tanks.size (); i++) {Tank t=tanks.
Get (i);
if (this!=t) {if (This.live&&this.islive () &&this.getrect (). intersects (T.getrect ())) {
This.stay ();//Returns the position of the previous step; T.stay ();////returns the position of the previous step return true;
}} return false;
private void Stay () {x=oldx;
Y=oldy; /** * is the inner class of the tank; the blood strips are shown above the heads of our tanks; * @author hekangmin * */Private class Bloodbar {public void
Draw (Graphics g) {Color c=g.getcolor ();
G.setcolor (color.red);
G.drawrect (x,y-10,width,10);
int w=width*life/100;
G.fillrect (x,y-10,w,10); }/** * Eat blood clots; * @param b blood clots * @returntrue eat, false not to eat;/public boolean Eat (blood b) {if T
His.live&&b.islive () &&this.getrect (). intersects (B.getrect ())) {this.life=100; B.sEtlive (FALSE);
return true;
return false; /** * The resurrection of our tanks after death; * * public void Reborn () {if (This.isgood () &&!this.islive ()) {This
. Setlive (True);
This.setlife (100); }
}
}
Tankwarclient.java
Package Com.hkm.TankWar;
Import java.awt.*;
Import java.awt.event.*;
Import java.util.List;
Import java.util.ArrayList; /** * This is the game window; * @author hekangmin * */public class Tankwarclient extends frame{/** * The width of the game window;/Public stat
IC final int game_width=800;
/** * The height of the game window; * * public static final int game_height=600;
Tank mytank=new Tank (700,400,true,tank.direction.stop,this);
List<tank> tanks=new arraylist<tank> ();
List<explode> explodes=new arraylist<explode> ();
List<missile> missiles=new arraylist<missile> ();
Wall w1=new Wall (300,200,20,200,this);
Wall w2=new Wall (600,300,30,150,this);
Blood B=new blood ();
/** * Draw a virtual picture; * * Image offscreenimage=null;
The public tankwarclient (String name)//sets the text {super (name); /** * Run window; */public void Launchframe () {for (int i=0;i<10;i++)//Add 10 enemy tanks {tanks. Add (New Tank 50+40* (i+1), 50,FALSE,TANK.DIRECTION.D,This));
} this.setbounds (200,100,game_width,game_height);
This.setbackground (Color.green); This.addwindowlistener (New Windowadapter ()//anonymous class {public void windowclosing (WindowEvent e) {syste
M.exit (0);
}
}); This.addkeylistener (New Keymonitor ())//join keyboard listener; this.setresizable (false);//cannot change the size of the window; This.setvisible (True)
; New Thread (new Paintthread ()). Start ();//create a new thread;} public void Paint (Graphics g) {g.drawstring ("Missile coun
T: "+missiles.size (), 10, 50);//display string; g.DrawString (" Explodes Count: "+explodes.size (), 10,70);
g.DrawString ("Tanks Count:" +tanks.size (), 10,90);
g.DrawString ("Mytank Life:" +mytank.getlife (), 10,110);
/** * Draw the wall; * * W1.DRAW (g);
W2.draw (g);
/** * Detect bullets and all kinds of things; * for (int i=0;i<missiles.size (); i++) {missile m=missiles.get (i);
M.hitswall (W1);
M.hitswall (W2);
M.hittanks (tanks); M.hittank(Mytank);
M.draw (g);
if (!m.islive ())//missiles.remove (m);
else M.draw (g);
/** * Draw an explosion; * for (int i=0;i<explodes.size (); i++) {Explode e=explodes.get (i);
E.draw (g);
for (int i=0;i<tanks.size (); i++) {Tank t=tanks.get (i);
T.colliedswithwall (W1);
T.colliedswithwall (W2);
T.colliedswithtanks (tanks);
T.draw (g);
} B.draw (g);
Mytank.eat (b);
Mytank.draw (g);
/** * Use double buffering technology to eliminate the phenomenon of tank flicker;/public void update (Graphics g)//g as a brush painted on the screen;
{if (offscreenimage==null) offscreenimage=this.createimage (Game_width, game_height);
Graphics goffscreen=offscreenimage.getgraphics ();//goffscreen is the brush of offscreenimage;
Color C=goffscreen.getcolor ();
Goffscreen.setcolor (Color.green);
Goffscreen.fillrect (0, 0, game_width, game_height);
Goffscreen.setcolor (c);
Paint (Goffscreen);//painting on the virtual picture; G.drawimage (Offscreenimage,0,0,null///////////////////////////////////////////G
{while (true) {repaint ();//The Repaint method here is the try{thread.sleep (100) of the frame class;
}catch (interruptedexception e) {e.printstacktrace ();
"}}} private class Keymonitor extends Keyadapter {public void keyreleased (KeyEvent e) {
Mytank.keyreleased (e);
public void keypressed (KeyEvent e) {mytank.keypressed (e); } public static void Main (string[] args) {New tankwarclient (' My Tank World '). Launchfram
E (); }
}
Wall.java
Package Com.hkm.TankWar;
Import java.awt.*;
/**
* Generate block Wall this class;
* @author hekangmin * * */Public
class Wall {
/**
* x,y for the wall position, w,h for width height;
*
/int x,y,w,h;
/**
* Holding reference * *
tankwarclient TC;
public Wall (int x, int y, int w, int h, tankwarclient tc) {
this.x = x;
This.y = y;
THIS.W = W;
This.h = h;
THIS.TC = TC;
}
public void Draw (Graphics g)
{
Color c=g.getcolor ();
G.setcolor (Color.gray);
G.fillrect (x,y,w,h);
G.setcolor (c);
}
/**
* Get the rectangular area of the wall;
* @return/public
Rectangle getrect ()
{return
new Rectangle (x,y,w,h );
}
}
The above mentioned is the entire content of this article, I hope you can enjoy.