• 第二十三章《斗地主游戏》第3节：项目完整代码

    对于初学者来说，斗地主游戏是一个比较复杂的项目，它涉及的类很多，以下是这个项目所有类的源代码，源码中有两个Main.java文件，它们虽然文件名称相同，但位于不同的包下，读者在复制粘贴这两个文件时需要注意要把它们放在正确的位置。

    Message.java

    1. package client.model;
    2. import java.io.*;
    3. import java.util.*;
    4. public class Message implements Serializable {
    5.     private int typeid; //消息类型
    6.     private int playerid; //玩家id
    7.     private String content; //消息内容
    8.     private List pokers = new ArrayList(); //扑克列表
    9.     public int getTypeid() {
    10.         return typeid;
    11.     }
    12.     public void setTypeid(int typeid) {
    13.         this.typeid = typeid;
    14.     }
    15.     public int getPlayerid() {
    16.         return playerid;
    17.     }
    18.     public void setPlayerid(int playerid) {
    19.         this.playerid = playerid;
    20.     }
    21.     public String getContent() {
    22.         return content;
    23.     }
    24.     public void setContent(String content) {
    25.         this.content = content;
    26.     }
    27.     public List getPokers() {
    28.         return pokers;
    29.     }
    30.     public void setPokers(List pokers) {
    31.         this.pokers = pokers;
    32.     }
    33.     public Message() {
    34.     }
    35.     public Message(int typeid, int playerid, String content, List pokers) {
    36.         this.typeid = typeid;
    37.         this.playerid = playerid;
    38.         this.content = content;
    39.         this.pokers = pokers;
    40.     }
    41. }

    Player.java

    1. package client.model;
    2. import java.io.*;
    3. import java.net.*;
    4. import java.util.*;
    5. //玩家类
    6. public class Player implements Serializable {
    7. 	private int id; //玩家id
    8. 	private String name; //玩家姓名
    9. 	private Socket socket; //玩家对应的socket
    10. 	private List pokers=new ArrayList();//玩家的扑克列表
    11. 	public int getId() {
    12. 		return id;
    13. 	}
    14. 	public void setId(int id) {
    15. 		this.id = id;
    16. 	}
    17. 	public String getName() {
    18. 		return name;
    19. 	}
    20. 	public void setName(String name) {
    21. 		this.name = name;
    22. 	}
    23. 	public Socket getSocket() {
    24. 		return socket;
    25. 	}
    26. 	public void setSocket(Socket socket) {
    27. 		this.socket = socket;
    28. 	}
    29. 	public List getPokers() {
    30. 		return pokers;
    31. 	}
    32. 	public void setPokers(List pokers) {
    33. 		this.pokers = pokers;
    34. 	}
    35. 	public Player()
    36. 	{
    37. 	}
    38. 	public Player(int id,String name,Socket socket,List pokers)
    39. 	{
    40. 		this.id=id;
    41. 		this.name=name;
    42. 		this.socket=socket;
    43. 		this.pokers=pokers;
    44. 	}
    45. 	public Player(int id)
    46. 	{
    47. 		this.id=id;
    48. 	}
    49. 	public Player(int id,String name)
    50. 	{
    51. 		this.id=id;
    52. 		this.name=name;
    53. 	}
    54. 	public Player(int id,String name,List pokers)
    55. 	{
    56. 		this.id=id;
    57. 		this.name=name;
    58. 		this.pokers=pokers;
    59. 	}
    60. 	public String toString()
    61. 	{
    62. 		return "player[id:"+this.id+"name:"+this.name+"]";
    63. 	}
    64. }

    Poker.java

    1. package client.model;
    2. import javax.swing.text.html.HTMLDocument.HTMLReader.IsindexAction;
    3. //扑克类
    4. public class Poker {
    5. 	private int id; //扑克id
    6. 	private String name;//扑克名称
    7. 	private int num; //扑克数量
    8. 	private boolean isOut; //扑克是否打出
    9. 	public boolean isOut() {
    10. 		return isOut;
    11. 	}
    12. 	public void setOut(boolean isOut) {
    13. 		this.isOut = isOut;
    14. 	}
    15. 	public int getId() {
    16. 		return id;
    17. 	}
    18. 	public void setId(int id) {
    19. 		this.id = id;
    20. 	}
    21. 	public String getName() {
    22. 		return name;
    23. 	}
    24. 	public void setName(String name) {
    25. 		this.name = name;
    26. 	}
    27. 	public int getNum() {
    28. 		return num;
    29. 	}
    30. 	public void setNum(int num) {
    31. 		this.num = num;
    32. 	}
    33. 	public Poker()
    34. 	{}
    35. 	public Poker(int id,String name,int num)
    36. 	{
    37. 		this.id=id;
    38. 		this.name=name;
    39. 		this.num=num;
    40. 	}
    41. 	public Poker(int id,String name,int num,boolean isOut)
    42. 	{
    43. 		this.id=id;
    44. 		this.name=name;
    45. 		this.num=num;
    46. 		this.isOut=isOut;
    47. 	}
    48. }

    PokerLabel.java

    1. package client.model;
    2. import javax.swing.*;
    3. //扑克标签类
    4. public class PokerLabel extends JLabel implements Comparable{
    5. 	private int id;
    6. 	private String name;
    7. 	private int num;
    8. 	private boolean isOut;
    9. 	private boolean isUp;
    10. 	private boolean isSelected;  //是否选中
    11. 	public boolean isSelected() {
    12. 		return isSelected;
    13. 	}
    14. 	public void setSelected(boolean isSelected) {
    15. 		this.isSelected = isSelected;
    16. 	}
    17. 	public int getId() {
    18. 		return id;
    19. 	}
    20. 	public void setId(int id) {
    21. 		this.id = id;
    22. 	}
    23. 	public String getName() {
    24. 		return name;
    25. 	}
    26. 	public void setName(String name) {
    27. 		this.name = name;
    28. 	}
    29. 	public int getNum() {
    30. 		return num;
    31. 	}
    32. 	public void setNum(int num) {
    33. 		this.num = num;
    34. 	}
    35. 	public boolean isOut() {
    36. 		return isOut;
    37. 	}
    38. 	public void setOut(boolean isOut) {
    39. 		this.isOut = isOut;
    40. 	}
    41. 	public boolean isUp() {
    42. 		return isUp;
    43. 	}
    44. 	public void setUp(boolean isUp) {
    45. 		this.isUp = isUp;
    46. 	}
    47. 	public PokerLabel()
    48. 	{
    49. 		this.setSize(105, 150);
    50. 	}
    51. 	public PokerLabel(int id,String name,int num)
    52. 	{
    53. 		this.id=id;
    54. 		this.name=name;
    55. 		this.num=num;
    56. 		this.setSize(105, 150);
    57. 	}
    58. 	public PokerLabel(int id,String name,int num,boolean isOut,boolean isUp)
    59. 	{
    60. 		this.id=id;
    61. 		this.name=name;
    62. 		this.num=num;
    63. 		this.isOut=isOut;
    64. 		this.isUp=isUp;
    65. 		if(isUp)
    66. 			turnUp();
    67. 		else {
    68. 			turnDown();
    69. 		}
    70.  
    71. 		this.setSize(105, 150);
    72. 	}
    73. 	public void turnUp()
    74. 	{
    75. 		this.setIcon(new ImageIcon("images/poker/"+id+".jpg"));
    76. 	}
    77.  
    78. 	public void turnDown()
    79. 	{
    80. 		this.setIcon(new ImageIcon("images/poker/down.jpg"));
    81. 	}
    82. 	@Override
    83. 	public int compareTo(Object arg0) {
    84. 		PokerLabel pokerLabel=(PokerLabel)arg0;
    85. 		if(this.num>pokerLabel.num)
    86. 			return 1;
    87. 		else if(this.num
    88. 			return -1;
    89. 		else
    90. 			return 0;
    91. 	}
    92. }

    ChuPaiThread.java

    1. package client.thread;
    2. import java.util.*;
    3. import com.alibaba.fastjson.JSON;
    4. import client.model.*;
    5. import client.view.*;
    6. public class ChuPaiThread extends Thread {
    7.     private int time;
    8.     private MainFrame mainFrame;
    9.     private boolean isRun;
    10.     public int getTime() {
    11.         return time;
    12.     }
    13.     public void setTime(int time) {
    14.         this.time = time;
    15.     }
    16.     public MainFrame getMainFrame() {
    17.         return mainFrame;
    18.     }
    19.     public void setMainFrame(MainFrame mainFrame) {
    20.         this.mainFrame = mainFrame;
    21.     }
    22.     public boolean isRun() {
    23.         return isRun;
    24.     }
    25.     public void setRun(boolean isRun) {
    26.         this.isRun = isRun;
    27.     }
    28.     public ChuPaiThread(int time, MainFrame mainFrame) {
    29.         isRun = true;
    30.         this.time = time;
    31.         this.mainFrame = mainFrame;
    32.     }
    33.     public void run() {
    34.         while (time >= 0 && isRun) {
    35.             mainFrame.timeLabel.setText(time + "");
    36.             time--;
    37.             try {
    38.                 Thread.sleep(1000);
    39.             } catch (InterruptedException e) {
    40.                 // TODO Auto-generated catch block
    41.                 e.printStackTrace();
    42.             }
    43.         }
    44.         Message message = null;
    45.         //如果是不出 (一种是时间到了 一种是 选择不出)
    46.         if (time == -1 || isRun == false && mainFrame.isOut == false) {
    47.             //时间到了不出，则将出牌按钮隐藏
    48.             mainFrame.chupaiJLabel.setVisible(false);
    49.             mainFrame.buchuJLabel.setVisible(false);
    50.             mainFrame.timeLabel.setVisible(false);
    51.             message = new Message(3, mainFrame.currentPlayer.getId(), "不出", null);
    52.             //转换为json 交给 sendThread发送到服务器去
    53.             String msg = JSON.toJSONString(message);
    54.             mainFrame.sendThread.setMsg(msg);
    55.         }
    56.         //出牌
    57.         if (isRun == false && mainFrame.isOut == true) {
    58.             message = new Message(4, mainFrame.currentPlayer.getId(), "出牌",
    59.                     changePokerLableToPoker(mainFrame.selectedPokerLabels));
    60.             //转换为json 交给 sendThread发送到服务器去
    61.             String msg = JSON.toJSONString(message);
    62.             mainFrame.sendThread.setMsg(msg);
    63.             //将当前发送出去的扑克牌 从扑克牌列表中移除
    64.             mainFrame.removeOutPokerFromPokerList();
    65.             //如果扑克列表的数量为0 代表赢了
    66.             if (mainFrame.pokerLabels.size() == 0) {
    67.                 //产生游戏结束的消息
    68.                 message = new Message(5, mainFrame.currentPlayer.getId(),
    69.                         "游戏结束", null);
    70.                 msg = JSON.toJSONString(message);
    71.                 try {
    72.                     Thread.sleep(100);
    73.                     //发送消息
    74.                     mainFrame.sendThread.setMsg(msg);
    75.                 } catch (InterruptedException e) {
    76.                     e.printStackTrace();
    77.                 }
    78.             }
    79.         }
    80.     }
    81.     public List changePokerLableToPoker(List selectedPokerLabels) {
    82.         List list = new ArrayList();
    83.         for (int i = 0; i < selectedPokerLabels.size(); i++) {
    84.             PokerLabel pokerLabel = selectedPokerLabels.get(i);
    85.             Poker poker = new Poker(pokerLabel.getId(), pokerLabel.getName(),
    86.                     pokerLabel.getNum());
    87.             list.add(poker);
    88.         }
    89.         return list;
    90.     }
    91. }

    CountThread.java

    1. package client.thread;
    2. import com.alibaba.fastjson.JSON;
    3. import client.model.*;
    4. import client.view.*;
    5. //计时器的线程
    6. public class CountThread extends Thread{
    7. 	private int i;
    8. 	private MainFrame mainFrame;
    9. 	private boolean isRun;
    10. 	public boolean isRun() {
    11. 		return isRun;
    12. 	}
    13. 	public void setRun(boolean isRun) {
    14. 		this.isRun = isRun;
    15. 	}
    16. 	public CountThread(int i,MainFrame mainFrame)
    17. 	{
    18. 		isRun=true;
    19. 		this.i=i;
    20. 		this.mainFrame=mainFrame;
    21. 	}
    22. 	public void run()
    23. 	{
    24. 		while(i>=0 && isRun)
    25. 		{
    26. 			mainFrame.timeLabel.setText(i+"");
    27. 			i--;
    28. 			try {
    29. 				Thread.sleep(1000);
    30. 			} catch (InterruptedException e) {
    31. 				e.printStackTrace();
    32. 			}
    33. 		}
    34. 		Message msg=null;
    35. 		//时间到了 或者 点击过不抢地主的按钮了
    36. 		if(i==-1 || isRun==false && mainFrame.isLord==false)
    37. 		{
    38. 			msg=new Message(1,mainFrame.currentPlayer.getId(),
    39. 					"不抢",null);
    40. 		}
    41. 		//点了抢地主的按钮了
    42. 		if(isRun==false && mainFrame.isLord==true)
    43. 		{
    44. 			msg=new Message(2,mainFrame.currentPlayer.getId(),
    45. 					"抢地主",null);
    46. 		}
    47. 		//将消息传到服务器端
    48. 		mainFrame.sendThread.setMsg(JSON.toJSONString(msg));
    49. 	}
    50. }

    ReceiveThread.java

    1. package client.thread;
    2. import java.awt.*;
    3. import javax.swing.*;
    4. import java.io.*;
    5. import java.net.*;
    6. import java.util.*;
    7. import com.alibaba.fastjson.*;
    8. import client.model.*;
    9. import client.view.*;
    10. //创建一个接收消息的线程
    11. public class ReceiveThread extends Thread {
    12.     private Socket socket;
    13.     private MainFrame mainFrame;
    14.     private int step = 0;
    15.     private boolean isRun = true;
    16.     public boolean isRun() {
    17.         return isRun;
    18.     }
    19.     public void setRun(boolean isRun) {
    20.         this.isRun = isRun;
    21.     }
    22.     public ReceiveThread(Socket socket, MainFrame mainFrame) {
    23.         this.socket = socket;
    24.         this.mainFrame = mainFrame;
    25.     }
    26.     public void run() {
    27.         try {
    28.             DataInputStream dataInputStream =
    29.                     new DataInputStream(socket.getInputStream());
    30.             while (true) {
    31.                 if (isRun == false)
    32.                     break;
    33.                 //接收从服务器端传递过来的消息 json字符串
    34.                 String jsonString = dataInputStream.readUTF();
    35.                 if (step == 0) {
    36.                     java.util.List players = new ArrayList();
    37.                     //System.out.println(jsonString);
    38.                     //解析json字符串  "[{},{}]"  [{},{}]
    39.                     //将json字符串转换为json数组
    40.                     JSONArray playerJsonArray = JSONArray.parseArray(jsonString);
    41.                     for (int i = 0; i < playerJsonArray.size(); i++) {
    42.                         //获得当个json对象--> 玩家对象
    43.                         JSONObject playerJson = (JSONObject) playerJsonArray.get(i);
    44.                         int id = playerJson.getInteger("id");
    45.                         String name = playerJson.getString("name");
    46.  
    47.                         //存放扑克列表
    48.                         java.util.List pokers = new ArrayList();
    49.                         JSONArray pokerJsonArray =
    50.                                 playerJson.getJSONArray("pokers");
    51.                         for (int j = 0; j < pokerJsonArray.size(); j++) {
    52.                             // 每循环一次 获得一个扑克对象
    53.                             JSONObject pokerJSon = (JSONObject) pokerJsonArray.get(j);
    54.                             int pid = pokerJSon.getInteger("id");
    55.                             String pname = pokerJSon.getString("name");
    56.                             int num = pokerJSon.getInteger("num");
    57.                             Poker poker = new Poker(pid, pname, num);
    58.                             pokers.add(poker);
    59.                         }
    60.                         Player player = new Player(id, name, pokers);
    61.                         players.add(player);
    62.                     }
    63.                     //获得3个玩家的信息了
    64.                     if (players.size() == 3) {
    65.                         mainFrame.showAllPlayersInfo(players);
    66.                         step = 1; //玩家到齐 进展到第二步
    67.                     }
    68.                 } else if (step == 1) {
    69.                     //接收抢地主的消息或者出牌的消息
    70.                     JSONObject msgJsonObject = JSONObject.parseObject(jsonString);
    71.                     //解析消息对象
    72.                     int typeid = msgJsonObject.getInteger("typeid");
    73.                     int playerid = msgJsonObject.getInteger("playerid");
    74.                     String contentString = msgJsonObject.getString("content");
    75.                     //消息类型为不抢
    76.                     if (typeid == 1) {
    77.                         //1.主窗口显示不抢的信息
    78.                         mainFrame.showMsg(playerid, 1);
    79.                         //2.设置下一家开始抢地主
    80.                         if (playerid + 1 == mainFrame.currentPlayer.getId())
    81.                             mainFrame.getLord();
    82.                     }
    83.                     //抢地主的消息
    84.                     if (typeid == 2) {
    85.                         //获得地主牌
    86.                         JSONArray pokersJsonArray =
    87.                                 msgJsonObject.getJSONArray("pokers");
    88.                         java.util.List lordPokers = new ArrayList();
    89.                         for (int i = 0; i < pokersJsonArray.size(); i++) {
    90.                             JSONObject pokerJsonObject = (JSONObject) pokersJsonArray.get(i);
    91.                             int id = pokerJsonObject.getInteger("id");
    92.                             String name = pokerJsonObject.getString("name");
    93.                             int num = pokerJsonObject.getInteger("num");
    94.                             Poker p = new Poker(id, name, num);
    95.                             System.out.println(p);
    96.                             lordPokers.add(p);
    97.                         }
    98.                         //如果是自己抢的地主
    99.                         if (mainFrame.currentPlayer.getId() == playerid) {
    100.                             //添加地主牌
    101.                             mainFrame.addLordPokers(lordPokers);
    102.                             //第一家出牌 显示出牌的按钮
    103.                             mainFrame.showChuPaiJabel();
    104.                         }
    105.                         //显示地主图标
    106.                         mainFrame.showLordIcon(playerid);
    107.                         //之前的消息框隐藏
    108.                         mainFrame.msgLabel.setVisible(false);
    109.                         //所有玩家 都可以选择出牌列表 (不代表能出牌)
    110.                         mainFrame.addClickEventToPoker();
    111.                     }
    112.                     if (typeid == 3) //不出牌
    113.                     {
    114.                         //显示不出牌的消息
    115.                         mainFrame.showMsg(playerid, 3);
    116.                         //判断自己是不是下一家 如果是 显示出牌按钮  0->1   1-> 2   2-> 0
    117.                         if (playerid + 1 == mainFrame.currentPlayer.getId() ||
    118.                                 playerid - 2 == mainFrame.currentPlayer.getId()) {
    119.                             mainFrame.showChuPaiJabel();
    120.                         }
    121.                     }
    122.                     if (typeid == 4) //出牌
    123.                     {
    124.                         //获得出牌列表
    125.                         JSONArray pokersJsonArray =
    126.                                 msgJsonObject.getJSONArray("pokers");
    127.  
    128.                         java.util.List outPokers = new ArrayList();
    129.  
    130.                         for (int i = 0; i < pokersJsonArray.size(); i++) {
    131.                             JSONObject pokerJsonObject = (JSONObject) pokersJsonArray.get(i);
    132.                             int id = pokerJsonObject.getInteger("id");
    133.                             String name = pokerJsonObject.getString("name");
    134.                             int num = pokerJsonObject.getInteger("num");
    135.                             Poker p = new Poker(id, name, num);
    136.                             System.out.println(p);
    137.                             outPokers.add(p);
    138.                         }
    139.                         //显示出牌列表
    140.                         mainFrame.showOutPokerList(playerid, outPokers);
    141.                         //判断自己是不是下一家 如果是 显示出牌按钮  0->1   1-> 2   2-> 0
    142.                         if (playerid + 1 == mainFrame.currentPlayer.getId() ||
    143.                                 playerid - 2 == mainFrame.currentPlayer.getId()) {
    144.                             mainFrame.showChuPaiJabel();
    145.                         }
    146.                         mainFrame.prevPlayerid = playerid; //记录上一个出牌的玩家id
    147.                     }
    148.                     //如果是游戏结束的消息
    149.                     if (typeid == 5) {
    150.                         if (playerid == mainFrame.currentPlayer.getId()) {
    151.                             JOptionPane.showMessageDialog(mainFrame, "赢了");
    152.                         } else {
    153.                             JOptionPane.showMessageDialog(mainFrame, "输了");
    154.                         }
    155.                         //游戏结束 关闭线程 清理窗口等
    156.                         mainFrame.gameOver();
    157.                     }
    158.                 }
    159.             }
    160.         } catch (IOException e) {
    161.             // TODO Auto-generated catch block
    162.             e.printStackTrace();
    163.         }
    164.     }
    165. }

    SendThread.java

    1. package client.thread;
    2. import java.io.*;
    3. import java.net.Socket;
    4. //发送消息的线程
    5. public class SendThread extends Thread {
    6.     private String msg;
    7.     public String getMsg() {
    8.         return msg;
    9.     }
    10.     public void setMsg(String msg) {
    11.         this.msg = msg;
    12.     }
    13.     private Socket socket;
    14.     public Socket getSocket() {
    15.         return socket;
    16.     }
    17.     public void setSocket(Socket socket) {
    18.         this.socket = socket;
    19.     }
    20.     private boolean isRun = true;
    21.     public boolean isRun() {
    22.         return isRun;
    23.     }
    24.     public void setRun(boolean isRun) {
    25.         this.isRun = isRun;
    26.     }
    27.     public SendThread(Socket socket) {
    28.         this.socket = socket;
    29.     }
    30.     public SendThread(Socket socket, String msg) {
    31.         this.socket = socket;
    32.         this.msg = msg;
    33.     }
    34.     public SendThread() {
    35.     }
    36.     public void run() {
    37.         DataOutputStream dataOutputStream;
    38.         try {
    39.             dataOutputStream = new DataOutputStream(socket.getOutputStream());
    40.             while (true) {
    41.                 if (isRun == false) {
    42.                     break;
    43.                 }
    44.                 //如果消息不为null
    45.                 if (msg != null) {
    46.                     System.out.println("消息在发送中:" + msg);
    47.                     //发送消息
    48.                     dataOutputStream.writeUTF(msg);
    49.                     //消息发送完毕 消息内容清空
    50.                     msg = null;
    51.                 }
    52.                 Thread.sleep(50);  //暂停 等待新消息进来
    53.             }
    54.         } catch (IOException e) {
    55.             e.printStackTrace();
    56.         } catch (InterruptedException e) {
    57.             e.printStackTrace();
    58.         }
    59.     }
    60. }

    GameUtil.java

    1. package client.util;
    2. import client.model.*;
    3. public class GameUtil {
    4. 	public static void move(PokerLabel pokerLabel,int x,int y)
    5. 	{
    6. 		 pokerLabel.setLocation(x, y);
    7. 		 try {
    8. 			Thread.sleep(50);
    9. 		} catch (InterruptedException e) {
    10. 			e.printStackTrace();
    11. 		}
    12. 	}
    13. 	public static void move2(PokerLabel pokerLabel,int x,int y)
    14. 	{
    15. 		 pokerLabel.setLocation(x, y);
    16. 	}
    17. }

    PokerRule.java

    1. package client.util;
    2. import java.util.*;
    3. import client.model.*;
    4. public class PokerRule {
    5.     //判断牌型
    6.     public static PokerType checkPokerType(List list) {
    7.         Collections.sort(list);
    8.         int count = list.size();
    9.         if (count == 1) {
    10.             //单张
    11.             return PokerType.p_1;
    12.         } else if (count == 2) {
    13.             //对子
    14.             if (isSame(list, count)) {
    15.                 return PokerType.p_2;
    16.             }
    17.             //王炸
    18.             if (isWangZha(list)) {
    19.                 return PokerType.p_2w;
    20.             }
    21.             return PokerType.p_error;
    22.         } else if (count == 3) {
    23.             //三个头
    24.             if (isSame(list, count)) {
    25.                 return PokerType.p_3;
    26.             }
    27.             return PokerType.p_error;
    28.         } else if (count == 4) {
    29.             //炸弹
    30.             if (isSame(list, count)) {
    31.                 return PokerType.p_4;
    32.             }
    33.             //三带一
    34.             if (isSanDaiYi(list)) {
    35.                 return PokerType.p_31;
    36.             }
    37.             return PokerType.p_error;
    38.  
    39.         } else if (count >= 5) {
    40.             //顺子
    41.             if (isShunZi(list)) {
    42.                 return PokerType.p_n;
    43.             } else if (isSanDaiYiDui(list)) {
    44.                 //三代一对
    45.                 return PokerType.p_32;
    46.             } else if (isLianDui(list)) {
    47.                 //连对
    48.                 return PokerType.p_1122;
    49.             } else if (isFeiJI(list)) {
    50.                 //双飞or双飞双带
    51.                 return PokerType.p_111222;
    52.             } else if (isFeiJIDaiChiBang1(list)) {
    53.                 //双飞or双飞双带
    54.                 return PokerType.p_11122234;
    55.             } else if (isFeiJIDaiChiBang2(list)) {
    56.                 //双飞or双飞双带
    57.                 return PokerType.p_1112223344;
    58.             }
    59.         }
    60.         return PokerType.p_error;
    61.     }
    62.     public static boolean isWangZha(List list) {
    63.         if ((list.get(0).getNum() == 16 && list.get(1).getNum() == 17) ||
    64.                 (list.get(0).getNum() == 17 && list.get(1).getNum() == 16)) {
    65.             return true;
    66.         }
    67.         return false;
    68.     }
    69.     //判断list内扑克是否相同
    70.     public static boolean isSame(List list, int count) {
    71.         for (int j = 0; j < count - 1; j++) {
    72.             int a = list.get(j).getNum();
    73.             int b = list.get(j + 1).getNum();
    74.             if (a != b) {
    75.                 return false;
    76.             }
    77.         }
    78.         return true;
    79.     }
    80.     //判断是否是三带一
    81.     public static boolean isSanDaiYi(List list) {
    82.         List temp = new ArrayList();
    83.         temp.addAll(list);
    84.         if (isSame(temp, 3)) {
    85.             return true;
    86.         }
    87.         temp.remove(0);
    88.         if (isSame(temp, 3)) {
    89.             return true;
    90.         }
    91.         return false;
    92.     }
    93.     //判断是否是三带一对
    94.     public static boolean isSanDaiYiDui(List list) {
    95.         List temp = new ArrayList();
    96.         temp.addAll(list);
    97.         if (temp.size() == 5) {
    98.             if (isSame(temp, 3)) {
    99.                 temp.remove(0);
    100.                 temp.remove(0);
    101.                 temp.remove(0);
    102.                 if (isSame(temp, 2)) {
    103.                     return true;
    104.                 }
    105.                 return false;
    106.             }
    107.             if (isSame(temp, 2)) {
    108.                 temp.remove(0);
    109.                 temp.remove(0);
    110.                 if (isSame(temp, 3)) {
    111.                     return true;
    112.                 }
    113.                 return false;
    114.             }
    115.         }
    116.         return false;
    117.     }
    118.     // 判断是否是顺子
    119.     public static boolean isShunZi(List list) {
    120.         for (int i = 0; i < list.size() - 1; i++) {
    121.             int a = list.get(i).getNum();
    122.             int b = list.get(i + 1).getNum();
    123.             if (b - a != 1) {
    124.                 return false;
    125.             }
    126.         }
    127.         return true;
    128.     }
    129.     // 判断是否是连对
    130.     public static boolean isLianDui(List list) {
    131.         int size = list.size();
    132.         if (size < 6 && size % 2 != 0) {
    133.             return false;
    134.         }
    135.         for (int i = 0; i < size; i++) {
    136.             int a = list.get(i).getNum();
    137.             int b = list.get(i + 1).getNum();
    138.             if (a != b) {
    139.                 return false;
    140.             }
    141.             i++;
    142.         }
    143.         for (int i = 0; i < size; i++) {
    144.             int a = list.get(i).getNum();
    145.             int b = list.get(i + 2).getNum();
    146.             if (b - a != 1) {
    147.                 return false;
    148.             }
    149.             i++;
    150.             i++;
    151.         }
    152.         return true;
    153.     }
    154.     //判断是不是双飞
    155.     public static boolean isFeiJI(List list) {
    156.         List count = feiCount(list);
    157.         if (count != null && count.size() >= 2) {
    158.             int len = count.size();
    159.             for (int i = 0; i < len - 1; i++) {
    160.                 if (count.get(i + 1) - count.get(i) != 1) {
    161.                     return false;
    162.                 }
    163.             }
    164.             int dui = feiDuiCount(list, count);
    165.             if (dui == 0) {
    166.                 return true;
    167.             }
    168.         }
    169.         return false;
    170.     }
    171.     //飞机带翅膀 3311
    172.     public static boolean isFeiJIDaiChiBang2(List list) {
    173.         List feiji = feiCount(list);
    174.         if (feiji != null && feiji.size() >= 2) {
    175.             int len = feiji.size();
    176.             for (int i = 0; i < len - 1; i++) {
    177.                 if (feiji.get(i + 1) - feiji.get(i) != 1) {
    178.                     return false;
    179.                 }
    180.             }
    181.             int dui = feiDuiCount(list, feiji);
    182.             if (dui == feiji.size()) {
    183.                 return true;
    184.             }
    185.         }
    186.         return false;
    187.     }
    188.     //飞机带翅膀3322
    189.     public static boolean isFeiJIDaiChiBang1(List list) {
    190.         List feiji = feiCount(list);
    191.         if (feiji != null && feiji.size() >= 2) {
    192.             int len = feiji.size();
    193.             for (int i = 0; i < len - 1; i++) {
    194.                 if (feiji.get(i + 1) - feiji.get(i) != 1) {
    195.                     return false;
    196.                 }
    197.             }
    198.             int dui = feiDanZhangCount(list, feiji);
    199.             if (dui == feiji.size()) {
    200.                 return true;
    201.             }
    202.         }
    203.         return false;
    204.     }
    205.     //判断三个头有几个
    206.     public static List feiCount(List list) {
    207.         List cnt = new ArrayList();
    208.         for (int i = 0; i < list.size() - 2; i++) {
    209.             int a = list.get(i).getNum();
    210.             int b = list.get(i + 1).getNum();
    211.             int c = list.get(i + 2).getNum();
    212.             if (a == b && a == c) {
    213.                 cnt.add(a);
    214.             }
    215.         }
    216.         return cnt;
    217.     }
    218.     // 判断双飞中对子有几个
    219.     public static int feiDuiCount(List list,
    220.                                   List feiji) {
    221.         List temp = new ArrayList();
    222.         temp.addAll(list);
    223.         int cnt = 0;
    224.         for (int i = 0; i < temp.size(); i++) {
    225.             for (int j = 0; j < feiji.size(); j++) {
    226.                 int a = list.get(i).getNum();
    227.                 if (a == feiji.get(j)) {
    228.                     temp.remove(i);
    229.                 }
    230.             }
    231.         }
    232.         int size = temp.size();
    233.         if (size > 0 && size % 2 == 0) {
    234.             for (int i = 0; i < temp.size() - 1; i++) {
    235.                 int a = list.get(i).getNum();
    236.                 int b = list.get(i + 1).getNum();
    237.                 if (a == b) {
    238.                     cnt++;
    239.                 }
    240.             }
    241.         }
    242.         return cnt;
    243.     }
    244.     //判断双飞中单张有几个
    245.     public static int feiDanZhangCount(List list,
    246.                                        List feiji) {
    247.         List temp = new ArrayList();
    248.         temp.addAll(list);
    249.         int cnt = 0;
    250.         for (int i = 0; i < temp.size(); i++) {
    251.             for (int j = 0; j < feiji.size(); j++) {
    252.                 int a = list.get(i).getNum();
    253.                 if (a == feiji.get(j)) {
    254.                     temp.remove(i);
    255.                 }
    256.             }
    257.         }
    258.         int size = temp.size();
    259.         if (size > 0) {
    260.             for (int i = 0; i < temp.size() - 1; i++) {
    261.                 int a = list.get(i).getNum();
    262.                 int b = list.get(i + 1).getNum();
    263.                 if (a != b) {
    264.                     cnt++;
    265.                 }
    266.             }
    267.         }
    268.         return cnt;
    269.     }
    270.     //判断是否符合出牌规则，即根据上家牌面判断本次出牌是否合规
    271.     public static boolean legal(List prevList,
    272.                                 List currentList) {
    273.         // 首先判断牌型是不是一样
    274.         PokerType paiXing = checkPokerType(prevList);
    275.         if (paiXing.equals(checkPokerType(currentList))) {
    276.             // 根据牌型来判断大小
    277.             if (PokerType.p_1.equals(paiXing)) {
    278.                 // 单张
    279.                 if (compareLast(prevList, currentList)) {
    280.                     return true;
    281.                 }
    282.                 return false;
    283.             } else if (PokerType.p_2w.equals(paiXing)) {
    284.                 // 王炸
    285.                 return false;
    286.             } else if (PokerType.p_2.equals(paiXing)) {
    287.                 // 对子
    288.                 if (compareLast(prevList, currentList)) {
    289.                     return true;
    290.                 }
    291.                 return false;
    292.             } else if (PokerType.p_3.equals(paiXing)) {
    293.                 // 三张
    294.                 if (compareLast(prevList, currentList)) {
    295.                     return true;
    296.                 }
    297.                 return false;
    298.             } else if (PokerType.p_31.equals(paiXing)) {
    299.                 // 三带一
    300.                 if (compareLast(prevList, currentList)) {
    301.                     return true;
    302.                 }
    303.                 return false;
    304.             } else if (PokerType.p_32.equals(paiXing)) {
    305.                 // 三带一对
    306.                 if (compare(prevList, currentList)) {
    307.                     return true;
    308.                 }
    309.                 return false;
    310.             } else if (PokerType.p_4.equals(paiXing)) {
    311.                 // 炸弹
    312.                 if (compareLast(prevList, currentList)) {
    313.                     return true;
    314.                 }
    315.                 return false;
    316.             } else if (PokerType.p_n.equals(paiXing)) {
    317.                 // 顺子
    318.                 if (compareLast(prevList, currentList)) {
    319.                     return true;
    320.                 }
    321.                 return false;
    322.             } else if (PokerType.p_1122.equals(paiXing)) {
    323.                 // 连对
    324.                 if (compareLast(prevList, currentList)) {
    325.                     return true;
    326.                 }
    327.                 return false;
    328.             } else if (PokerType.p_111222.equals(paiXing)) {
    329.                 // 双飞
    330.                 if (compare(prevList, currentList)) {
    331.                     return true;
    332.                 }
    333.                 return false;
    334.             } else if (PokerType.p_11122234.equals(paiXing)) {
    335.                 // 飞机带翅膀（单张）
    336.                 if (compare(prevList, currentList)) {
    337.                     return true;
    338.                 }
    339.                 return false;
    340.             } else if (PokerType.p_1112223344.equals(paiXing)) {
    341.                 // 飞机带翅膀（对子）
    342.                 if (compare(prevList, currentList)) {
    343.                     return true;
    344.                 }
    345.                 return false;
    346.             }
    347.         } else if (currentList.size() == 2) {
    348.             //判断是不是王炸
    349.             if (isWangZha(currentList)) {
    350.                 return true;
    351.             }
    352.             return false;
    353.         } else if (currentList.size() == 4) {
    354.             //判断是不是炸弹
    355.             if (isSame(currentList, 4)) {
    356.                 return true;
    357.             }
    358.             return false;
    359.         }
    360.         return false;
    361.     }
    362.  
    363.     public static boolean compareLast(List prevList,
    364.                                       List currentList) {
    365.         if (prevList.get(prevList.size() - 1).getNum() <
    366.                 currentList.get(currentList.size() - 1).getNum()) {
    367.             return true;
    368.         }
    369.         return false;
    370.     }
    371.     public static boolean compare(List prevList,
    372.                                   List currentList) {
    373.         int a = san(prevList);
    374.         int b = san(currentList);
    375.         if (a == -1 || b == -1) {
    376.             return false;
    377.         }
    378.         if (b > a) {
    379.             return true;
    380.         }
    381.         return false;
    382.     }
    383.     public static int san(List list) {
    384.         for (int i = 0; i < list.size() - 2; i++) {
    385.             int a = list.get(i).getNum();
    386.             int b = list.get(i + 1).getNum();
    387.             int c = list.get(i + 2).getNum();
    388.             if (a == b && a == c) {
    389.                 return a;
    390.             }
    391.         }
    392.         return -1;
    393.     }
    394. }

    PokerType.java

    1. package client.util;
    2. public enum PokerType {
    3. 	p_1,//单牌。
    4. 	p_2,//对子。
    5. 	p_2w,//王炸
    6. 	p_3,//3不带。
    7. 	p_4,//炸弹。
    8. 	p_n,//顺子。
    9. 	p_31,//3带1。
    10. 	p_32,//3带2。
    11. 	p_1122,//连队。
    12. 	p_111222,//飞机。
    13. 	p_11122234,//飞机带单排.
    14. 	p_1112223344,//飞机带对子.
    15. 	p_error//不能出牌
    16. }

    LoginFrame.java

    1. package client.view;
    2. import java.awt.*;
    3. import java.awt.event.*;
    4. import javax.swing.*;
    5. import java.io.*;
    6. import java.net.*;
    7. public class LoginFrame extends JFrame {
    8.     private JLabel lblUserName;
    9.     private JTextField txtUserName;
    10.     private JButton btnLogin;
    11.     private JButton btnCancel;
    12.     private void init() {
    13.         Container container = this.getContentPane();
    14.         //创建组件对象
    15.         lblUserName = new JLabel("用户名:");
    16.         txtUserName = new JTextField();
    17.         btnLogin = new JButton("登录");
    18.         btnCancel = new JButton("取消");
    19.         //设置窗口属性
    20.         setSize(400, 220);
    21.         setVisible(true);
    22.         setLocationRelativeTo(null);
    23.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    24.         container.setLayout(null);
    25.         //设置组件属性
    26.         lblUserName.setSize(80, 25);
    27.         lblUserName.setLocation(90, 50);
    28.         lblUserName.setFont(new Font("微软雅黑", Font.PLAIN, 20));
    29.         txtUserName.setSize(120, 25);
    30.         txtUserName.setLocation(180, 50);
    31.         txtUserName.setFont(new Font("微软雅黑", Font.PLAIN, 20));
    32.         btnLogin.setSize(80, 25);
    33.         btnLogin.setLocation(100, 100);
    34.         btnLogin.setFont(new Font("微软雅黑", Font.PLAIN, 20));
    35.         btnCancel.setSize(80, 25);
    36.         btnCancel.setLocation(200, 100);
    37.         btnCancel.setFont(new Font("微软雅黑", Font.PLAIN, 20));
    38.         //添加组件到窗口中
    39.         container.add(lblUserName);
    40.         container.add(txtUserName);
    41.         container.add(btnLogin);
    42.         container.add(btnCancel);
    43.         //创建监听器对象 绑定到按钮上
    44.         MyEvent myEvent = new MyEvent();
    45.         btnLogin.addActionListener(myEvent);
    46.     }
    47.     public LoginFrame() {
    48.         init();
    49.     }
    50.     //创建事件监听器类
    51.     class MyEvent implements ActionListener {
    52.         @Override
    53.         public void actionPerformed(ActionEvent arg0) {
    54.             //点击登录
    55.             //1.获得用户名
    56.             String uname = txtUserName.getText();
    57.             //2.创建一个socket链接服务器端
    58.             try {
    59.                 Socket socket = new Socket("127.0.0.1", 8888);
    60.                 //3.跳转到主窗口
    61.                 new MainFrame(uname, socket);
    62.                 dispose();//关闭当前窗口
    63.             } catch (UnknownHostException e) {
    64.                 e.printStackTrace();
    65.             } catch (IOException e) {
    66.                 e.printStackTrace();
    67.             }
    68.         }
    69.     }
    70. }

    MainFrame.java

    1. package client.view;
    2. import java.awt.*;
    3. import java.awt.event.*;
    4. import java.io.*;
    5. import java.net.*;
    6. import java.util.*;
    7. import javax.swing.*;
    8. import client.model.*;
    9. import client.util.*;
    10. import client.thread.*;
    11. public class MainFrame extends JFrame {
    12.     public MyPanel myPanel;
    13.     public String uname;
    14.     public Socket socket;
    15.     public SendThread sendThread; // 发送消息的线程
    16.     public ReceiveThread receiveThread;// 接收消息的线程
    17.     public Player currentPlayer; // 存放当前玩家对象
    18.     public java.util.List pokerLabels =
    19.             new ArrayList(); // 存放扑克标签列表
    20.     public JLabel lordLabel1; // 抢地主标签
    21.     public JLabel lordLabel2; // 不叫
    22.     public JLabel timeLabel; // 定时器标签
    23.     public CountThread countThread; // 计数器的线程
    24.     public boolean isLord; // 是否是地主
    25.     public JLabel msgLabel; // 存放消息
    26.     public JLabel lordIconLabel; //地主图标
    27.     public JLabel chupaiJLabel;//出牌标签
    28.     public JLabel buchuJLabel; //不出牌标签
    29.     public ChuPaiThread chuPaiThread; //出牌定时器线程
    30.     public java.util.List selectedPokerLabels =
    31.             new ArrayList();//存放选中的扑克列表
    32.     public java.util.List showOutPokerLabels =
    33.             new ArrayList(); //存放当前出牌的列表
    34.     public boolean isOut;  //选择的是出牌还是不出牌
    35.     public int prevPlayerid = -1; //上一个出牌的玩家id
    36.     public MainFrame(String uname, Socket socket) {
    37.         this.uname = uname;
    38.         this.socket = socket;
    39.         // 设置窗口的属性
    40.         this.setTitle(uname);
    41.         this.setSize(1200, 700);
    42.         this.setVisible(true);
    43.         this.setLocationRelativeTo(null);
    44.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    45.         // 添加mypanel
    46.         myPanel = new MyPanel();
    47.         myPanel.setBounds(0, 0, 1200, 700);
    48.         this.add(myPanel);
    49.         //初始化窗口信息
    50.         init();
    51.         // 启动发消息的线程
    52.         sendThread = new SendThread(socket, uname);
    53.         sendThread.start();
    54.         // 启动接收消息的线程
    55.         receiveThread = new ReceiveThread(socket, this);
    56.         receiveThread.start();
    57.     }
    58.     //窗口初始化
    59.     public void init() {
    60.         //创建消息框
    61.         msgLabel = new JLabel();
    62.         chupaiJLabel = new JLabel();
    63.         chupaiJLabel.setBounds(330, 350, 110, 53);
    64.         chupaiJLabel.setIcon(new ImageIcon("images/bg/chupai.png"));
    65.         chupaiJLabel.addMouseListener(new MyMouseEvent());
    66.         chupaiJLabel.setVisible(false);
    67.         this.myPanel.add(chupaiJLabel);
    68.         buchuJLabel = new JLabel();
    69.         buchuJLabel.setBounds(440, 350, 110, 53);
    70.         buchuJLabel.setIcon(new ImageIcon("images/bg/buchupai.png"));
    71.         buchuJLabel.addMouseListener(new MyMouseEvent());
    72.         buchuJLabel.setVisible(false);
    73.         this.myPanel.add(buchuJLabel);
    74.         timeLabel = new JLabel();
    75.         timeLabel.setBounds(550, 350, 50, 50);
    76.         timeLabel.setFont(new Font("Dialog", 0, 30));
    77.         timeLabel.setForeground(Color.red);
    78.         timeLabel.setVisible(false);
    79.         this.myPanel.add(timeLabel);
    80.     }
    81.     public void showAllPlayersInfo(java.util.List players) {
    82.         // 1.显示三个玩家的名称
    83.         // 2.显示当前玩家的扑克列表
    84.         for (int i = 0; i < players.size(); i++) {
    85.             if (players.get(i).getName().equals(uname)) {
    86.                 currentPlayer = players.get(i);
    87.             }
    88.         }
    89.         java.util.List pokers = currentPlayer.getPokers();
    90.         for (int i = 0; i < pokers.size(); i++) {
    91.             // 创建扑克标签
    92.             Poker poker = pokers.get(i);
    93.             PokerLabel pokerLabel = new PokerLabel(poker.getId(),
    94.                     poker.getName(), poker.getNum());
    95.             pokerLabel.turnUp(); // 显示正面图
    96.             // 添加到面板中
    97.             this.myPanel.add(pokerLabel);
    98.             this.pokerLabels.add(pokerLabel);
    99.             // 动态的显示出来
    100.             this.myPanel.setComponentZOrder(pokerLabel, 0);
    101.             // 一张一张的显示出来
    102.             GameUtil.move(pokerLabel, 300 + 30 * i, 450);
    103.         }
    104.         // 对扑克列表排序
    105.         Collections.sort(pokerLabels);
    106.         // 重新移动位置
    107.         for (int i = 0; i < pokerLabels.size(); i++) {
    108.             this.myPanel.setComponentZOrder(pokerLabels.get(i), 0);
    109.             GameUtil.move(pokerLabels.get(i), 300 + 30 * i, 450);
    110.         }
    111.         if (currentPlayer.getId() == 0) {
    112.             getLord(); // 抢地主
    113.         }
    114.     }
    115.     //抢地主
    116.     public void getLord() {
    117.         // 显示抢地主的按钮 和 定时器按钮
    118.         lordLabel1 = new JLabel();
    119.         lordLabel1.setBounds(330, 400, 104, 46);
    120.         lordLabel1.setIcon(new ImageIcon("images/bg/jiaodizhu.png"));
    121.         lordLabel1.addMouseListener(new MyMouseEvent());
    122.         this.myPanel.add(lordLabel1);
    123.         lordLabel2 = new JLabel();
    124.         lordLabel2.setBounds(440, 400, 104, 46);
    125.         lordLabel2.setIcon(new ImageIcon("images/bg/bujiao.png"));
    126.         lordLabel2.addMouseListener(new MyMouseEvent());
    127.         this.myPanel.add(lordLabel2);
    128.         //显示定时器的图标
    129.         this.timeLabel.setVisible(true);
    130.         this.setVisible(true);
    131.         // 重绘
    132.         this.repaint();
    133.         // 启动计时器的线程
    134.         countThread = new CountThread(10, this);
    135.         countThread.start();
    136.     }
    137.     //显示出牌的标签
    138.     public void showChuPaiJabel() {
    139.         if (prevPlayerid == currentPlayer.getId()) {
    140.             //从窗口上移除之前的出牌的列表
    141.             for (int i = 0; i < showOutPokerLabels.size(); i++) {
    142.                 myPanel.remove(showOutPokerLabels.get(i));
    143.             }
    144.             //清空之前出牌的列表
    145.             showOutPokerLabels.clear();
    146.         }
    147.         // 显示出牌和不出牌的按钮 和 定时器按钮
    148.         chupaiJLabel.setVisible(true);
    149.         buchuJLabel.setVisible(true);
    150.         timeLabel.setVisible(true);
    151.         this.repaint();
    152.         chuPaiThread = new ChuPaiThread(30, this);
    153.         chuPaiThread.start();
    154.     }
    155.     // 显示消息(不抢 或 不出)
    156.     public void showMsg(int playerid, int typeid) {
    157.         msgLabel.setVisible(true);
    158.         msgLabel.setBounds(500, 300, 129, 77);
    159.         if (typeid == 1) {
    160.             msgLabel.setIcon(new ImageIcon("images/bg/buqiang.png"));
    161.         }
    162.         if (typeid == 3) {
    163.             msgLabel.setIcon(new ImageIcon("images/bg/buchu.png"));
    164.         }
    165.         if (playerid == currentPlayer.getId()) {
    166.             msgLabel.setLocation(400, 300);
    167.         } else if (playerid + 1 == currentPlayer.getId() ||
    168.                 playerid - 2 == currentPlayer.getId()) //上家  //  2 0    0 1   1 2
    169.         {
    170.             msgLabel.setLocation(300, 100);
    171.         } else { // 下家
    172.             msgLabel.setLocation(800, 100);
    173.         }
    174.         this.myPanel.add(msgLabel);
    175.         this.repaint();
    176.     }
    177.     // 添加地主牌
    178.     public void addLordPokers(java.util.List lordPokers) {
    179.         for (int i = 0; i < lordPokers.size(); i++) {
    180.             Poker poker = lordPokers.get(i);
    181.             PokerLabel pokerLabel = new PokerLabel(poker.getId(),
    182.                     poker.getName(), poker.getNum());
    183.             pokerLabel.turnUp(); // 显示正面图
    184.             this.pokerLabels.add(pokerLabel);
    185.         }
    186.         Collections.sort(pokerLabels);
    187.         for (int i = 0; i < pokerLabels.size(); i++) {
    188.             // 添加到面板中
    189.             this.myPanel.add(pokerLabels.get(i));
    190.             // 动态的显示出来
    191.             this.myPanel.setComponentZOrder(pokerLabels.get(i), 0);
    192.             // 一张一张的显示出来
    193.             GameUtil.move(pokerLabels.get(i), 300 + 30 * i, 450);
    194.  
    195.         }
    196.         currentPlayer.getPokers().addAll(lordPokers);
    197.     }
    198.     //显示地主图标
    199.     public void showLordIcon(int playerid) {
    200.         //创建地主图标对象
    201.         lordIconLabel = new JLabel();
    202.         lordIconLabel.setIcon(new ImageIcon("images/bg/dizhu.png"));
    203.         lordIconLabel.setSize(60, 89);
    204.         //根据玩家id显示到具体的位置
    205.         //如果自己是地主
    206.         if (playerid == currentPlayer.getId()) {
    207.             lordIconLabel.setLocation(200, 450);
    208.         } else if (playerid + 1 == currentPlayer.getId() ||
    209.                 playerid - 2 == currentPlayer.getId()) //上家  //  2 0    0 1   1 2
    210.         {
    211.             lordIconLabel.setLocation(200, 100);
    212.         } else { // 下家
    213.             lordIconLabel.setLocation(950, 100);
    214.         }
    215.         //添加地主图标到面板上
    216.         this.myPanel.add(lordIconLabel);
    217.         this.repaint();  //重绘
    218.     }
    219.     //给扑克牌添加单击事件
    220.     public void addClickEventToPoker() {
    221.         for (int i = 0; i < pokerLabels.size(); i++) {
    222.             pokerLabels.get(i).addMouseListener(new PokerEvent());
    223.         }
    224.     }
    225.     //显示出牌的列表
    226.     public void showOutPokerList(int playerid,
    227.                                  java.util.List outPokers) {
    228.         //从窗口上移除之前的出牌的列表
    229.         for (int i = 0; i < showOutPokerLabels.size(); i++) {
    230.             myPanel.remove(showOutPokerLabels.get(i));
    231.         }
    232.         //清空之前出牌的列表
    233.         showOutPokerLabels.clear();
    234.         //显示当前出牌的列表
    235.         for (int i = 0; i < outPokers.size(); i++) {
    236.             Poker poker = outPokers.get(i);
    237.             PokerLabel pokerLabel = new PokerLabel(poker.getId(),
    238.                     poker.getName(), poker.getNum());
    239.             if (playerid == currentPlayer.getId()) {
    240.                 pokerLabel.setLocation(400 + 30 * i, 300);
    241.             } else if (playerid + 1 == currentPlayer.getId() ||
    242.                     playerid - 2 == currentPlayer.getId()) {
    243.                 pokerLabel.setLocation(200 + 30 * i, 100);
    244.             } else {
    245.                 pokerLabel.setLocation(700 + 30 * i, 100);
    246.             }
    247.             pokerLabel.turnUp();
    248.             myPanel.add(pokerLabel);
    249.             showOutPokerLabels.add(pokerLabel);
    250.             myPanel.setComponentZOrder(pokerLabel, 0);
    251.         }
    252.         this.repaint(); //窗口重绘
    253.     }
    254.     //出牌  将出的牌从当前玩家的扑克列表中移除
    255.     public void removeOutPokerFromPokerList() {
    256.         //1.从当前玩家的扑克列表中移除
    257.         pokerLabels.removeAll(selectedPokerLabels);
    258.         //2.从面板中移除
    259.         for (int i = 0; i < selectedPokerLabels.size(); i++) {
    260.             myPanel.remove(selectedPokerLabels.get(i));
    261.         }
    262.         //3.剩下的扑克列表重新定位
    263.         for (int i = 0; i < pokerLabels.size(); i++) {
    264.             myPanel.setComponentZOrder(pokerLabels.get(i), 0);
    265.             GameUtil.move2(pokerLabels.get(i), 300 + 30 * i, 450);
    266.         }
    267.         //4.清空选择的扑克牌列表
    268.         selectedPokerLabels.clear();
    269.         this.repaint();
    270.     }
    271.     //游戏结束
    272.     public void gameOver() {
    273.         this.myPanel.removeAll();
    274.         this.repaint();
    275.         try {
    276.             this.socket.close();
    277.         } catch (IOException e) {
    278.             // TODO Auto-generated catch block
    279.             e.printStackTrace();
    280.         }
    281.         this.countThread.setRun(false);
    282.         this.chuPaiThread.setRun(false);
    283.         this.sendThread.setRun(false);
    284.         this.receiveThread.setRun(false);
    285.     }
    286.     // 创建鼠标事件监听器类
    287.     class MyMouseEvent extends MouseAdapter {
    288.         @Override
    289.         public void mouseClicked(MouseEvent event) {
    290.             // 点击的是抢地主
    291.             if (event.getSource().equals(lordLabel1)) {
    292.                 // 停止计时器
    293.                 countThread.setRun(false);
    294.                 isLord = true;
    295.                 // 设置抢地主的按钮不可见
    296.                 lordLabel1.setVisible(false);
    297.                 lordLabel2.setVisible(false);
    298.                 timeLabel.setVisible(false);
    299.             }
    300.             // 点击的不抢
    301.             if (event.getSource().equals(lordLabel2)) {
    302.                 // 停止计时器
    303.                 countThread.setRun(false);
    304.                 isLord = false;
    305.                 lordLabel1.setVisible(false);
    306.                 lordLabel2.setVisible(false);
    307.                 timeLabel.setVisible(false);
    308.             }
    309.             //点击出牌
    310.             if (event.getSource().equals(chupaiJLabel)) {
    311.                 PokerType pokerType = PokerRule.checkPokerType(selectedPokerLabels);
    312.                 //判断是否符合牌型
    313.                 if (!pokerType.equals(PokerType.p_error)) {
    314.                     System.out.println(prevPlayerid + "," + currentPlayer.getId());
    315.                     //符合牌型，判断是不是比上家大 或者上家就是自己
    316.                     if (prevPlayerid == -1 || prevPlayerid == currentPlayer.getId() ||
    317.                             PokerRule.legal(showOutPokerLabels, selectedPokerLabels)) {
    318.                         isOut = true;
    319.                         //计时器停止
    320.                         chuPaiThread.setRun(false);
    321.                         chupaiJLabel.setVisible(false);
    322.                         buchuJLabel.setVisible(false);
    323.                         timeLabel.setVisible(false);
    324.                     } else {
    325.                         JOptionPane.showMessageDialog(null, "请按规则出牌");
    326.                     }
    327.                 } else {
    328.                     JOptionPane.showMessageDialog(null, "不符合牌型");
    329.                 }
    330.             }
    331.             if (event.getSource().equals(buchuJLabel)) {
    332.                 isOut = false;
    333.                 //计时器停止
    334.                 chuPaiThread.setRun(false);
    335.                 chupaiJLabel.setVisible(false);
    336.                 buchuJLabel.setVisible(false);
    337.                 timeLabel.setVisible(false);
    338.             }
    339.         }
    340.     }
    341.     //创建扑克牌的事件监听器类
    342.     class PokerEvent extends MouseAdapter {
    343.         @Override
    344.         public void mouseClicked(MouseEvent arg0) {
    345.             // TODO Auto-generated method stub
    346.             PokerLabel pokerLabel = (PokerLabel) arg0.getSource();
    347.             //如果之前选择过了 则取消选择(设置选中属性为false 位置回到原位，从选择的扑克牌列表中移除)
    348.             if (pokerLabel.isSelected()) {
    349.                 pokerLabel.setSelected(false);
    350.                 pokerLabel.setLocation(pokerLabel.getX(), pokerLabel.getY() + 30);
    351.                 selectedPokerLabels.remove(pokerLabel);
    352.             }
    353.             //如果之前没有选择 则选中(设置选中属性为true 位置往上移动一点,添加到选择的扑克牌列表中)
    354.             else {
    355.                 pokerLabel.setSelected(true);
    356.                 pokerLabel.setLocation(pokerLabel.getX(), pokerLabel.getY() - 30);
    357.                 selectedPokerLabels.add(pokerLabel);
    358.             }
    359.         }
    360.     }
    361. }

    MyPanel.java

    1. package client.view;
    2. import java.awt.*;
    3. import javax.swing.*;
    4. public class MyPanel extends JPanel{
    5. 	public MyPanel()
    6. 	{
    7. 		this.setLayout(null);
    8. 	}
    9. 	@Override
    10. 	protected void paintComponent(Graphics g) {
    11. 		Image image=new ImageIcon("images/bg/bg1.png").getImage();
    12. 		g.drawImage(image, 0, 0, this.getWidth(), this.getHeight(), null);
    13. 	}
    14. }

    Main.java

    1. package client.view;
    2. public class Main {
    3. 	public static void main(String[] args) {
    4. 	    new LoginFrame();//打开第一个玩家的登录窗口
    5. 		new LoginFrame();//打开第二个玩家的登录窗口
    6. 		new LoginFrame();//打开第三个玩家的登录窗口
    7. 	}
    8. }

    MainServer.java

    1. package server;
    2. import java.io.*;
    3. import java.net.*;
    4. import java.util.*;
    5. import com.alibaba.fastjson.*;
    6. import client.model.*;
    7. public class MainServer {
    8.     //创建玩家列表
    9.     public List players = new ArrayList();
    10.     public int index = 0;
    11.     //存放扑克列表
    12.     public List allPokers = new ArrayList();
    13.     //存放底牌
    14.     public List lordPokers = new ArrayList();
    15.     public int step = 0;  //牌局的进展步骤
    16.     public MainServer() {
    17.         //创建扑克列表
    18.         createPokers();
    19.         try {
    20.         //1.创建服务器端socket
    21.             ServerSocket serverSocket = new ServerSocket(8888);
    22.             while (true) {
    23.                 //2.接收客户端的socket
    24.                 Socket socket = serverSocket.accept();
    25.                 //3.开启线程 处理客户端的socket
    26.                 AcceptThread acceptThread = new AcceptThread(socket);
    27.                 acceptThread.start();
    28.             }
    29.         } catch (IOException e) {
    30.             e.printStackTrace();
    31.             System.out.println("服务器端异常");
    32.         }
    33.     }
    34.     //创建一个接收线程  处理客户端的信息
    35.     class AcceptThread extends Thread {
    36.         Socket socket;
    37.         public AcceptThread(Socket socket) {
    38.             this.socket = socket;
    39.         }
    40.         public void run() {
    41.             try {
    42.                 DataInputStream dataInputStream =
    43.                         new DataInputStream(socket.getInputStream());
    44.                 while (true) {
    45.                     String msg = dataInputStream.readUTF();
    46.                     if (step == 0) {
    47.                         //创建player对象
    48.                         Player player = new Player(index++, msg);
    49.                         player.setSocket(socket);
    50.                         //存入玩家列表
    51.                         players.add(player);
    52.                         System.out.println(msg + "上线了");
    53.                         System.out.println("当前上线人数:" + players.size());
    54.                         //玩家人数到齐,发给三个玩家
    55.                         if (players.size() == 3) {
    56.                             deal();//发牌
    57.                             step = 1;
    58.                         }
    59.                     } else if (step == 1)  //接收抢地主的信息
    60.                     {
    61.                         System.out.println("接收抢地主的消息");
    62.                         JSONObject msgJsonObject = JSON.parseObject(msg);
    63.                         int typeid = msgJsonObject.getInteger("typeid");
    64.                         int playerid = msgJsonObject.getInteger("playerid");
    65.                         String content = msgJsonObject.getString("content");
    66.                         //抢地主
    67.                         if (typeid == 2) {
    68.                             //重新组将一个 消息对象 ，添加地主牌
    69.                             Message sendMessage =
    70.                                     new Message(typeid, playerid, content, lordPokers);
    71.                             msg = JSON.toJSONString(sendMessage);
    72.                             step = 2;
    73.                         }
    74.                         //不抢 将客户端发过来的不抢的信息 原样群发到所有玩家
    75.                         sendMessageToClient(msg);
    76.                     } else if (step == 2) //出牌和不出牌和游戏结束
    77.                     {
    78.                         sendMessageToClient(msg); //转发到所有的客户端
    79.                     }
    80.                 }
    81.             } catch (IOException e) {
    82.                 e.printStackTrace();
    83.                 System.out.println("服务器异常:" + e.getMessage());
    84.             }
    85.         }
    86.     }
    87.     //群发消息到客户端
    88.     public void sendMessageToClient(String msg) {
    89.         for (int i = 0; i < players.size(); i++) {
    90.             DataOutputStream dataOutputStream;
    91.             try {
    92.                 dataOutputStream = new DataOutputStream(
    93.                         players.get(i).getSocket().getOutputStream());
    94.                 dataOutputStream.writeUTF(msg);
    95.             } catch (IOException e) {
    96.                 e.printStackTrace();
    97.             }
    98.         }
    99.     }
    100.     //创建所有的扑克列表
    101.     public void createPokers() {
    102.         //创建大王 ，小王
    103.         Poker dawang = new Poker(0, "大王", 17);
    104.         Poker xiaowang = new Poker(1, "小王", 16);
    105.         allPokers.add(dawang);
    106.         allPokers.add(xiaowang);
    107.         //创建其它扑克
    108.         String[] names = new String[]
    109.                 {"2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3"};
    110.         String[] colors = new String[]
    111.                 {"黑桃", "红桃", "梅花", "双块"};
    112.         int id = 2;
    113.         int num = 15;
    114.         //遍历扑克的种类
    115.         for (String name : names) {
    116.             //遍历每个种类的花色
    117.             for (String color : colors) {
    118.                 Poker poker = new Poker(id++, color + name, num);
    119.                 allPokers.add(poker);
    120.             }
    121.             num--;
    122.         }
    123.         //洗牌
    124.         Collections.shuffle(allPokers);
    125.     }
    126.     //发牌
    127.     public void deal() {
    128.         //发给三个玩家
    129.         for (int i = 0; i < allPokers.size(); i++) {
    130.             //最后三张留给地主牌
    131.             if (i >= 51) {
    132.                 lordPokers.add(allPokers.get(i));
    133.             } else {
    134.                 //依次分发给三个玩家
    135.                 if (i % 3 == 0)
    136.                     players.get(0).getPokers().add(allPokers.get(i));
    137.                 else if (i % 3 == 1)
    138.                     players.get(1).getPokers().add(allPokers.get(i));
    139.                 else
    140.                     players.get(2).getPokers().add(allPokers.get(i));
    141.             }
    142.         }
    143.         //将玩家的信息发送到客户端
    144.         for (int i = 0; i < players.size(); i++) {
    145.             try {
    146.                 DataOutputStream dataOutputStream =
    147.                         new DataOutputStream(
    148.                                 players.get(i).getSocket().getOutputStream());
    149.                 String jsonString = JSON.toJSONString(players);
    150.                 System.out.println(jsonString);
    151.                 dataOutputStream.writeUTF(jsonString);
    152.             } catch (IOException e) {
    153.                 e.printStackTrace();
    154.             }
    155.         }
    156.     }
    157. }

    Main.java

    1. package server;
    2. public class Main {
    3.     public static void main(String[] args) {
    4.         new MainServer();
    5.     }
    6. }

    除阅读文章外，各位小伙伴还可以点击这里观看我在本站的视频课程学习Java！

  • 相关阅读:
    数据管理知识体系指南（第二版）-第十章——参考数据和主数据-学习笔记
    vite + vue3 的项目中使用 vitest 做单元测试（仅供参考）
    MySQL的EXPLAIN执行计划的属性解释
    经典矩阵试题（一）
    提高研发效率还得看Apipost
    项目中执行 npm run xxx 的时候发生了什么？
    极狐GitLab专家团队支招解决 CVE-2023-4998 漏洞问题
    vue3 组件响应式v-model 失效，实践踩坑，一文搞懂组件响应式原理，对初学者友好
    Auto.js中的一般全局函数
    技术人必读的「CDP选型指南」来了！
  • 原文地址：https://blog.csdn.net/shalimu/article/details/128182742