java實現簡單網路象棋遊戲
阿新 • • 發佈：2020-01-07
本文例項為大家分享了java實現網路象棋遊戲的具體程式碼，供大家參考，具體內容如下
遊戲規則：
1.將/帥：不能出田字格，不能走斜線，只能前進後退向左向右，每次只走一格；
2.士/仕：不能出田字格，只能走斜線，每次只走一格；
3.象/相：只能走田字格，中間防止蹩腳，不能有棋；
4.馬：只能走日，（這個比較麻煩，且看下圖示識）
5.車：車只能走直線，這個很好理解，不細說了；
6.炮：
情況一：純走路—->中間和目的地都不能有棋
情況二：吃棋—–>中間要有一顆棋，目標也有棋，且是敵方的棋，畢竟不能自己吃自己哈
7.卒/兵：
河這邊：只能前進不能後退，不能橫著走！！！
河對面：可以前進，可以橫著走，不能後退！！！
面板設計
看上去一定很挫！哈哈，別急，聽我細細道來！
一般的介面設計我們都知道橫縱座標是這樣的：
但是我選擇背道而行，不是因為別的，是為了更好的去讓初學者理解，我們把原本的x座標看成陣列的列（col），把y座標看成我們陣列的行（row），這樣是不是更好理解一點呢，當然了我就是這麼理解的，哈哈，接下來的遊戲程式碼程式設計我們會把橫座標用y*width，縱座標用x*height你們應該就能理解為什麼了，因為x是陣列的行，也就是座標縱座標（y）的體現，同理陣列中的y也是如此。
資料傳輸：這裡我們採用UDP協議來進行通訊，所以你們也要先去了解一下UDP協議的一些基本方法，這裡就不細講了。
通訊協議：這裡我們自定義通訊協議啊：
“connect|”——-以此開頭代表另一端收到邀請並且同意建立連線通訊！如果邀請者受到這條訊息就代表通訊建立成功，可以開始遊戲了；
“move|”——以此開頭代表移動資料傳輸，如果一端移動了棋子，那麼另一端也要收到資訊，重新繪製介面；
“lose|”——–以此開頭代表一方認輸，如果有一方認輸就會向另一方傳送該資訊；
“quit|”——-以此開頭代表一方退出遊戲，任意一方離開都會向對方傳送該資訊，以提示對方；
“success|”—–以此開頭代表勝利，某一方勝利就向對方發出資訊，通知對方；
“regret|”——以此開頭表示悔棋，這個不用講了吧，大家都明白，但是本次程式設計中我沒有把這個加進去，這個你們可以自己根據自己需要去新增。
程式碼實現
1.Chess類：
package internet_chess;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Point;
import java.awt.Toolkit;
import java.awt.image.ImageObserver;
import javax.swing.JPanel;
public class Chess {
public int Row = 12;
public int Col = 11;
public String chessName;//當前棋子物件的名字
public int owner;//當前棋子物件的所有者--黑方還是紅方
public Point point;//當前棋子物件的位置
public Image chessImage;//當前棋子物件的影象
private int BLACKCHESS = 1;
private int REDCHESS = 0;//紅方0，黑方1
private int width = 40;
private int height = 40;
public Chess(String name,int own,Point point)//獲取每一個棋子物件名字，所有者，位置，和圖片資訊
{
this.chessName = name;
this.owner = own;
this.point = point;
if(owner == BLACKCHESS)//如果所有者是黑方
{
if(chessName.equals("將"))
{
chessImage = Toolkit.getDefaultToolkit().getImage("F:/Image/chess/0.png");
}
else if(chessName.equals("士"))
{
chessImage = Toolkit.getDefaultToolkit().getImage("F:/Image/chess/1.png");
}
else if(chessName.equals("象"))
{
chessImage = Toolkit.getDefaultToolkit().getImage("F:/Image/chess/3.png");
}
else if(chessName.equals("馬"))
{
chessImage = Toolkit.getDefaultToolkit().getImage("F:/Image/chess/5.png");
}
else if(chessName.equals("車"))
{
chessImage = Toolkit.getDefaultToolkit().getImage("F:/Image/chess/7.png");
}
else if(chessName.equals("炮"))
{
chessImage = Toolkit.getDefaultToolkit().getImage("F:/Image/chess/9.png");
}
else if(chessName.equals("卒"))
{
chessImage = Toolkit.getDefaultToolkit().getImage("F:/Image/chess/11.png");
}
}
else//如果所有者是紅方
{
if(chessName.equals("帥"))
{
chessImage = Toolkit.getDefaultToolkit().getImage("F:/Image/chess/16.png");
}
else if(chessName.equals("仕"))
{
chessImage = Toolkit.getDefaultToolkit().getImage("F:/Image/chess/17.png");
}
else if(chessName.equals("相"))
{
chessImage = Toolkit.getDefaultToolkit().getImage("F:/Image/chess/19.png");
}
else if(chessName.equals("馬"))
{
chessImage = Toolkit.getDefaultToolkit().getImage("F:/Image/chess/21.png");
}
else if(chessName.equals("車"))
{
chessImage = Toolkit.getDefaultToolkit().getImage("F:/Image/chess/23.png");
}
else if(chessName.equals("炮"))
{
chessImage = Toolkit.getDefaultToolkit().getImage("F:/Image/chess/25.png");
}
else if(chessName.equals("兵"))
{
chessImage = Toolkit.getDefaultToolkit().getImage("F:/Image/chess/27.png");
}
}
}
protected void paint(Graphics g,JPanel i)//畫棋子
{
g.drawImage(chessImage,point.y*width-width/2,point.x*height-height/2,width,height,(ImageObserver)i);
}
protected void paintSeclected(Graphics g)//畫滑鼠選擇了以後的棋子物件的邊框
{
g.drawRect(point.y*width-width/2,height);
}
public void SetPos(int x,int y)//重新設定移動以後的棋子物件的位置座標
{
point.x = x;
point.y = y;
}
public void ReversePos()//將該物件的位置座標逆置輸出，用於方便顯示資訊情況
{
point.x = Row-1 - point.x;
point.y = Col-1 - point.y;
}
}
2.ChessPanel類：
package internet_chess;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
public class ChessPanel extends JPanel implements Runnable{
private int BLACKCHESS = 1;
private int REDCHESS = 0;//黑棋是1，紅旗是0
public Chess chess[] = new Chess[32];//建立了32個棋子物件
private int width = 40;
private int height = 40;
public int Row = 12;
public int Col = 11;//11行10列
public int map[][] = new int [Row][Col];
public int player;//設定當前玩家物件
private boolean isFirst = false;//判斷是否是第一次點選的棋子，以此分開兩次點選棋子的碰撞矛盾
private int x1,y1,x2,y2;//用來儲存第一次第二次選中的座標的
private boolean flag = true;//用來控制執行緒的執行
private boolean isPlay = false;
private Chess firstChess = null;
private Chess secondChess = null;//設定第一次點選的棋子和第二次選中的棋子物件
private InetAddress myID;//自己id地址
private InetAddress youID;//目標ID地址
private int sendport;//傳送埠
private int receiveport = 8888;//接收埠
public ChessPanel()//建構函式
{
init_map();//初始化棋盤
//給這個面板新增滑鼠監聽機制
this.addMouseListener(new MouseAdapter()
{
public void mouseClicked(MouseEvent e)
{
if(isPlay == true)//判斷是否該本方下棋
{
SelectChess(e.getPoint());//選擇要移動的棋子
repaint();
}
}
public void SelectChess(Point pos)
{
int x = pos.x;
int y = pos.y;//獲取此時此刻滑鼠點選的位置座標
System.out.println("選擇要移動的棋子座標：x->"+x+" y->"+y);
if(x > 0 && x < (Col-1)*width && y > 0 && y < (Row-1)*height)//判斷滑鼠是否在合理的範圍，不在就直接退出
{
Point point = ReSetID(x,y);
if(isFirst)//判斷是否是第一次選中的棋子
{
x1 = point.x;
y1 = point.y;
//判斷第一次選中的棋子是不是自己的棋子或者是不是無效棋子，不是就失敗
int id = map[x1][y1];
if(id != -1 && chess[id].owner == player)
{
isFirst = false;
firstChess = chess[id];
System.out.println("id->"+id);
}
else//第一次選擇的棋子無效
{
JOptionPane.showConfirmDialog(null,"提示","第一次選棋無效！請重新選擇！",JOptionPane.OK_OPTION);
isFirst = true;
}
}
else//第二次選中的棋子
{
x2 = point.x;
y2 = point.y;
int id = map[x2][y2];
if(id != -1 && chess[id].owner != player)//第二次選擇了敵方棋子，將敵方棋子儲存起來
{
isFirst = true;
secondChess = chess[id];
//開始判斷是否可以移動棋子，如果可以就將棋子移動，併發資訊給對方我們已經移動的棋子資訊
//判斷是否可以移動棋子
if(IsMoveChess(firstChess,y2))//可以移動-吃棋
{
int idx1 = map[x1][y1];
map[x1][y1] = -1;
map[x2][y2] = idx1;
chess[id] = null;
firstChess.SetPos(x2,y2);
repaint();
send("move|"+String.valueOf(idx1)+"|"+String.valueOf(Row-1-x2)+"|"+String.valueOf(Col-1-y2)+"|",youID,sendport);
if(id == 0)//吃掉了黑棋將軍
{
send("success|紅棋贏",sendport);
isPlay = false;
JOptionPane.showConfirmDialog(null,"紅棋勝利","恭喜您，您贏了！",JOptionPane.OK_OPTION);
return;
}
else if(id == 16)//吃掉了紅棋大帥
{
send("success|黑棋贏","黑棋勝利",JOptionPane.OK_OPTION);
return;
}
isFirst = true;
isPlay = false;
}
else//表示不能吃棋，重新下棋
{
JOptionPane.showConfirmDialog(null,"對不起，移動棋子失敗，請重新選擇目標！",JOptionPane.ERROR_MESSAGE);
isFirst = false;
}
}
else if(id != -1 && chess[id].owner == player)//第二次又選擇了自己的棋子，那麼就將第二次選擇的棋子當做第一次選擇的棋子
{
firstChess = chess[id];
x1 = x2;
y1 = y2;
isFirst = false;
}
else//第二次選擇的棋子是空，那麼就是單純的移動棋子
{
secondChess = null;
if(IsMoveChess(firstChess,y2))//可以移動-吃棋
{
int idx1 = map[x1][y1];
map[x1][y1] = -1;
map[x2][y2] = idx1;
// chess[id] = null;
firstChess.SetPos(x2,y2);
send("move|"+String.valueOf(idx1)+"|"+String.valueOf(Row-1-x2)+"|"+String.valueOf(Col-1-y2)+"|",sendport);
System.out.println("第二次選中棋子為空:目標-》"+(Row-1-x2)+" "+(Col-1-y2));
repaint();
isFirst = true;
isPlay = false;
}
}
}
}
}
});
}
public boolean IsMoveChess(Chess chess,int x,int y)//判斷是否可以移動棋子----移動棋子的規則
{
if(chess.chessName.equals("將") || chess.chessName.equals("帥"))//只能走一步
{
int x0 = chess.point.x;
int y0 = chess.point.y;
if(x >= 8 && x <= 10 && y >= 4 && y <= 6)
{
// int x0 = chess.point.x;
// int y0 = chess.point.y;
if(Math.abs(x - x0) > 1 || Math.abs(y - y0) > 1)
return false;
else if(Math.abs(x - x0)*Math.abs(y - y0) != 0)//不能走斜線
return false;
else
return true;
}
if(this.chess[map[x][y]].chessName.equals("將") || this.chess[map[x][y]].chessName.equals("帥") && (y0 == y))//判斷兩個將領之間吃棋
{
int min = x < x0? x : x0;
int max = x > x0? x : x0;
for(min = min+1; min < max; min++)
{
if(map[min][y] != -1)
return false;
}
return true;
}
else
return false;
}
else if(chess.chessName.equals("士") || chess.chessName.equals("仕"))//士也不能出田字格，且，士走斜線，每次只走一格
{
if(x >= 8 && x <= 10 && y >= 4 && y <= 6)
{
int x0 = chess.point.x;
int y0 = chess.point.y;
if(Math.abs(x - x0) * Math.abs(y - y0) != 1)
{
return false;
}
else
return true;
}
else//越界
return false;
}
else if(chess.chessName.equals("象") || chess.chessName.equals("相"))//相走田字，且不能過河
{
if(x >= 6 && x != 11 && y >= 1 && y <= 9)
{
int x0 = chess.point.x;
int y0 = chess.point.y;
if(Math.abs(x - x0) * Math.abs(y - y0) != 4)
{
return false;
}
else if(Math.abs(x - x0) == 2 && Math.abs(y - y0) == 2)
{
int xm,ym;//求取中間值，防止中間有值不能走棋
xm = x > x0? x-1:x0-1;
ym = y > y0? y-1:y0-1;
if(map[xm][ym] != -1)//表示中間有棋
return false;
return true;
}
else//防止1*4 == 4的情況出現
return false;
}
else
return false;
}
else if(chess.chessName.equals("馬"))//馬走日，防止蹩腳的情況出現
{
if(x >= 1 && x <=10 && y >= 1 && y <= 9)
{
int x0 = chess.point.x;
int y0 = chess.point.y;
if(Math.abs(x - x0) * Math.abs(y - y0) == 2)//判斷是否走日
{
//判斷是否蹩腳
if(Math.abs(y - y0) == 2)
{
if(map[x0][y+1] != -1 && y < y0)//左邊
{
return false;
}
if(map[x0][y-1] != -1 && y0 < y)//右邊
{
return false;
}
return true;
}
else
{
if(map[x+1][y0] != -1 && x < x0)//上邊
{
return false;
}
if(map[x-1][y0] != -1 && x > x0)//下邊
{
return false;
}
return true;
}
}
else
return false;
}
else
return false;
}
else if(chess.chessName.equals("車"))//車走直線
{
if(x >= 1 && x <=10 && y >= 1 && y <= 9)
{
int x0 = chess.point.x;
int y0 = chess.point.y;
if(x == x0)//水平移動
{
int i = y < y0 ? y : y0;
int max = y > y0 ? y : y0;
for(i = i+1; i < max; i++)//不判斷目標狀態，目標狀態能否走在外面判斷
{
if(map[x][i] != -1)
{
// if(i == max && this.chess[map[x][i]].owner != chess.owner)
// {
// return true;
// }
return false;
}
}
return true;
}
else if(y == y0)//垂直移動
{
int i = x < x0 ? x : x0;
int max = x > x0 ? x : x0;
for(i = i+1; i < max; i++)
{
if(map[i][y] != -1)
{
// if(i == max && this.chess[map[i][y]].owner != chess.owner)
// {
// return true;
// }
return false;
}
}
return true;
}
return false;
}
else
return false;//越界
}
else if(chess.chessName.equals("炮"))//跑隔山打牛，不隔山就走路，水平或者垂直移動
{
if(x >= 1 && x <=10 && y >= 1 && y <= 9)
{
int x0 = chess.point.x;
int y0 = chess.point.y;
int countx = 0;
int county = 0;
if(x == x0)//水平移動
{
int i = y < y0 ? y : y0;
int max = y > y0 ? y : y0;
for(i = i+1; i < max; i++)
{
if(map[x][i] != -1)
{
countx++;
}
}
}
else if(y == y0)//垂直移動
{
int i = x < x0 ? x : x0;
int max = x > x0 ? x : x0;
for(i = i+1; i < max; i++)
{
if(map[i][y] != -1)
{
county++;
}
}
}
if(countx == 1 || county == 1)//說明中間有一個棋
{
// if(this.chess[map[x][y]].owner != chess.owner)
// {
// return true;
// }
// else
// return false;
System.out.println("countx:"+countx);
System.out.println("county:"+county);
return true;
}
else if(countx == 0 && county == 0)//說明中間沒有棋
{
if(map[x][y] == -1)//目標沒有棋
{
return true;
}
else
return false;
// return true;
}
else
return false;
}
else
return false;//越界
}
else if(chess.chessName.equals("兵") || chess.chessName.equals("卒"))//卒子在自己區域不能退，只能前進，每次只走一步
{
if(x < 7 && x >= 1 && y >= 1 && y <= 9)
{
int x0 = chess.point.x;
int y0 = chess.point.y;
if(x == x0 && Math.abs(y-y0) == 1)//橫向只走一步，判斷是否在河的這邊還是那邊
{
//如果是河的這邊就不能走橫向
if(x == 6)
return false;
else
return true;
}
if(y == y0 && x - x0 == -1)//縱向只走一步,且必須向前走
{
return true;
}
return false;
}
else
return false;
}
return false;
}
public Point ReSetID(int x,int y)//重置id,將id轉化成可辨識的座標資訊
{
int posx = (y+height/2)/height;
int posy = (x+width/2)/width;
return new Point(posx,posy);
}
public void init_map()//初始化棋盤
{
for(int i = 0; i < Row; i++)
{
for(int j = 0; j < Col; j++)
{
map[i][j] = -1;//將棋盤初始化為-1，表示沒有棋子id
}
}
}
public void paint(Graphics g)//自己畫棋盤
{
super.paint(g);
g.clearRect(0,this.getWidth(),this.getHeight());
//畫棋盤
int a = 1;
int b = 8;
int c = 5;//兩軍中間的分界線
for(int j = 1; j < Row-1; j++)//畫橫線
{
g.drawLine(a*width,j*height,(Col-2)*width,j*height);
}
for(int i = 1; i < Col-1; i++)//畫豎線
{
g.drawLine(i*width,a*height,i*width,(Row-2)*height);
if(i == 4)
{
g.drawLine(i*width,(i+2)*width,(a+2)*height);
g.drawLine(i*width,b*height,(b+2)*height);
}
if(i == 6)
{
g.drawLine(i*width,(i-2)*width,(b+2)*height);
}
}
g.drawRect(0,(Col-1)*width,(Row-1)*height);
g.setColor(Color.GRAY);
g.fillRect(a*width,c*height,(Col-2-a)*width,height);
g.setFont(new Font("黑體",Font.BOLD,20));
g.setColor(Color.white);
g.drawString("楚 河 漢 界",3*width,(c+1)*height-10);
g.setColor(Color.black);
//畫棋子
for(int i = 0; i < chess.length; i++)
{
if(chess[i] != null)
{
chess[i].paint(g,this);
}
}
if(firstChess != null)
{
firstChess.paintSeclected(g);
}
if(secondChess != null)
{
secondChess.paintSeclected(g);
}
}
public void send(String str,InetAddress ip,int port) //傳送資料報
{
DatagramSocket s = null;
try{
s = new DatagramSocket();//建立一個數據報套接字
byte data[] = new byte[100];
data = str.getBytes();
DatagramPacket pocket = new DatagramPacket(data,data.length,ip,port);//將資料報的資訊放入自定址包中,自定址資訊包括資料，資料長度，目標ip地址，目標埠號
s.send(pocket);//傳送自定址包
System.out.println("傳送資訊："+str);
}catch(IOException ex)
{
ex.printStackTrace();
}finally
{
if(s != null)
s.close();
}
}
public void startgame(InetAddress ip,int otherport,int myport)//遊戲正式開始的起點入口
{
youID = ip;
this.sendport = otherport;
this.receiveport = myport;
try{
myID = InetAddress.getLocalHost();
}catch(UnknownHostException ex)
{
ex.printStackTrace();
}
send("play|",sendport);//傳送邀請，等待目標ip的迴應----開啟一個執行緒，不斷監聽埠，檢查是否有訊息，是否建立連線成功
Thread t = new Thread(this);
t.start();
}
public void FirstPaintChess()//第一次畫棋盤---將每個棋盤上的棋子物件擺放完好，設定各自的初始屬性
{
//原本把黑棋放上面，紅棋放下面，但是為了顯示效果，凡是玩家玩，都把玩家的花色放下面
init_map();//如果再玩一局就要先清空棋盤，然後再重置棋子，否則上一局某些位置上面的id會遺留下來
paintChess();
if(player == BLACKCHESS)
{
ReverseChess();
}
repaint();
}
public void ReverseChess()//轉置，將座標改變，以便於下棋者下棋
{
//先改變座標
// for(int i = 0; i < 32; i++)
// {
// if(chess[i] != null)
// chess[i].ReversePos();
// }
//改變map地圖id
for(int i = 0; i < 32; i++)
{
if(chess[i] != null)
{
chess[i].ReversePos();
int xx = chess[i].point.x;
int yy = chess[i].point.y;
map[xx][yy] = i;
}
}
}
public void paintChess()//畫棋盤顯示，上面黑棋，下面紅棋
{
//黑方
chess[0] = new Chess("將",BLACKCHESS,new Point(1,5));
map[1][5] = 0;
chess[1] = new Chess("士",4));
map[1][4] = 1;
chess[2] = new Chess("士",6));
map[1][6] = 2;
chess[3] = new Chess("象",3));
map[1][3] = 3;
chess[4] = new Chess("象",7));
map[1][7] = 4;
chess[5] = new Chess("馬",2));
map[1][2] = 5;
chess[6] = new Chess("馬",8));
map[1][8] = 6;
chess[7] = new Chess("車",1));
map[1][1] = 7;
chess[8] = new Chess("車",9));
map[1][9] = 8;
chess[9] = new Chess("炮",new Point(3,2));
map[3][2] = 9;
chess[10] = new Chess("炮",8));
map[3][8] = 10;
for(int i = 11,j = 1; i < 16; i++,j+=2)
{
chess[i] = new Chess("卒",new Point(4,j));
map[4][j] = i;
}
//畫紅棋
chess[16] = new Chess("帥",REDCHESS,new Point(10,5));
map[10][5] = 16;
chess[17] = new Chess("仕",4));
map[10][4] = 17;
chess[18] = new Chess("仕",6));
map[10][6] = 18;
chess[19] = new Chess("相",3));
map[10][3] = 19;
chess[20] = new Chess("相",7));
map[10][7] = 20;
chess[21] = new Chess("馬",2));
map[10][2] = 21;
chess[22] = new Chess("馬",8));
map[10][8] = 22;
chess[23] = new Chess("車",1));
map[10][1] = 23;
chess[24] = new Chess("車",9));
map[10][9] = 24;
chess[25] = new Chess("炮",new Point(8,2));
map[8][2] = 25;
chess[26] = new Chess("炮",8));
map[8][8] = 26;
for(int i = 27,j = 1; i < 32; i++,j+=2)
{
chess[i] = new Chess("兵",new Point(7,j));
map[7][j] = i;
}
}
@Override
public void run()
{
DatagramSocket sock = null;
try {
sock = new DatagramSocket(receiveport);//開啟監聽視窗
byte data[] = new byte[100];
DatagramPacket pocket = new DatagramPacket(data,data.length);
while(flag)
{
sock.receive(pocket);//接收資料
//讀取接收資訊
String str = new String(data);
String s[] = new String[6];
s = str.split("\\|");//將資料資訊按照|進行分割
if(s[0].equals("play"))//表示此時這個物件是一個被邀請的物件，將被邀請的物件設定為黑棋
{
player = BLACKCHESS;//被邀請者設為黑棋
send("connect|",sendport);
//開始畫棋盤
FirstPaintChess();
isPlay = false;//因為是紅棋先走，所以黑棋此時不能下棋
}
else if(s[0].equals("connect"))//表示此時的物件是遊戲發出者物件，並且已經和被邀請物件建立連線
{
player = REDCHESS;//遊戲發出者設為紅棋物件
FirstPaintChess();
isPlay = true;//因為此時是紅棋，而紅旗先走，所以紅棋此時可以下棋
}
else if(s[0].equals("lose"))//對方認輸
{
JOptionPane.showConfirmDialog(null,"認輸","對方棋手認輸！",JOptionPane.OK_OPTION);
isPlay = false;
}
else if(s[0].equals("success"))//對方贏了
{
if(s[1].equals("黑棋贏"))
{
JOptionPane.showConfirmDialog(null,"輸了","黑棋贏了！您輸了！",JOptionPane.OK_OPTION);
}
else if(s[1].equals("紅棋贏"))
{
JOptionPane.showConfirmDialog(null,"紅棋贏了！您輸了！",JOptionPane.OK_OPTION);
}
isPlay = false;
}
else if(s[0].equals("move"))//對方走棋
{
int indx = Integer.parseInt(s[1]);
System.out.println("indx->"+indx);
int posx = Integer.parseInt(s[2]);
System.out.println("posx->"+posx);
int posy = Integer.parseInt(s[3]);
System.out.println("posy->"+posy);
int x = chess[indx].point.x;
int y = chess[indx].point.y;
map[x][y] = -1;
chess[indx].point.x = posx;
chess[indx].point.y = posy;
if(map[posx][posy] != -1)
{
chess[map[posx][posy]] = null;
}
map[posx][posy] = indx;
repaint();
isPlay = true;
}
else if(s[0].equals("quit"))//對方退出
{
JOptionPane.showConfirmDialog(null,"對方離開，遊戲結束！",JOptionPane.OK_OPTION);
isPlay = false;
flag = false;//退出執行緒
}
}
} catch (SocketException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally
{
if(sock != null)
{
sock.close();
}
}
}
}
3.ChessFrame類：
package internet_chess;
import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Rectangle;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.net.InetAddress;
import java.net.UnknownHostException;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
public class ChessFrame extends JFrame{
private JButton start = new JButton("開始");
private JButton end = new JButton("結束");
private JButton lose = new JButton("認輸");
private JPanel paneUp = new JPanel();
private ChessPanel chesspanel = new ChessPanel();
private JPanel paneDown = new JPanel();
private JLabel IPlabel = new JLabel("IP：");
private JLabel otherPortlabel = new JLabel("目標埠");
private JLabel imageicon = new JLabel();
private JTextField ip_address = new JTextField("127.0.0.1");
private JTextField otherPort = new JTextField("9999");
private InetAddress myID;//自己id地址
private InetAddress youID;//目標ID地址
private int sendport;//傳送埠
private int receiveport = 8888;//接收埠
public ChessFrame()//建構函式
{
paneDown.setLayout(new FlowLayout());
IPlabel.setBounds(10,10,40,20);
ip_address.setBounds(new Rectangle(60,50,20));
paneDown.add(IPlabel);
paneDown.add(ip_address);
paneDown.add(otherPortlabel);
paneDown.add(otherPort);
paneDown.add(start);
paneDown.add(lose);
paneDown.add(end);
lose.setEnabled(false);
imageicon.setBounds(new Rectangle(300,100,100));
imageicon.setIcon(new ImageIcon("F:/Image/chess/0.png"));//標籤載入圖片
paneUp.add(imageicon,BorderLayout.CENTER);
Container con = this.getContentPane();
con.add(paneUp,BorderLayout.NORTH);
con.add(chesspanel,BorderLayout.CENTER);
con.add(paneDown,BorderLayout.SOUTH);
this.setTitle("8888網路象棋");
this.setSize(new Dimension(600,700));
this.setVisible(true);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
start.addMouseListener(new MouseAdapter()
{
public void mouseClicked(MouseEvent e)
{
try {
String ip = ip_address.getText();//獲取當前目標ip地址
sendport = Integer.parseInt(otherPort.getText());//獲取目標連線埠
myID = InetAddress.getLocalHost();//獲取本地ip地址
youID = InetAddress.getByName(ip);//獲取目標ip地址
} catch (UnknownHostException e1) {
e1.printStackTrace();
}
chesspanel.startgame(youID,sendport,receiveport);
lose.setEnabled(true);
}
});
end.addMouseListener(new MouseAdapter()
{
public void mouseClicked(MouseEvent e)
{
try{
chesspanel.send("quit|",sendport);//向對方傳送離開資訊，同時斷開連線
System.exit(0);
}catch(Exception ex)
{
ex.printStackTrace();
}
}
});
lose.addMouseListener(new MouseAdapter()
{
public void mouseClicked(MouseEvent e)
{
try{
chesspanel.send("lose|",sendport);//向對方傳送認輸資訊
}catch(Exception ex)
{
ex.printStackTrace();
}
}
});
//加一個對方求和的按鈕
}
public static void main(String[] args) {
// TODO Auto-generated method stub
new ChessFrame();
}
}
程式碼結果
以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支援我們。