• 第二十三章《斗地主游戏》第2节：系统功能实现

    地主游戏的功能模块非常多，本小节将介绍各功能模块的实现思路及基本源代码。

    23.2.1游戏服务器的启动

    在server包下有一个Main类，这个类中包含main()方法，main()方法中包含启动游戏服务器的语句，游戏服务器的启动必须先于客户端的启动，否则游戏无法运行。Main类中main()方法的代码如下：

    new MainServer();

    可以看出：main()方法中仅是创建了一个MainServer类对象，而MainServer类对象会在其构造方法中启动一个ServerSocket，同时启动线程处理客户端与服务器的对话，实现这个过程的代码如下：

    1. //1.创建服务器端socket
    2. ServerSocket serverSocket=new ServerSocket(8888);
    3. while(true)
    4. {
    5.     //2.接收客户端的socket
    6.     Socket socket= serverSocket.accept();
    7.     //3.开启线程 处理客户端的socket
    8.     AcceptThread acceptThread=new AcceptThread(socket);
    9.     acceptThread.start();
    10. }

    23.2.2登录窗口和主界面窗口的启动

    当启动了服务器之后，就可以启动用户登录窗口。在client.view包下有一个Main类，它包含main()方法，当main()方法执行后就会创建出玩家登录窗口对象。由于斗地主游戏必须够3个玩家才能开始运行，因此在本案例中，main()方法直接开启3个登录窗口以保证游戏能立刻进入运行状态，但读者必须清楚：在真实的游戏中一次只能开启一个登录窗口。Main类的main()方法代码如下：

    1. new LoginFrame();//打开第一个玩家的登录窗口
    2. new LoginFrame();//打开第二个玩家的登录窗口
    3. new LoginFrame();//打开第三个玩家的登录窗口

    从以上代码可以看出：main()方法只是打开了登录窗口，登录窗口的界面如图23-1所示。当玩家在登录窗口中任意输入一个昵称并单击“登录”按钮后，就会进入斗地主游戏主界面窗口。

    之所以在单击“登录”按钮后会进入斗地主游戏主界面窗口，是因为“登录”按钮的监听器在监听到事件后会打开主界面窗口，并且用Socket与服务器建立连接。“登录”按钮监听器的事件响应程序如下：

    1. //点击登录
    2. //1.获得用户名
    3. String uname= txtUserName.getText();
    4. //2.创建一个socket链接服务器端
    5. try {
    6.     Socket socket=new Socket("127.0.0.1",8888);
    7.     //3.跳转到主窗口
    8.     new MainFrame(uname,socket);
    9.     dispose();//关闭当前窗口
    10. } catch (UnknownHostException e) {
    11.     e.printStackTrace();
    12. } catch (IOException e) {
    13.     e.printStackTrace();
    14. }

    23.2.3接收客户端上线消息

    每个玩家登录到斗地主游戏后，客户端要主动向服务器发送消息以通知服务器自己已经上线，这样服务器就能知道目前有哪些玩家上线，当有3个客户端连接到服务器后游戏参与者数量正好凑够，此时服务器将开启游戏。

    在23.2.2小节曾讲到：玩家在登录之后会创建出一个游戏主界面窗体，也就是MainFrame类的对象，而MainFrame对象则会在自己的构造方法中启动一个线程，并用这个线程向服务器端发送消息，启动线程的代码如下：

    1. // 启动发消息的线程
    2. sendThread = new SendThread(socket, uname);
    3. sendThread.start();

    线程启动后发送登录消息的代码如下：

    1. DataOutputStream dataOutputStream;
    2. try {
    3.     dataOutputStream = new DataOutputStream(socket.getOutputStream());
    4.     while(true)
    5.     {
    6.         if(isRun==false){
    7.             break;
    8.         }
    9.         //如果消息不为null
    10.         if(msg!=null){
    11.             System.out.println("消息在发送中:"+msg);
    12.             //发送消息
    13.             dataOutputStream.writeUTF(msg);
    14.             //消息发送完毕 消息内容清空
    15.             msg=null;
    16.         }
    17.         Thread.sleep(50);  //暂停 等待新消息进来
    18.     }
    19. } catch (IOException e) {
    20.     e.printStackTrace();
    21. } catch (InterruptedException e) {
    22.     e.printStackTrace();
    23. }

    服务器端也要相应的接收客户端发来的消息，接收消息的任务也是由一个线程负责完成的，线程接收消息后就知道有一个玩家已经上线，此时它要创建一个玩家对象并进行计数，接收消息及创建玩家对象的代码如下：

    1. Player player=new Player(index++,msg);
    2. player.setSocket(socket);
    3. //存入玩家列表
    4. players.add(player);
    5. System.out.println(msg+"上线了");
    6. System.out.println("当前上线人数:"+players.size());

    23.2.4发牌

    当有3个玩家上线后，系统会自动启动发牌程序，发牌是由服务器完成的，因此在表示服务器的MainServer类中专门定义了一个发牌方法deal()，该方法的实现过程如下：

    1. public void deal()
    2. {
    3.     //发给三个玩家
    4.     for(int i=0;i
    5.     {
    6.         //最后三张留给地主牌
    7.         if(i>=51)
    8.         {
    9.             lordPokers.add(allPokers.get(i));
    10.         }
    11.         else {
    12.             //依次分发给三个玩家
    13.             if(i%3==0)
    14.                 players.get(0).getPokers().add(allPokers.get(i));
    15.             else if(i%3==1)
    16.                 players.get(1).getPokers().add(allPokers.get(i));
    17.             else
    18.                 players.get(2).getPokers().add(allPokers.get(i));
    19.         }
    20.     }
    21.  
    22.     //将玩家的信息发送到客户端
    23.     for(int i=0;i
    24.     {
    25.         try {
    26.             DataOutputStream dataOutputStream= new DataOutputStream(players.get(i).getSocket().getOutputStream());
    27.             String jsonString=JSON.toJSONString(players);
    28.             System.out.println(jsonString);
    29.             dataOutputStream.writeUTF(jsonString);
    30.         } catch (IOException e) {
    31.             e.printStackTrace();
    32.         }
    33.     }
    34. }

    23.2.5解析消息

    服务器向客户端发牌的操作过程中，所有的扑克牌的组合都是以JSON字符串的形式表示的，而客户端接收到所发牌之后必须把这个JSON字符串解析为一个JSON数组，而这个JSON数组则表示收到的牌，紧接着要把JSON数组传递给玩家对象，玩家对象在接收到这一组牌后要把这些牌在放到一个ArrayList对象中，表示玩家已经拿到了所发的牌，这个过程的实现代码写在客户端接收消息的线程ReceiveThread中，其实现过程如下：

    1. String jsonString= dataInputStream.readUTF();
    2. java.util.List players=new ArrayList();
    3. //System.out.println(jsonString);
    4. //解析json字符串
    5. //将json字符串转换为json数组
    6. JSONArray playerJsonArray = JSONArray.parseArray(jsonString);
    7. for(int i=0;i
    8. {
    9.     //获得当个json对象--> 玩家对象
    10.     JSONObject playerJson=(JSONObject) playerJsonArray.get(i);
    11.     int id=playerJson.getInteger("id");
    12.     String name=playerJson.getString("name");
    13.     //存放扑克列表
    14.     java.util.List pokers=new ArrayList();
    15.     JSONArray pokerJsonArray= playerJson.getJSONArray("pokers");
    16.     for(int j=0;j
    17.     {
    18.         // 每循环一次 获得一个扑克对象
    19.         JSONObject pokerJSon= (JSONObject) pokerJsonArray.get(j);
    20.         int pid=pokerJSon.getInteger("id");
    21.         String pname=pokerJSon.getString("name");
    22.         int num=pokerJSon.getInteger("num");
    23.         Poker poker=new Poker(pid,pname,num);
    24.         pokers.add(poker);
    25.     }
    26.     Player player=new Player(id,name,pokers);
    27.     players.add(player);

    23.2.6显示接收到的牌

    玩家在收到所发的牌之后要把这些牌显示出来，这个操作是由定义在MainFrame类的showAllPlayersInfo()方法完成的，这个方法显示牌的核心操作是把表示牌的对象Poker与每张牌的图片对应起来并把这些牌的图片显示到窗体的上，showAllPlayersInfo()方法的实现过程如下：

    1. public void showAllPlayersInfo(java.util.List players) {
    2.     // 1.显示三个玩家的名称
    3.     // 2.显示当前玩家的扑克列表
    4.     for (int i = 0; i < players.size(); i++) {
    5.         if (players.get(i).getName().equals(uname)) {
    6.             currentPlayer = players.get(i);
    7.         }
    8.     }
    9.  
    10.     java.util.List pokers = currentPlayer.getPokers();
    11.     for (int i = 0; i < pokers.size(); i++) {
    12.         // 创建扑克标签
    13.         Poker poker = pokers.get(i);
    14.         PokerLabel pokerLabel = new PokerLabel(poker.getId(),poker.getName(), poker.getNum());
    15.         pokerLabel.turnUp(); // 显示正面图
    16.         // 添加到面板中
    17.         this.myPanel.add(pokerLabel);
    18.         this.pokerLabels.add(pokerLabel);
    19.         // 动态的显示出来
    20.         this.myPanel.setComponentZOrder(pokerLabel, 0);
    21.         // 一张一张的显示出来
    22.         GameUtil.move(pokerLabel, 300 + 30 * i, 450);
    23.     }
    24.     // 对扑克列表排序
    25.     Collections.sort(pokerLabels);
    26.     // 重新移动位置
    27.     for (int i = 0; i < pokerLabels.size(); i++) {
    28.         this.myPanel.setComponentZOrder(pokerLabels.get(i), 0);
    29.         GameUtil.move(pokerLabels.get(i), 300 + 30 * i, 450);
    30.     }
    31.     if (currentPlayer.getId() == 0) {
    32.         getLord(); // 抢地主
    33.     }
    34. }

    23.2.7按大小排列牌

    玩家在接收到发的牌时，这些牌都是随机排列的，为了方便玩家出牌，必须把这些牌按大小排列一遍。排列牌是调用Collections类的sort()方法完成的，为sort()方法所传递的参数是PokerLabel对象，根据第11章所学的知识可知，如果一个类的对象如果能够被排序，这个类必须实现Comparable接口并实现其compareTo()方法，以下是PokerLabel实现compareTo()方法的过程。

    1. public int compareTo(Object arg0) {
    2.     PokerLabel pokerLabel=(PokerLabel)arg0;
    3.     if(this.num>pokerLabel.num)
    4.         return 1;
    5.     else if(this.num
    6.         return -1;
    7.     else
    8.         return 0;
    9. }

    从以上代码可以看出：两张牌进行比较时，所比较的依据就是PokerLabel对象的num属性，而这个num属性就代表了牌面的点数。

    23.2.8抢地主

    各玩家拿到牌后，根据牌的好坏可以选择是否抢地主。抢地主操作是由MainFrame类所定义的getLord()方法完成，其最核心代码是显示倒计时并箭头玩家的鼠标操作并根据玩家鼠标所单击是“抢地主”还是“不抢”。getLord()方法的实现过程如下：

    1. public void getLord() {
    2.     // 显示抢地主的按钮 和 定时器按钮
    3.     lordLabel1 = new JLabel();
    4.     lordLabel1.setBounds(330, 400, 104, 46);
    5.     lordLabel1.setIcon(new ImageIcon("images/bg/jiaodizhu.png"));
    6.     lordLabel1.addMouseListener(new MyMouseEvent());//①
    7.     this.myPanel.add(lordLabel1);
    8.     lordLabel2 = new JLabel();
    9.     lordLabel2.setBounds(440, 400, 104, 46);
    10.     lordLabel2.setIcon(new ImageIcon("images/bg/bujiao.png"));
    11.     lordLabel2.addMouseListener(new MyMouseEvent());//②
    12.     this.myPanel.add(lordLabel2);
    13.     //显示定时器的图标
    14.     this.timeLabel.setVisible(true);
    15.     this.setVisible(true);
    16.     // 重绘
    17.     this.repaint();
    18.     // 启动计时器的线程
    19.     countThread = new CountThread(10, this);
    20.     countThread.start();
    21. }

    在以上代码中，lordLabel1表示“抢地主”的标签，而lordLabel2则表示“不抢”，这两个标签在被单击时也要做出响应，因此需要给这两个标签添加监听器。在MainFrame类中定义了一个鼠标事件监听器，它负责监听所有的鼠标单击操作，因此程序需要在进行处理时判断玩家单击的是哪一个标签，其中负责处理玩家单击“抢地主”标签的代码如下：

    1. if (event.getSource().equals(lordLabel1)) {
    2.     // 停止计时器
    3.     countThread.setRun(false);
    4.     isLord = true;
    5.     // 设置抢地主的按钮不可见
    6.     lordLabel1.setVisible(false);
    7.     lordLabel2.setVisible(false);
    8.     timeLabel.setVisible(false);
    9. }

    而处理“不抢”标签被单击的代码如下：

    1. // 点击的不抢
    2. if (event.getSource().equals(lordLabel2)) {
    3.     // 停止计时器
    4.     countThread.setRun(false);
    5.     isLord = false;
    6.     lordLabel1.setVisible(false);
    7.     lordLabel2.setVisible(false);
    8.     timeLabel.setVisible(false);
    9. }

    23.2.9显示出牌和不出牌标签并开始倒计时

    抢地主步骤结束后，需要开始出牌，因此游戏主界面上必须显示出“出牌”和“不出牌”标签以及倒计时标签。显示这些标签的操作由MainFrame类的showChuPaiJabel()方法完成，其实现过程如下：

    1. //显示出牌的标签
    2. public void showChuPaiJabel()
    3. {
    4.     if(prevPlayerid==currentPlayer.getId())
    5.     {
    6.         //从窗口上移除之前的出牌的列表
    7.         for(int i=0;i
    8.         {
    9.             myPanel.remove(showOutPokerLabels.get(i));
    10.         }
    11.         //清空之前出牌的列表
    12.         showOutPokerLabels.clear();
    13.     }
    14.     // 显示出牌和不出牌的按钮 和 定时器按钮
    15.     chupaiJLabel.setVisible(true);
    16.     buchuJLabel.setVisible(true);
    17.     timeLabel.setVisible(true);
    18.     this.repaint();
    19.     chuPaiThread=new ChuPaiThread(30, this);//①倒计时
    20.     chuPaiThread.start();
    21. }

    从showChuPaiJabel()方法的语句①可以看出：出来要把各种标签显示出来外，还要开始倒计时操作，这个操作是由chuPaiThread线程完成的，其倒计时代码如下：

    1. while(time>=0 && isRun){
    2.     mainFrame.timeLabel.setText(time+"");
    3.     time--;
    4.     try {
    5.         Thread.sleep(1000);
    6.     } catch (InterruptedException e) {
    7.         e.printStackTrace();
    8.     }
    9. }

    23.2.10分发出牌消息

    任意一个玩家完成出牌操作后，他所出的牌必须被自己以及另外两个玩家看到，因此必须向服务器发送出牌消息，并由服务器在把这些消息分发给其他两位玩家。出牌消息是由SendThread线程完成的，实际上整个游戏中所有消息都是由这个线程完成的。SendThread线程发送消息的代码写在它的run()方法中，其实现过程如下：

    1. public void run() {
    2.     DataOutputStream dataOutputStream;
    3.     try {
    4.         dataOutputStream = new DataOutputStream(socket.getOutputStream());
    5.         while (true) {
    6.             if (isRun == false) {
    7.                 break;
    8.             }
    9.             //如果消息不为null
    10.             if (msg != null) {
    11.                 System.out.println("消息在发送中:" + msg);
    12.                 //发送消息
    13.                 dataOutputStream.writeUTF(msg);
    14.                 //消息发送完毕 消息内容清空
    15.                 msg = null;
    16.             }
    17.             Thread.sleep(50);  //暂停 等待新消息进来
    18.         }
    19.     } catch (IOException e) {
    20.         e.printStackTrace();
    21.     } catch (InterruptedException e) {
    22.         e.printStackTrace();
    23.     }
    24. }

    从这段代码可以看出：SendThread线程中有一个无限循环，这个循环一直在不断等待这发送消息的任务，一旦要发送的消息不为空则立刻发送消息，因此如果想让这个线程发送消息，只需要调用SendThread类的setMsg()方法把消息传递给SendThread即可，而ChuPaiThread线程的run()方法执行以下代码完成出牌操作以及把消息传递给SendThread：

    1. message=new Message(4,mainFrame.currentPlayer.getId(),"出牌",
    2. changePokerLableToPoker(mainFrame.selectedPokerLabels));
    3. //转换为json 交给 sendThread发送到服务器去
    4. String msg=JSON.toJSONString(message);
    5. mainFrame.sendThread.setMsg(msg);
    6. //将当前发送出去的扑克牌 从扑克牌列表中移除
    7. mainFrame.removeOutPokerFromPokerList();
    8. //如果扑克列表的数量为0 代表赢了
    9. if(mainFrame.pokerLabels.size()==0)
    10. {
    11.     message=new Message(5, mainFrame.currentPlayer.getId(), "游戏结束", null);
    12.     msg=JSON.toJSONString(message);
    13.     try {
    14.         Thread.sleep(100);
    15.         mainFrame.sendThread.setMsg(msg);
    16.     } catch (InterruptedException e) {
    17.         e.printStackTrace();
    18.     }
    19. }

    23.2.11判断牌型和出牌是否符合规则

    如果轮到当前玩家出牌，那么玩家不能随意出，必须符合某种牌型。在斗地主游戏中，所有牌型都已经被定义到PokerType枚举中，而判断牌型的操作由PokerRule类所定义的checkPokerType()方法完成，其源代码如下：

    1. //判断牌型
    2. public static PokerType checkPokerType(List list){
    3.     Collections.sort(list);
    4.     int count=list.size();
    5.     if(count==1){
    6.         //单张
    7.         return PokerType.p_1;
    8.     }else if(count==2){
    9.         //对子
    10.         if(isSame(list, count)){
    11.             return PokerType.p_2;
    12.         }
    13.         //王炸
    14.         if(isWangZha(list)){
    15.             return PokerType.p_2w;
    16.         }
    17.         return PokerType.p_error;
    18.     }else if(count==3){
    19.         //三个头
    20.         if(isSame(list, count)){
    21.             return PokerType.p_3;
    22.         }
    23.         return PokerType.p_error;
    24.     }else if(count==4){
    25.         //炸弹
    26.         if(isSame(list, count)){
    27.             return PokerType.p_4;
    28.         }
    29.         //三带一
    30.         if(isSanDaiYi(list)){
    31.             return PokerType.p_31;
    32.         }
    33.         return PokerType.p_error;
    34.     }else if(count>=5){
    35.         //顺子
    36.         if(isShunZi(list)){
    37.             return PokerType.p_n;
    38.         }else if(isSanDaiYiDui(list)){
    39.             //三代一对
    40.             return PokerType.p_32;
    41.         }else if(isLianDui(list)){
    42.             //连对
    43.             return PokerType.p_1122;
    44.         }else if(isFeiJI(list)){
    45.             //双飞or双飞双带
    46.             return PokerType.p_111222;
    47.         }else if(isFeiJIDaiChiBang1(list)){
    48.             //双飞or双飞双带
    49.             return PokerType.p_11122234;
    50.         }
    51.  
    52.         else if(isFeiJIDaiChiBang2(list)){
    53.             //双飞or双飞双带
    54.             return PokerType.p_1112223344;
    55.         }
    56.     }
    57.     return PokerType.p_error;
    58. }

    玩家所出的牌型如果正确，还必须看是否符合出牌规则，如果下家的牌不大于上家则认为不符合出牌规则，这个判断操作由PokerRule类的legal()静态方法完成，其实现过程如下：

    1. //判断是否符合出牌规则，即根据上家牌面判断本次出牌是否合规
    2. public static boolean legal(List prevList, List currentList){
    3.     // 首先判断牌型是不是一样
    4.     PokerType paiXing = checkPokerType(prevList);
    5.     if (paiXing.equals(checkPokerType(currentList))) {
    6.         // 根据牌型来判断大小
    7.         if (PokerType.p_1.equals(paiXing)) {
    8.             // 单张
    9.             if (compareLast(prevList, currentList)) {
    10.                 return true;
    11.             }
    12.             return false;
    13.         } else if (PokerType.p_2w.equals(paiXing)) {
    14.             // 王炸
    15.             return false;
    16.         } else if (PokerType.p_2.equals(paiXing)) {
    17.             // 对子
    18.             if (compareLast(prevList, currentList)) {
    19.                 return true;
    20.             }
    21.             return false;
    22.         } else if (PokerType.p_3.equals(paiXing)) {
    23.             // 三张
    24.             if (compareLast(prevList, currentList)) {
    25.                 return true;
    26.             }
    27.             return false;
    28.         } else if (PokerType.p_31.equals(paiXing)) {
    29.             // 三带一
    30.             if (compareLast(prevList, currentList)) {
    31.                 return true;
    32.             }
    33.             return false;
    34.         } else if (PokerType.p_32.equals(paiXing)) {
    35.             // 三带一对
    36.             if (compare(prevList, currentList)) {
    37.                 return true;
    38.             }
    39.             return false;
    40.         } else if (PokerType.p_4.equals(paiXing)) {
    41.             // 炸弹
    42.             if (compareLast(prevList, currentList)) {
    43.                 return true;
    44.             }
    45.             return false;
    46.         } else if (PokerType.p_n.equals(paiXing)) {
    47.             // 顺子
    48.             if (compareLast(prevList, currentList)) {
    49.                 return true;
    50.             }
    51.             return false;
    52.         } else if (PokerType.p_1122.equals(paiXing)) {
    53.             // 连对
    54.             if (compareLast(prevList, currentList)) {
    55.                 return true;
    56.             }
    57.             return false;
    58.         } else if (PokerType.p_111222.equals(paiXing)) {
    59.             // 双飞
    60.             if (compare(prevList, currentList)) {
    61.                 return true;
    62.             }
    63.             return false;
    64.         }
    65.         else if (PokerType.p_11122234.equals(paiXing)) {
    66.             // 飞机带翅膀（单张）
    67.             if (compare(prevList, currentList)) {
    68.                 return true;
    69.             }
    70.             return false;
    71.         }
    72.         else if (PokerType.p_1112223344.equals(paiXing)) {
    73.             // 飞机带翅膀（对子）
    74.             if (compare(prevList, currentList)) {
    75.                 return true;
    76.             }
    77.             return false;
    78.         }
    79.     }else if(currentList.size()==2){
    80.         //判断是不是王炸
    81.         if(isWangZha(currentList)){
    82.             return true;
    83.         }
    84.         return false;
    85.     } else if(currentList.size()==4){
    86.         //判断是不是炸弹
    87.         if(isSame(currentList, 4)){
    88.             return true;
    89.         }
    90.         return false;
    91.     }
    92.     return false;
    93. }

    23.2.12判断玩家输赢

    判断玩家输赢其实很简单，只要某个玩家手中的牌数量等于0就认定该玩家已经赢了，如果已经赢了，则还要向服务器发送游戏结束的消息。完成判断操和发送消息的操作由ChuPaiThread类的run()方法完成，由之前的介绍可知：ChuPaiThread类的run()方法会完成很多操作，其中判断玩家是否已经赢得牌局以及发送消息的代码如下：

    1. if(mainFrame.pokerLabels.size()==0)
    2. {
    3.     //产生游戏结束的消息
    4.     message=new Message(5, mainFrame.currentPlayer.getId(), "游戏结束", null);
    5.     msg=JSON.toJSONString(message);
    6.     try {
    7.         Thread.sleep(100);
    8.         //发送消息
    9.         mainFrame.sendThread.setMsg(msg);
    10.     } catch (InterruptedException e) {
    11.         e.printStackTrace();
    12.     }
    13. }

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

  • 相关阅读:
    计算机毕业设计java+ssm医院医疗救助系统的设计与实现
    体验一下 Claude 3.5 Sonnet
    H3C GRE over ipsec配置
    C到C++入门基础知识
    HTML网页设计——轮滑运动体育类人物介绍主题12页面毕业设计网页
    VectorDraw Developer Framework 10.1004 Crack
    MySQL常用函数整理，建议收藏！
    ElasticSearch ( 三 ) 基本操作
    java学习--day22（进程&线程）
    试试这2个流动图片制作方法让你的图片动起来吧
  • 原文地址：https://blog.csdn.net/shalimu/article/details/128181670