//類(lèi)TankClient, 繼承自Frame類(lèi)

//繼承Frame類(lèi)后所重寫(xiě)的兩個(gè)方法paint()和update()
//在paint()方法中設(shè)置在一張圖片中需要畫(huà)出什么東西. 
@Override
public void paint(Graphics g) {
 //下面三行畫(huà)出游戲窗口左上角的游戲參數(shù)
 g.drawString("missiles count:" + missiles.size(), 10, 50);
 g.drawString("explodes count:" + explodes.size(), 10, 70);
 g.drawString("tanks count:" + tanks.size(), 10, 90);
 
 //檢測(cè)我的坦克是否被子彈打到, 并畫(huà)出子彈
 for(int i = 0; i < missiles.size(); i++) {
 Missile m = missiles.get(i);
 if(m.hitTank(myTank)){
 TankDeadMsg msg = new TankDeadMsg(myTank.id);
 nc.send(msg);
 MissileDeadMsg mmsg = new MissileDeadMsg(m.getTankId(), m.getId());
 nc.send(mmsg);
 }
 m.draw(g);
 }
 //畫(huà)出爆炸
 for(int i = 0; i < explodes.size(); i++) {
 Explode e = explodes.get(i);
 e.draw(g);
 }
 //畫(huà)出其他坦克
 for(int i = 0; i < tanks.size(); i++) {
 Tank t = tanks.get(i);
 t.draw(g);
 }
 //畫(huà)出我的坦克
 myTank.draw(g);
}

/*
 * update()方法用于寫(xiě)每幀更新時(shí)的邏輯. 
 * 每一幀更新的時(shí)候, 我們會(huì)把該幀的圖片畫(huà)到屏幕中.
 * 但是這樣做是有缺陷的, 因?yàn)榘岩桓眻D片畫(huà)到屏幕上會(huì)有延時(shí), 游戲顯示不夠流暢
 * 所以這里用到了一種緩沖技術(shù).
 * 先把圖像畫(huà)到一塊幕布上, 每幀更新的時(shí)候直接把畫(huà)布推到窗口中顯示
 */
@Override
public void update(Graphics g) {
 if(offScreenImage == null) {
 offScreenImage = this.createImage(800, 600);//創(chuàng)建一張畫(huà)布
 }
 Graphics gOffScreen = offScreenImage.getGraphics();
 Color c = gOffScreen.getColor();
 gOffScreen.setColor(Color.GREEN);
 gOffScreen.fillRect(0, 0, GAME_WIDTH, GAME_HEIGHT);
 gOffScreen.setColor(c);
 paint(gOffScreen);//先在畫(huà)布上畫(huà)好
 g.drawImage(offScreenImage, 0, 0, null);//直接把畫(huà)布推到窗口
}


//這是加載游戲窗口的方法
public void launchFrame() {
 this.setLocation(400, 300);//設(shè)置游戲窗口相對(duì)于屏幕的位置
 this.setSize(GAME_WIDTH, GAME_HEIGHT);//設(shè)置游戲窗口的大小
 this.setTitle("TankWar");//設(shè)置標(biāo)題
 this.addWindowListener(new WindowAdapter() {//為窗口的關(guān)閉按鈕添加監(jiān)聽(tīng)

 @Override
 public void windowClosing(WindowEvent e) {
 System.exit(0);
 }
 });
 this.setResizable(false);//設(shè)置游戲窗口的大小不可改變
 this.setBackground(Color.GREEN);//設(shè)置背景顏色
 this.addKeyListener(new KeyMonitor());//添加鍵盤(pán)監(jiān)聽(tīng), 
 this.setVisible(true);//設(shè)置窗口可視化, 也就是顯示出來(lái)
 new Thread(new PaintThread()).start();//開(kāi)啟線程, 把圖片畫(huà)出到窗口中
 dialog.setVisible(true);//顯示設(shè)置服務(wù)器IP, 端口號(hào), 自己UDP端口號(hào)的對(duì)話窗口
}

//在窗口中畫(huà)出圖像的線程, 定義為每50毫秒畫(huà)一次. 
class PaintThread implements Runnable {

 public void run() {
 while(true) {
 repaint();
 try {
 Thread.sleep(50);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 }
}

public int id;//作為網(wǎng)絡(luò)中的標(biāo)識(shí)

public static final int XSPEED = 5;//左右方向上每幀移動(dòng)的距離
public static final int YSPEED = 5;//上下方向每幀移動(dòng)的距離
public static final int WIDTH = 30;//坦克圖形的寬
public static final int HEIGHT = 30;//坦克圖形的高

private boolean good;//根據(jù)true和false把坦克分成兩類(lèi), 游戲中兩派對(duì)戰(zhàn)
private int x, y;//坦克的坐標(biāo)
private boolean live = true;//坦克是否活著, 死了將不再畫(huà)出
private TankClient tc;//客戶端類(lèi)的引用
private boolean bL, bU, bR, bD;//用于判斷鍵盤(pán)按下的方向
private Dir dir = Dir.STOP;//坦克的方向
private Dir ptDir = Dir.D;//炮筒的方向

 public void draw(Graphics g) {
 if(!live) {
 if(!good) {
 tc.getTanks().remove(this);//如果坦克死了就把它從容器中去除, 并直接結(jié)束
 }
 return;
 }
 //畫(huà)出坦克
 Color c = g.getColor();
 if(good) g.setColor(Color.RED);
 else g.setColor(Color.BLUE);
 g.fillOval(x, y, WIDTH, HEIGHT);
 g.setColor(c);
 //畫(huà)出炮筒
 switch(ptDir) {
 case L:
 g.drawLine(x + WIDTH/2, y + HEIGHT/2, x, y + HEIGHT/2);
 break;
 case LU:
 g.drawLine(x + WIDTH/2, y + HEIGHT/2, x, y);
 break;
 case U:
 g.drawLine(x + WIDTH/2, y + HEIGHT/2, x + WIDTH/2, y);
 break;
 //...省略部分方向
 }
 move();//每次畫(huà)完改變坦克的坐標(biāo), 連續(xù)畫(huà)的時(shí)候坦克就動(dòng)起來(lái)了
 }

private void move() {
 switch(dir) {//根據(jù)坦克的方向改變坐標(biāo)
 case L://左
 x -= XSPEED;
 break;
 case LU://左上
 x -= XSPEED;
 y -= YSPEED;
 break;
 //...省略
 }

 if(dir != Dir.STOP) {
 ptDir = dir;
 }
 //防止坦克走出游戲窗口, 越界時(shí)要停住
 if(x < 0) x = 0;
 if(y < 30) y = 30;
 if(x + WIDTH > TankClient.GAME_WIDTH) x = TankClient.GAME_WIDTH - WIDTH;
 if(y + HEIGHT > TankClient.GAME_HEIGHT) y = TankClient.GAME_HEIGHT - HEIGHT;
}

 public void keyPressed(KeyEvent e) {//接收接盤(pán)事件
 int key = e.getKeyCode();
 //根據(jù)鍵盤(pán)按下的按鍵修改bL, bU, bR, bD四個(gè)布爾值, 回后會(huì)根據(jù)四個(gè)布爾值判斷上, 左上, 左等八個(gè)方向
 switch (key) {
 case KeyEvent.VK_A://按下鍵盤(pán)A鍵, 意味著往左
 bL = true;
 break;
 case KeyEvent.VK_W://按下鍵盤(pán)W鍵, 意味著往上
 bU = true;
 break;
 case KeyEvent.VK_D:
 bR = true;
 break;
 case KeyEvent.VK_S:
 bD = true;
 break;
 }
 locateDirection();//根據(jù)四個(gè)布爾值判斷八個(gè)方向的方法
 }

 private void locateDirection() {
 Dir oldDir = this.dir;//記錄下原來(lái)的方法, 用于聯(lián)網(wǎng)
 //根據(jù)四個(gè)方向的布爾值判斷八個(gè)更細(xì)分的方向
 //比如左和下都是true, 證明玩家按的是左下, 方向就該為左下
 if(bL && !bU && !bR && !bD) dir = Dir.L;
 else if(bL && bU && !bR && !bD) dir = Dir.LU;
 else if(!bL && bU && !bR && !bD) dir = Dir.U;
 else if(!bL && bU && bR && !bD) dir = Dir.RU;
 else if(!bL && !bU && bR && !bD) dir = Dir.R;
 else if(!bL && !bU && bR && bD) dir = Dir.RD;
 else if(!bL && !bU && !bR && bD) dir = Dir.D;
 else if(bL && !bU && !bR && bD) dir = Dir.LD;
 else if(!bL && !bU && !bR && !bD) dir = Dir.STOP;
 //可以先跳過(guò)這段代碼, 用于網(wǎng)絡(luò)中其他客戶端的坦克移動(dòng)
 if(dir != oldDir){
 TankMoveMsg msg = new TankMoveMsg(id, x, y, dir, ptDir);
 tc.getNc().send(msg);
 }
 }
 //對(duì)鍵盤(pán)釋放的監(jiān)聽(tīng)
 public void keyReleased(KeyEvent e) {
 int key = e.getKeyCode();
 switch (key) {
 case KeyEvent.VK_J://設(shè)定J鍵開(kāi)火, 當(dāng)釋放J鍵時(shí)發(fā)出一發(fā)子彈
 fire();
 break;
 case KeyEvent.VK_A:
 bL = false;
 break;
 case KeyEvent.VK_W:
 bU = false;
 break;
 case KeyEvent.VK_D:
 bR = false;
 break;
 case KeyEvent.VK_S:
 bD = false;
 break;
 }
 locateDirection();
 }

private Missile fire() {
 if(!live) return null;//如果坦克死了就不能開(kāi)火
 int x = this.x + WIDTH/2 - Missile.WIDTH/2;//設(shè)定子彈的x坐標(biāo)
 int y = this.y + HEIGHT/2 - Missile.HEIGHT/2;//設(shè)定子彈的y坐標(biāo)
 Missile m = new Missile(id, x, y, this.good, this.ptDir, this.tc);//創(chuàng)建一顆子彈
 tc.getMissiles().add(m);//把子彈添加到容器中. 
 //網(wǎng)絡(luò)部分可暫時(shí)跳過(guò), 發(fā)出一發(fā)子彈后要發(fā)送給服務(wù)器并轉(zhuǎn)發(fā)給其他客戶端.
 MissileNewMsg msg = new MissileNewMsg(m);
 tc.getNc().send(msg);
 return m;
}

public static final int XSPEED = 10;//子彈每幀中坐標(biāo)改變的大小, 比坦克大些, 子彈當(dāng)然要飛快點(diǎn)嘛
public static final int YSPEED = 10;
public static final int WIDTH = 10;
public static final int HEIGHT = 10;
private static int ID = 10;

private int id;//用于在網(wǎng)絡(luò)中標(biāo)識(shí)的id
private TankClient tc;//客戶端的引用
private int tankId;//表明是哪個(gè)坦克發(fā)出的
private int x, y;//子彈的坐標(biāo)
private Dir dir = Dir.R;//子彈的方向
private boolean live = true;//子彈是否存活
private boolean good;//子彈所屬陣營(yíng), 我方坦克自能被地方坦克擊斃

public boolean hitTank(Tank t) {
 //如果子彈是活的, 被打中的坦克也是活的
 //子彈和坦克不屬于同一方
 //子彈的圖形碰撞到了坦克的圖形
 //認(rèn)為子彈打中了坦克
 if(this.live && t.isLive() && this.good != t.isGood() && this.getRect().intersects(t.getRect())) {
 this.live = false;//子彈生命設(shè)置為false
 t.setLive(false);//坦克生命設(shè)置為false
 tc.getExplodes().add(new Explode(x, y, tc));//產(chǎn)生一個(gè)爆炸, 坐標(biāo)為子彈的坐標(biāo)
 return true;
 }
 return false;
}

public Rectangle getRect() {
 return new Rectangle(x, y, WIDTH, HEIGHT);
}

//客戶端
public void connect(String ip, int port){
 serverIP = ip;
 Socket s = null;
 try {
 ds = new DatagramSocket(UDP_PORT);//創(chuàng)建UDP套接字
 s = new Socket(ip, port);//創(chuàng)建TCP套接字
 DataOutputStream dos = new DataOutputStream(s.getOutputStream());
 dos.writeInt(UDP_PORT);//向服務(wù)器發(fā)送自己的UDP端口號(hào)
 DataInputStream dis = new DataInputStream(s.getInputStream());
 int id = dis.readInt();//獲得服務(wù)器分配給自己坦克的id號(hào)
 this.serverUDPPort = dis.readInt();//獲得服務(wù)器的UDP端口號(hào)
 tc.getMyTank().id = id;
 tc.getMyTank().setGood((id & 1) == 0 ? true : false);//根據(jù)坦克的id號(hào)的奇偶性設(shè)置坦克的陣營(yíng)
 } catch (IOException e) {
 e.printStackTrace();
 }finally {
 try{
 if(s != null) s.close();//信息交換完畢后客戶端的TCP套接字關(guān)閉
 } catch (IOException e) {
 e.printStackTrace();
 }
 }

 TankNewMsg msg = new TankNewMsg(tc.getMyTank());
 send(msg);//發(fā)送坦克出生的消息(后面介紹)

 new Thread(new UDPThread()).start();//開(kāi)啟UDP線程
}

//服務(wù)器
public void start(){
 new Thread(new UDPThread()).start();//開(kāi)啟UDP線程
 ServerSocket ss = null;
 try {
 ss = new ServerSocket(TCP_PORT);//創(chuàng)建TCP歡迎套接字
 } catch (IOException e) {
 e.printStackTrace();
 }

 while(true){//監(jiān)聽(tīng)每個(gè)客戶端的連接
 Socket s = null;
 try {
 s = ss.accept();//為客戶端分配一個(gè)專(zhuān)屬TCP套接字
 DataInputStream dis = new DataInputStream(s.getInputStream());
 int UDP_PORT = dis.readInt();//獲得客戶端的UDP端口號(hào)
 Client client = new Client(s.getInetAddress().getHostAddress(), UDP_PORT);//把客戶端的IP地址和UDP端口號(hào)封裝成Client對(duì)象, 以備后面使用
 clients.add(client);//裝入容器中

 DataOutputStream dos = new DataOutputStream(s.getOutputStream());
 dos.writeInt(ID++);//給客戶端的主戰(zhàn)坦克分配一個(gè)id號(hào)
 dos.writeInt(UDP_PORT);
 }catch (IOException e) {
 e.printStackTrace();
 }finally {
 try {
 if(s != null) s.close();
 } catch (IOException e) {
 e.printStackTrace();
 }
 }
 }
}

public interface Msg {
 public static final int TANK_NEW_MSG = 1;
 public static final int TANK_MOVE_MSG= 2;
 public static final int MISSILE_NEW_MESSAGE = 3;
 public static final int TANK_DEAD_MESSAGE = 4;
 public static final int MISSILE_DEAD_MESSAGE = 5;

 //每個(gè)消息報(bào)文, 自己將擁有發(fā)送和解析的方法, 為多態(tài)的實(shí)現(xiàn)奠定基礎(chǔ). 
 public void send(DatagramSocket ds, String IP, int UDP_Port);
 public void parse(DataInputStream dis);
}

//如果沒(méi)有多態(tài)的話, NetClient中將要定義每個(gè)消息的發(fā)送方法
public void sendTankNewMsg(TankNewMsg msg){
 //很長(zhǎng)...
}
public void sendMissileNewMsg(MissileNewMsg msg){
 //很長(zhǎng)...
}
//只要有新的消息類(lèi)型, 后面就要接著定義...

//假如使用了多態(tài), NetClient中只需要定義一個(gè)發(fā)送方法
public void send(Msg msg){
 msg.send(ds, serverIP, serverUDPPort);
}
//當(dāng)我們要發(fā)送某個(gè)類(lèi)型的消息時(shí), 只需要
TankNewMsg msg = new TankNewMsg();
NetClient nc = new NetClient();//實(shí)踐中不需要, 能拿到唯一的NetClient的引用
nc.send(msg)

//在NetClient類(lèi)中, 解析的方法如下
private void parse(DatagramPacket dp) {
 ByteArrayInputStream bais = new ByteArrayInputStream(buf, 0, dp.getLength());
 DataInputStream dis = new DataInputStream(bais);
 int msgType = 0;
 try {
 msgType = dis.readInt();//先拿到消息的類(lèi)型
 } catch (IOException e) {
 e.printStackTrace();
 }
 Msg msg = null;
 switch (msgType){//根據(jù)消息的類(lèi)型, 調(diào)用具體消息的解析方法
 case Msg.TANK_NEW_MSG :
 msg = new TankNewMsg(tc);
 msg.parse(dis);
 break;
 case Msg.TANK_MOVE_MSG :
 msg = new TankMoveMsg(tc);
 msg.parse(dis);
 break;
 case Msg.MISSILE_NEW_MESSAGE :
 msg = new MissileNewMsg(tc);
 msg.parse(dis);
 break;
 case Msg.TANK_DEAD_MESSAGE :
 msg = new TankDeadMsg(tc);
 msg.parse(dis);
 break;
 case Msg.MISSILE_DEAD_MESSAGE :
 msg = new MissileDeadMsg(tc);
 msg.parse(dis);
 break;
 }
}

//下面是TankNewMsg中解析本消息的方法
public void parse(DataInputStream dis){
 try{
 int id = dis.readInt();
 if(id == this.tc.getMyTank().id){
 return;
 }

 int x = dis.readInt();
 int y = dis.readInt();
 Dir dir = Dir.values()[dis.readInt()];
 boolean good = dis.readBoolean();

 //接收到別人的新信息, 判斷別人的坦克是否已將加入到tanks集合中
 boolean exist = false;
 for (Tank t : tc.getTanks()){
 if(id == t.id){
 exist = true;
 break;
 }
 }
 if(!exist) {//當(dāng)判斷到接收的新坦克不存在已有集合才加入到集合.
 TankNewMsg msg = new TankNewMsg(tc);
 tc.getNc().send(msg);//加入一輛新坦克后要把自己的信息也發(fā)送出去.
 Tank t = new Tank(x, y, good, dir, tc);
 t.id = id;
 tc.getTanks().add(t);
 }
 } catch (IOException e) {
 e.printStackTrace();
 }
}

private void locateDirection() {
 Dir oldDir = this.dir;//記錄舊的方向
 if(bL && !bU && !bR && !bD) dir = Dir.L;
 else if(bL && bU && !bR && !bD) dir = Dir.LU;
 else if(!bL && bU && !bR && !bD) dir = Dir.U;
 else if(!bL && bU && bR && !bD) dir = Dir.RU;
 else if(!bL && !bU && bR && !bD) dir = Dir.R;
 else if(!bL && !bU && bR && bD) dir = Dir.RD;
 else if(!bL && !bU && !bR && bD) dir = Dir.D;
 else if(bL && !bU && !bR && bD) dir = Dir.LD;
 else if(!bL && !bU && !bR && !bD) dir = Dir.STOP;

 if(dir != oldDir){//如果改變后的方向不同于舊方向也就是說(shuō)方向發(fā)生了改變
 TankMoveMsg msg = new TankMoveMsg(id, x, y, dir, ptDir);//創(chuàng)建TankMoveMsg消息
 tc.getNc().send(msg);//發(fā)送
 }
}

private Missile fire() {
 if(!live) return null;
 int x = this.x + WIDTH/2 - Missile.WIDTH/2;
 int y = this.y + HEIGHT/2 - Missile.HEIGHT/2;
 Missile m = new Missile(id, x, y, this.good, this.ptDir, this.tc);
 tc.getMissiles().add(m);

 MissileNewMsg msg = new MissileNewMsg(m);//生成MissileNewMsg
 tc.getNc().send(msg);//發(fā)送給其他客戶端
 return m;
}

//MissileNewMsg的解析
public void parse(DataInputStream dis) {
 try{
 int tankId = dis.readInt();
 if(tankId == tc.getMyTank().id){//如果是自己發(fā)出的子彈就跳過(guò)(已經(jīng)加入到容器了)
 return;
 }
 int id = dis.readInt();
 int x = dis.readInt();
 int y = dis.readInt();
 Dir dir = Dir.values()[dis.readInt()];
 boolean good = dis.readBoolean();
 //把收到的這顆子彈添加到子彈容器中
 Missile m = new Missile(tankId, x, y, good, dir, tc);
 m.setId(id);
 tc.getMissiles().add(m);
 } catch (IOException e) {
 e.printStackTrace();
 }
}

//TankClient類(lèi), paint()中的代碼片段, 遍歷子彈容器中的每顆子彈看自己的坦克有沒(méi)有被打中. 
for(int i = 0; i < missiles.size(); i++) {
 Missile m = missiles.get(i);
 if(m.hitTank(myTank)){
 TankDeadMsg msg = new TankDeadMsg(myTank.id);
 nc.send(msg);
 MissileDeadMsg mmsg = new MissileDeadMsg(m.getTankId(), m.getId());
 nc.send(mmsg);
 }
 m.draw(g);
}

//MissileDeadMsg的解析
public void parse(DataInputStream dis) {
 try{
 int tankId = dis.readInt();
 int id = dis.readInt();
 //在容器找到對(duì)應(yīng)的那顆子彈, 設(shè)置死亡不再畫(huà)出, 并產(chǎn)生一個(gè)爆炸. 
 for(Missile m : tc.getMissiles()){
 if(tankId == tc.getMyTank().id && id == m.getId()){
 m.setLive(false);
 tc.getExplodes().add(new Explode(m.getX(), m.getY(), tc));
 break;
 }
 }
 } catch (IOException e) {
 e.printStackTrace();
 }
}

//TankDeadMsg的解析
public void parse(DataInputStream dis) {
 try{
 int tankId = dis.readInt();
 if(tankId == this.tc.getMyTank().id){//如果是自己坦克發(fā)出的死亡消息舊跳過(guò)
 return;
 }
 for(Tank t : tc.getTanks()){//否則遍歷坦克容器, 把死去的坦克移出容器, 不再畫(huà)出. 
 if(t.id == tankId){
 t.setLive(false);
 break;
 }
 }
 } catch (IOException e) {
 e.printStackTrace();
 }
}

//修改后, TankNewMsg的解析部分如下
 public void parse(DataInputStream dis){
 try{
 int id = dis.readInt();
 if(id == this.tc.getMyTank().getId()){
 return;
 }
 int x = dis.readInt();
 int y = dis.readInt();
 Dir dir = Dir.values()[dis.readInt()];
 boolean good = dis.readBoolean();
 Tank newTank = new Tank(x, y, good, dir, tc);
 newTank.setId(id);
 tc.getTanks().add(newTank);//把新的坦克添加到容器中
 //發(fā)出自己的信息 
 TankAlreadyExistMsg msg = new TankAlreadyExistMsg(tc.getMyTank());
 tc.getNc().send(msg);

 } catch (IOException e) {
 e.printStackTrace();
 }
 }
//TankAlreadyExist的解析部分如下
public void parse(DataInputStream dis) {
 try{
 int id = dis.readInt();
 if(id == tc.getMyTank().getId()){
 return;
 }
 boolean exist = false;//判定發(fā)送TankAlreadyExist的坦克是否已經(jīng)存在于游戲中
 for(Tank t : tc.getTanks()){
 if(id == t.getId()){
 exist = true;
 break;
 }
 }
 if(!exist){//不存在則添加到游戲中
 int x = dis.readInt();
 int y = dis.readInt();
 Dir dir = Dir.values()[dis.readInt()];
 boolean good = dis.readBoolean();
 Tank existTank = new Tank(x, y, good, dir, tc);
 existTank.setId(id);
 tc.getTanks().add(existTank);
 }
 } catch (IOException e) {
 e.printStackTrace();
 }
}

//服務(wù)端添加的代碼片段
int deadTankUDPPort = dis.readInt();//獲得死亡坦克客戶端的UDP端口號(hào)
for(int i = 0; i < clients.size(); i++){//從Client集合中刪除該客戶端. 
 Client c = clients.get(i);
 if(c.UDP_PORT == deadTankUDPPort){
 clients.remove(c);
 }
}
//而客戶端則在向其他客戶端發(fā)送死亡消息后通知服務(wù)器把自己從客戶端容器移除
 for(int i = 0; i < missiles.size(); i++) {
 Missile m = missiles.get(i);
 if(m.hitTank(myTank)){
 TankDeadMsg msg = new TankDeadMsg(myTank.getId());//發(fā)送坦克死亡的消息
 nc.send(msg);
 MissileDeadMsg mmsg = new MissileDeadMsg(m.getTankId(), m.getId());//發(fā)送子彈死亡的消息, 通知產(chǎn)生爆炸
 nc.send(mmsg);
 nc.sendTankDeadMsg();//告訴服務(wù)器把自己從Client集合中移除
 gameOverDialog.setVisible(true);//彈窗結(jié)束游戲
 }
 m.draw(g);
 }