Java斗地主游戲開發(fā)

游戲中用到的技術(shù)：遞歸这难，排序
游戲中用到的對象：

撲克牌
游戲玩家

游戲中的操作：

洗牌
發(fā)牌
搶地主
出牌

游戲規(guī)則：

規(guī)則類

定義一副撲克牌數(shù)組對象

定義大小為54的字符串?dāng)?shù)組表示一副撲克牌
更直觀的展示給游戲玩家

    /**
    * 一副撲克牌汇荐，54張亮元，初始化
     *字符串?dāng)?shù)組纲岭，
    */
    private String[] pukepai = new String[] {
    "紅桃A", "方塊A", "梅花A", "黑桃A",
    "紅桃2", "方塊2", "梅花2", "黑桃2",
    "紅桃3", "方塊3", "梅花3", "黑桃3",
    "紅桃4", "方塊4", "梅花4", "黑桃4",
    "紅桃5", "方塊5", "梅花5", "黑桃5",
    "紅桃6", "方塊6", "梅花6", "黑桃6",
    "紅桃7", "方塊7", "梅花7", "黑桃7",
    "紅桃8", "方塊8", "梅花8", "黑桃8",
    "紅桃9", "方塊9", "梅花9", "黑桃9",
    "紅桃10", "方塊10", "梅花10", "黑桃10",
    "紅桃J", "方塊J", "梅花J", "黑桃J",
    "紅桃Q", "方塊Q", "梅花Q", "黑Q",
    "紅桃K", "方塊K", "梅花K", "黑桃K",
    "大鬼", "小鬼" };

定義大小為54的整型數(shù)組表示一副撲克牌
用戶進(jìn)行撲克牌的大小比較

    /**
    *定義一個整型數(shù)組對象
    *字符串表示的撲克牌窃蹋，比較大小相對困難
    *定義一個整型數(shù)組對象表示撲克牌來替代字符串表示的撲克牌
    *進(jìn)行撲克牌的大小比較
    */
    int[] pukepaiInts = new int[] {
    11, 12, 13, 14,//"紅桃A", "方塊A", "梅花A", "黑桃A",
    21, 22, 23, 24,//"紅桃2", "方塊2", "梅花2", "黑桃2",
    31, 32, 33, 34,//"紅桃3", "方塊3", "梅花3", "黑桃3",
    41, 42, 43, 44,//"紅桃4", "方塊4", "梅花4", "黑桃4",
    51, 52, 53, 54,//"紅桃5", "方塊5", "梅花5", "黑桃5",
    61, 62, 63, 64,//"紅桃6", "方塊6", "梅花6", "黑桃6",
    71, 72, 73, 74,//"紅桃7", "方塊7", "梅花7", "黑桃7",
    81, 82, 83, 84,//"紅桃8", "方塊8", "梅花8", "黑桃8",
    91, 92, 93, 94,//"紅桃9", "方塊9", "梅花9", "黑桃9",
    101, 102, 103, 104,//"紅桃10", "方塊10", "梅花10", "黑桃10",
    111,112,113,114,//"紅桃J", "方塊J", "梅花J", "黑桃J",
    121, 122, 123, 124,//"紅桃Q", "方塊Q", "梅花Q", "黑桃Q",
    131, 132, 133, 134,//"紅桃K", "方塊K", "梅花K", "黑桃K",
    0, 1//"大鬼", "小鬼"
    };

定義游戲玩家類

游戲玩家：ID、名稱压恒、在游戲中的身份探赫、在游戲中的狀態(tài)型宙、手里的牌、要出的牌伦吠、在牌桌上的位置

public class Gamers {
    /**
     * 玩家唯一ID
     */
    public int id;
    /**
     * 玩家名稱
     */
    public String name;
    /**
     * 玩家身份
     * 
     * "農(nóng)民" / "地主"
     */
    public String status;
    /**
     * 玩家手里的牌
     */
    public List<String> pais;

    public int[] paiInts;
    /**
     * 玩家在游戲中的位置
     * 
     * "1" / "2" / "3"
     */
    public String position;
    /**
     * 玩家要出的牌
     */
    public int[] chuPai;
    /**
     * 玩家在游行中的狀態(tài)
     * 
     * "出牌" / "等待" / "勝利" / "失敗"
     */
    public String operationStatus;

}

實現(xiàn)洗牌函數(shù)

 /**
 * 洗牌
 * 
 * @param pukepai
 *            初始化的撲克牌對象
 * @return 返回洗好后的撲克牌對象
 */
private String[] xipai(String[] pukepai) {
    //定義一副空的撲克牌
    String[] xipaiEnd = new String[54];
    // 把初始化的撲克牌元素插入到新的空的撲克牌中
    for (int i = 1; i < pukepai.length; i++) {
        int index = zeroToFifty_four(xipaiEnd);
        xipaiEnd[index] = pukepai[i];
        System.out.println("第 " + i + " 張牌 " + pukepai[i] + " 位置下標(biāo)："
                + index);
    }
    return xipaiEnd;
}

尋找元素為空的下標(biāo)妆兑，用到遞歸算法

/**
 * 尋找元素為空的下標(biāo)
 * 
 * @param pukepai
 * @return 元素為空的下標(biāo)
 */
private int zeroToFifty_four(String[] pukepai) {
    // 0 <= Math.random < 1
    //隨機(jī)獲取下標(biāo)，范圍0~53
    int index = (int) (Math.random() * 54);
    if (pukepai[index] != null) {
        // System.out.println("下標(biāo) " + index + " 元素不為空");
        // 繼續(xù)尋找元素為空的下標(biāo)
        return zeroToFifty_four(pukepai);
    } else {
        return temp;
    }
}

實現(xiàn)發(fā)牌函數(shù)

/**
 * 給三位玩家發(fā)牌的函數(shù)
 * 
 * @param pukepai
 *            傳入洗完后的撲克牌對象
 * @param wanjiaA
 * @param wanjiaB
 * @paramwanjiaC
 * @return 返回三位玩家對象列表
 */
private List<Wanjia> fapai(String[] pukepai, Wanjia wanjiaA,
        Wanjia wanjiaB, Wanjia wanjiaC) {
    List<Wanjia> wanjias = new ArrayList<Xipai.Wanjia>();
    // 預(yù)留最后三張底牌
    for (int i = 0; i < pukepai.length - 3; i++) {
        if (i % 3 == 0) {// 第一個
            wanjiaA.pais.add(pukepai[i]);
        } else if (i % 3 == 1) {// 第二個
            wanjiaB.pais.add(pukepai[i]);
        } else if (i % 3 == 2) {// 第三個
            wanjiaC.pais.add(pukepai[i]);
        }
    }
    wanjias.add(wanjiaA);
    wanjias.add(wanjiaB);
    wanjias.add(wanjiaC);
    return wanjias;
}

測試洗牌發(fā)牌函數(shù)

public static void main(String[] arg) {
    Xipai localXipai = new Xipai();
    // 洗完之后的撲克牌
    String[] xipaiEnd = localXipai.xipai(localXipai.pukepai);
    // 初始化三個玩家對象
    Wanjia wanjiaA = localXipai.new Wanjia();
    wanjiaA.name = "路人甲";
    wanjiaA.status = "農(nóng)民";
    wanjiaA.position = "左";
    wanjiaA.pais = new ArrayList<String>();
    Wanjia wanjiaB = localXipai.new Wanjia();
    wanjiaB.name = "路人乙";
    wanjiaB.status = "農(nóng)民";
    wanjiaB.position = "右";
    wanjiaB.pais = new ArrayList<String>();
    Wanjia wanjiaC = localXipai.new Wanjia();
    wanjiaC.name = "官二代C";
    wanjiaC.status = "地主";
    wanjiaC.position = "下";
    wanjiaC.pais = new ArrayList<String>();
    // 給三個玩家發(fā)牌
    List<Wanjia> listWanjias = localXipai.fapai(xipaiEnd, wanjiaA, wanjiaB,
            wanjiaC);
    // 分別打印玩家手里的牌
    for (Wanjia wanjia : listWanjias) {
        System.out.println(wanjia.name + "手里的牌：" + wanjia.pais.toString()
                + "\n");
    }
    System.out.println("底牌：" + xipaiEnd[53] + " " + xipaiEnd[52] + " "
            + xipaiEnd[51]);
}

測試結(jié)果圖

測試發(fā)牌效果

游戲玩家搶地主

把底牌發(fā)給搶到地主的玩家

System.out.println("開始搶地主" + "\n");
System.out.println("玩家 --- " + wanjiaB.name + " --- 搶到地主" + "\n");
wanjiaB.status = "地主";
wanjiaB.pais.add(xipaiEnd[53]);
wanjiaB.pais.add(xipaiEnd[52]);
wanjiaB.pais.add(xipaiEnd[51]);
//其他玩家為農(nóng)民
wanjiaA.status = "農(nóng)民";
wanjiaC.status = "農(nóng)民";
//分別打印玩家手里的牌
for (Wanjia wanjia : listWanjias) {
    System.out.println("玩家=== " + wanjia.name + " ( " + wanjia.status
            + " ) ===手里的牌" + "\n");
    System.out.println(wanjia.pais.toString() + "\n");
}

搶地主結(jié)束
各玩家手里的牌

地主與農(nóng)民手里的牌

對玩家手里的牌進(jìn)行排序

發(fā)給玩家的牌是無序的毛仪，對玩家手里的牌由小到大排序搁嗓，這里用到整型數(shù)組

System.out.println("由小到大排序手里的牌" + "\n");
System.out.println("開始對玩家 " + wanjiaA.name + " 手中的牌排序" + "\n");
// 玩家A，玩家手里的牌轉(zhuǎn)換成對應(yīng)的整型數(shù)組
wanjiaA.paiInts = localXipai.transitionToInts(wanjiaA.pais);
System.out.println("排序中... 玩家 " + wanjiaA.name + " 手中的牌排序 "
                + wanjiaA.paiInts[0] + "\n");
wanjiaA.pais.clear();
//排序完成箱靴，再把整型數(shù)組轉(zhuǎn)換成字符串?dāng)?shù)組
wanjiaA.pais.addAll(localXipai.transitionToList(wanjiaA.paiInts));
System.out.println("玩家 " + wanjiaA.name + " 手中的牌排序結(jié)束" + "\n");

// 玩家B
wanjiaB.paiInts = localXipai.transitionToInts(wanjiaB.pais);
wanjiaB.pais.clear();
wanjiaB.pais.addAll(localXipai.transitionToList(wanjiaB.paiInts));


// 玩家C
wanjiaC.paiInts = localXipai.transitionToInts(wanjiaC.pais);
wanjiaC.pais.clear();
wanjiaC.pais.addAll(localXipai.transitionToList(wanjiaC.paiInts));

System.out.println("排序結(jié)果:" + "\n");

for (Wanjia wanjia : listWanjias) {
    System.out.println("玩家=== " + wanjia.name + " ( " + wanjia.status
            + " ) ===手里的牌" + "\n");
    System.out.println(wanjia.pais.toString() + "\n");
}

撲克牌排序結(jié)束

玩家手里的牌排序結(jié)果

字符串列表表示的撲克牌轉(zhuǎn)化為整型數(shù)組表示的撲克牌函數(shù)

    /**
     *字符串列表表示的撲克牌轉(zhuǎn)化為整型數(shù)組表示的撲克牌
     * 
     * 然后再由小到大排序
     * 
     * @param str
     * @return 返回由小到大排序的數(shù)組
     */
    private int[] transitionToInts(List<String> str) {
        int[] ints = new int[str.size()];
        for (int i = 0; i < str.size(); i++) {
            String pai = str.get(i);
            if (pai.compareTo("紅桃A") == 0) {
                ints[i] = 11;
            } else if (pai.compareTo("紅桃2") == 0) {
                ints[i] = 21;
            } else if (pai.compareTo("紅桃3") == 0) {
                ints[i] = 31;
            } else if (pai.compareTo("紅桃4") == 0) {
                ints[i] = 41;
            } else if (pai.compareTo("紅桃5") == 0) {
                ints[i] = 51;
            } else if (pai.compareTo("紅桃6") == 0) {
                ints[i] = 61;
            } else if (pai.compareTo("紅桃7") == 0) {
                ints[i] = 71;
            } else if (pai.compareTo("紅桃8") == 0) {
                ints[i] = 81;
            } else if (pai.compareTo("紅桃9") == 0) {
                ints[i] = 91;
            } else if (pai.compareTo("紅桃10") == 0) {
                ints[i] = 101;
            } else if (pai.compareTo("紅桃J") == 0) {
                ints[i] = 111;
            } else if (pai.compareTo("紅桃Q") == 0) {
                ints[i] = 121;
            } else if (pai.compareTo("紅桃K") == 0) {
                ints[i] = 131;
            } else if (pai.compareTo("方塊A") == 0) {
                ints[i] = 12;
            } else if (pai.compareTo("方塊2") == 0) {
                ints[i] = 22;
            } else if (pai.compareTo("方塊3") == 0) {
                ints[i] = 32;
            } else if (pai.compareTo("方塊4") == 0) {
                ints[i] = 42;
            } else if (pai.compareTo("方塊5") == 0) {
                ints[i] = 52;
            } else if (pai.compareTo("方塊6") == 0) {
                ints[i] = 62;
            } else if (pai.compareTo("方塊7") == 0) {
                ints[i] = 72;
            } else if (pai.compareTo("方塊8") == 0) {
                ints[i] = 82;
            } else if (pai.compareTo("方塊9") == 0) {
                ints[i] = 92;
            } else if (pai.compareTo("方塊10") == 0) {
                ints[i] = 102;
            } else if (pai.compareTo("方塊J") == 0) {
                ints[i] = 112;
            } else if (pai.compareTo("方塊Q") == 0) {
                ints[i] = 122;
            } else if (pai.compareTo("方塊K") == 0) {
                ints[i] = 132;
            } else if (pai.compareTo("梅花A") == 0) {
                ints[i] = 13;
            } else if (pai.compareTo("梅花2") == 0) {
                ints[i] = 23;
            } else if (pai.compareTo("梅花3") == 0) {
                ints[i] = 33;
            } else if (pai.compareTo("梅花4") == 0) {
                ints[i] = 43;
            } else if (pai.compareTo("梅花5") == 0) {
                ints[i] = 53;
            } else if (pai.compareTo("梅花6") == 0) {
                ints[i] = 63;
            } else if (pai.compareTo("梅花7") == 0) {
                ints[i] = 73;
            } else if (pai.compareTo("梅花8") == 0) {
                ints[i] = 83;
            } else if (pai.compareTo("梅花9") == 0) {
                ints[i] = 93;
            } else if (pai.compareTo("梅花10") == 0) {
                ints[i] = 103;
            } else if (pai.compareTo("梅花J") == 0) {
                ints[i] = 113;
            } else if (pai.compareTo("梅花Q") == 0) {
                ints[i] = 123;
            } else if (pai.compareTo("梅花K") == 0) {
                ints[i] = 133;
            } else if (pai.compareTo("黑桃A") == 0) {
                ints[i] = 14;
            } else if (pai.compareTo("黑桃2") == 0) {
                ints[i] = 24;
            } else if (pai.compareTo("黑桃3") == 0) {
                ints[i] = 34;
            } else if (pai.compareTo("黑桃4") == 0) {
                ints[i] = 44;
            } else if (pai.compareTo("黑桃5") == 0) {
                ints[i] = 54;
            } else if (pai.compareTo("黑桃6") == 0) {
                ints[i] = 64;
            } else if (pai.compareTo("黑桃7") == 0) {
                ints[i] = 74;
            } else if (pai.compareTo("黑桃8") == 0) {
                ints[i] = 84;
            } else if (pai.compareTo("黑桃9") == 0) {
                ints[i] = 94;
            } else if (pai.compareTo("黑桃10") == 0) {
                ints[i] = 104;
            } else if (pai.compareTo("黑桃J") == 0) {
                ints[i] = 114;
            } else if (pai.compareTo("黑桃Q") == 0) {
                ints[i] = 124;
            } else if (pai.compareTo("黑桃K") == 0) {
                ints[i] = 134;
            } else if (pai.compareTo("大鬼") == 0) {
                ints[i] = 1;
            } else if (pai.compareTo("小鬼") == 0) {
                ints[i] = 0;
            }
        }
        return sortBubblingFromMinToMax(ints);
    }

整型數(shù)組由小到大排序函數(shù)腺逛，用到冒泡排序

/**
 * 冒泡排序， 由小到大
 * 
 * @param paramInts
 * @return
 */
public int[] sortBubblingFromMinToMax(int[] paramInts) {
    return sortBubblingFromMinToMax(paramInts, 0, paramInts.length - 1);
}
/**
 * 遞歸方式實現(xiàn)冒泡排序
 * @param paramInts 原始數(shù)組
 * @param index 數(shù)組下標(biāo)
 * @param moreIndex 該下標(biāo)是數(shù)組中剩余元素中的最大值
 * @return
 */
public int[] sortBubblingFromMinToMax(int[] paramInts, int index,
    int moreIndex) {
        if (moreIndex == 0) {
        return paramInts;
    } else if (index == moreIndex) {
        return sortBubblingFromMinToMax(paramInts, 0, moreIndex - 1);
    } else if (paramInts[index + 1] < paramInts[index]) {// 后一元素小于于前一元素
        // 交換數(shù)值
        int temp = paramInts[index];
        paramInts[index] = paramInts[index + 1];
        paramInts[index + 1] = temp;
        // 比較一下對元素
        return sortBubblingFromMinToMax(paramInts, index + 1, moreIndex);
    } else {// 后一元素不于前一元素
        // 比較下一對元素
        return sortBubblingFromMinToMax(paramInts, index + 1, moreIndex);

    }
}

整型數(shù)組表示的撲克牌轉(zhuǎn)化為字符串列表表示的撲克牌函數(shù)

    /**
     * 整型數(shù)組表示的撲克牌轉(zhuǎn)化為字符串?dāng)?shù)組表示的撲克牌
     * 
     * 展示需要
     * 
     * @param paramInts
     * @return
     */
    public static List<String> transitionToList(int[] paramInts) {
        List<String> listStr = new ArrayList<String>();
        for (int value : paramInts) {
            switch (value) {
            case 0:
                listStr.add("小鬼");
                break;
            case 1:
                listStr.add("大鬼");
                break;
            case 11:
                listStr.add("紅桃A");
                break;
            case 12:
                listStr.add("方塊A");
                break;
            case 13:
                listStr.add("梅花A");
                break;
            case 14:
                listStr.add("黑桃A");
                break;
            case 21:
                listStr.add("紅桃2");
                break;
            case 22:
                listStr.add("方塊2");
                break;
            case 23:
                listStr.add("梅花2");
                break;
            case 24:
                listStr.add("黑桃2");
                break;
            case 31:
                listStr.add("紅桃3");
                break;
            case 32:
                listStr.add("方塊3");
                break;
            case 33:
                listStr.add("梅花3");
                break;
            case 34:
                listStr.add("黑桃3");
                break;
            case 41:
                listStr.add("紅桃4");
                break;
            case 42:
                listStr.add("方塊4");
                break;
            case 43:
                listStr.add("梅花4");
                break;
            case 44:
                listStr.add("黑桃4");
                break;
            case 51:
                listStr.add("紅桃5");
                break;
            case 52:
                listStr.add("方塊5");
                break;
            case 53:
                listStr.add("梅花5");
                break;
            case 54:
                listStr.add("黑桃5");
                break;
            case 61:
                listStr.add("紅桃6");
                break;
            case 62:
                listStr.add("方塊6");
                break;
            case 63:
                listStr.add("梅花6");
                break;
            case 64:
                listStr.add("黑桃6");
                break;
            case 71:
                listStr.add("紅桃7");
                break;
            case 72:
                listStr.add("方塊7");
                break;
            case 73:
                listStr.add("梅花7");
                break;
            case 74:
                listStr.add("黑桃7");
                break;
            case 81:
                listStr.add("紅桃8");
                break;
            case 82:
                listStr.add("方塊8");
                break;
            case 83:
                listStr.add("梅花8");
                break;
            case 84:
                listStr.add("黑桃8");
                break;
            case 91:
                listStr.add("紅桃9");
                break;
            case 92:
                listStr.add("方塊9");
                break;
            case 93:
                listStr.add("梅花9");
                break;
            case 94:
                listStr.add("黑桃9");
                break;
            case 101:
                listStr.add("紅桃10");
                break;
            case 102:
                listStr.add("方塊10");
                break;
            case 103:
                listStr.add("梅花10");
                break;
            case 104:
                listStr.add("黑桃10");
                break;
            case 111:
                listStr.add("紅桃J");
                break;
            case 112:
                listStr.add("方塊J");
                break;
            case 113:
                listStr.add("梅花J");
                break;
            case 114:
                listStr.add("黑桃J");
                break;
            case 121:
                listStr.add("紅桃Q");
                break;
            case 122:
                listStr.add("方塊Q");
                break;
            case 123:
                listStr.add("梅花Q");
                break;
            case 124:
                listStr.add("黑桃Q");
                break;
            case 131:
                listStr.add("紅桃K");
                break;
            case 132:
                listStr.add("方塊K");
                break;
            case 133:
                listStr.add("梅花K");
                break;
            case 134:
                listStr.add("黑桃K");
                break;
            default:
                listStr.add("程序錯誤");
                break;
            }
        }
        return listStr;
    }

游戲規(guī)則

規(guī)則類刨晴，符合如下兩個原則：
1.玩家出的牌拍是否符合出牌的規(guī)則
2.玩家出的牌是否壓過其他玩家出的牌

1.玩家出的牌是否符合出牌的規(guī)則
玩家出一張牌：隨意一漲牌
玩家出二張牌：兩張相同的牌--"一對"
玩家出三張牌：三張相同的牌--"三不帶"
玩家出四張牌：
1.三張相同的牌帶其他的牌--"三帶一"
2.四張相同的牌--"炸"
3.兩鬼帶隨意兩張牌

玩家出五張牌："順子"--
1."A" "10" "J" "Q" "K"
2.不能有鬼跟"2",五張連著的牌

玩家出六張牌：
1."順子"
2."三連對"
3."飛機(jī)"
4."四帶二"

玩家出七張牌：
1."順子"

玩家出八張牌：
1."順子"
2."四連對"
3."飛機(jī)帶二"

玩家出九張牌：
1."順子"

玩家出十張牌：
1."順子"
2."五連對"

玩家出十一張牌：
1."順子"

玩家出十二張牌：
1."順子"
2."六連對"

玩家出十三張牌：
1.違反游戲規(guī)則

玩家出十四張牌：
1."七連對"

玩家出十五張牌：
1.不符合游戲規(guī)則

玩家出十六張牌：
1."八連對"

玩家出十七張牌：
1.不符合游戲規(guī)則

玩家出十八張牌：
1."九連對"

玩家出十九張牌：
1.不符合游戲規(guī)則

玩家出二十張牌：
1."十連對"

2.玩家出的牌是否壓過其他玩家出的牌
需要有一個牌桌存放玩家出的牌屉来，定義一個牌桌

/**
* 牌桌路翻，存放玩家每次出的牌
 */
private List<int[]> paiZHuo = new ArrayList<int[]>();

方便計算，對玩家出的牌進(jìn)行又小到大排序

// 對玩家出的牌由小到大排序茄靠，這里調(diào)用之前實現(xiàn)的冒泡排序函數(shù)進(jìn)行排序
handPai = sortBubblingFromMinToMax(handPai);

玩家出一張牌

if (paiZHuo.isEmpty()) {// 牌桌上沒有牌
    System.out.println("一張 " + handPaiStr);
    flag = true;
} else if (lastHandPais.length == 1) {// 牌桌上一張牌
    int lastHandPai = lastHandPais[0];
    flag = GameRuleUtil.commpareTwoPai(handPai[0], lastHandPai);
    if (flag == true) {
        System.out.println("一張 " + handPaiStr + " 壓住 一張 "
                    + lastHandPaisStr);
    } else {
        System.out.println("一張 " + handPaiStr + " 壓不住 一張 "
                    + lastHandPaisStr);
    }
} else {// 牌桌上大于一張牌
    System.out.println("一張 " + handPaiStr + " 壓不住 "
        + lastHandPaisStr);
    flag = false;
}

判斷兩張牌的大小的函數(shù)

/**
 * 判斷兩張牌的大小
 * 
 * @param onePai
 *            玩家出的牌
 * @param otherPai
 *            牌桌上的牌
 * @return true:玩家出的牌壓住牌桌上的牌 false:牌桌上的牌壓不住牌桌上的牌
 */
public static boolean commpareTwoPai(int onePai, int otherPai) {
    boolean flag = false;
    if (otherPai / 10 > 2) {// 是3 ~ 13的牌
        if (onePai / 10 > otherPai || onePai / 10 <= 2) {
            flag = true;
        } else {
            flag = false;
        }
    } else if (otherPai == 0 && onePai == 1) {// "大鬼"壓"小鬼"
        flag = true;
    } else if (otherPai / 10 == 1 && (onePai / 10 == 0 || onePai / 10 == 2)) {// 大小鬼及2壓A
        flag = true;
    } else if (otherPai / 10 == 2 && onePai / 10 == 0) {// 大小鬼壓2
        flag = true;
    } else {
        flag = false;
    }
    return flag;
}

玩家出兩張牌
先判斷兩張牌是否符合出牌規(guī)則
再判斷是否壓過牌桌上其他玩家出的牌

判斷牌中有幾張相同牌的函數(shù)
這個函數(shù)也可以判斷牌中有兩張相同的牌及有三張相同的牌及四張相同的牌


/**
 * 判斷有序數(shù)組中存在相同元素個數(shù)為x個
 * 
 * 第一個元素與第二個元素對比
 * 
 * 元素相等茂契，統(tǒng)計相等元素的變量加1
 * 
 * 元素不相等，統(tǒng)計相等元素的變量歸0慨绳，重新統(tǒng)計相等元素個數(shù)
 * 
 * 第二個元素與第三個元素對比
 * 
 * @param paramInts
 *            有序數(shù)組(由大到小掉冶，或者由小到大)
 * @param index
 * @param num
 * @return
 */
private boolean isXEqual(int[] paramInts, int index, int num, int x) {
    if (num == x) {// 有x個相同元素
        return true;
    } else if (index == paramInts.length - 1) {// 對比到最后一個元素，沒有可比較的
        // 說明沒有四個相同的元素
        return false;
    } else if (paramInts[index] / 10 == paramInts[index + 1] / 10) {// 相鄰元素相等
        // 計算相等元素個數(shù)變量num加1脐雪，繼續(xù)對比之后的相鄰元素
        // ++num先計算賦值給num然后再用
        return isXEqual(paramInts, index + 1, ++num, x);
    } else {
        // 相鄰元素不相等厌小，計算相等元素個數(shù)變量設(shè)置為0，繼續(xù)對比之后的相鄰元素
        return isXEqual(paramInts, index + 1, 1, x);
    }
}

再判斷兩張牌是否壓過牌桌上其他玩家出的牌

if (isXEqual(handPai, 0, 1, 2)) {// 一對,例如：AA
    if (paiZHuo.isEmpty()) {// 牌桌上沒有牌
        System.out.println("一對 " + handPaiStr);
        flag = true;
    } else if (handPai[0] / 10 == 0 && handPai[1] / 10 == 0) {// 玩家出的"大小鬼"
        System.out.println("倆鬼 壓住 " + lastHandPaisStr);
        flag = true;
    } else if (lastHandPais.length == 2) {// 牌桌上兩張牌
        int lastHandPai = lastHandPais[0];
    //判斷隊的大小战秋，其實判斷兩張牌的大小一樣璧亚，調(diào)用判斷兩張牌大小的函數(shù)比較
        flag = GameRuleUtil.commpareTwoPai(handPai[0], lastHandPai);
        if (flag == true) {
            System.out.println("\"一對\"  " + handPaiStr + " 壓住 "
                        + lastHandPaisStr);
        } else {
            System.out.println("\"一對\" " + handPaiStr
                + " 壓不住 \"一對\"" + lastHandPaisStr);
        }
    } else {// 牌桌上不是兩張牌
        System.out.println("\"一對\"  " + handPaiStr + " 壓不住 "
                    + lastHandPaisStr);
        flag = false;
    }
} else {// 玩家出的兩張牌:不符合規(guī)則
    System.out.println("兩張牌不是一對，不符合游戲規(guī)則");
    flag = false;
}

玩家出三張牌

if (isXEqual(handPai, 0, 1, 3)) {// 例如：AAA
    if (paiZHuo.isEmpty()) {// 牌桌上沒有牌
        System.out.println("\"三不帶\"  " + handPaiStr);
                    flag = true;
    } else if (lastHandPais.length == 3) {// 牌桌上是三張牌
        int lastHandPai = lastHandPais[0];
 //判斷"三不帶"的大小脂信，其實判斷兩張牌的大小一樣癣蟋，調(diào)用判斷兩張牌大小的函數(shù)比較
        flag = GameRuleUtil.commpareTwoPai(handPai[0], lastHandPai);
        if (flag == true) {
            System.out.println("\"三不帶\"  " + handPaiStr
                    + " 壓住 \"三不帶\"" + lastHandPaisStr);
        } else {
            System.out.println("\"三不帶\"  " + handPaiStr
                    + " 壓不住 \"三不帶\"" + lastHandPaisStr);
        }
    } else {// 牌桌上不是三張牌
        System.out.println("\"三不帶\"  " + handPaiStr + " 壓不住 "
                + lastHandPaisStr);
        flag = false;
    }
} else {// 玩家出的三張牌:不符合規(guī)則
    System.out.println("三張牌 " + handPaiStr + " 不是\"三不帶\"，不符合游戲規(guī)則");
        flag = false;
}

玩家出四張牌

            if (isXEqual(handPai, 0, 1, 4)) {// 四張牌:"一炸"
                if (paiZHuo.isEmpty()) {// 牌桌為空
                    System.out.println("\"一炸\" " + handPaiStr);
                    flag = true;

                } else if (lastHandPais.length == 2
                        && lastHandPais[0] / 10 == 0
                        && lastHandPais[1] / 10 == 0) {// 桌牌上是"倆鬼"
                    System.out.println("\"一炸\"  " + handPaiStr + " 壓不住 \"兩鬼\" "
                            + lastHandPaisStr);
                } else if (!isXEqual(lastHandPais, 0, 1, 4)) {// 牌桌上不是"一炸"
                    System.out.println("\"一炸\" " + handPaiStr + " 壓住 "
                            + lastHandPaisStr);
                    flag = true;
                } else if (GameRuleUtil.commpareTwoPai(handPai[0],
                        lastHandPais[0])) {// 玩家的炸大于牌桌上的"一炸"
                    System.out.println("\"一炸\" " + handPaiStr + " 壓住 \"一炸\" "
                            + lastHandPaisStr);
                    flag = true;
                } else {
                    System.out.println("\"一炸\" " + handPaiStr + " 壓不住 \"一炸\" "
                            + lastHandPaisStr);
                    flag = false;
                }

            } else if (isXEqual(handPai, 0, 1, 3)) {// 四張牌："三帶一"
                if (paiZHuo.isEmpty()) {// 牌桌為空
                    System.out.println("\"三帶一\"" + handPaiStr);
                    flag = true;

                } else if (!isXEqual(lastHandPais, 0, 1, 3)) {// 牌桌上不是"三帶一"
                    System.out.println("\"三帶一\"  " + handPaiStr + " 壓不住 "
                            + lastHandPaisStr);
                    flag = false;
                } else if (GameRuleUtil.commpareTwoPai(
                        GameRuleUtil.getEqualInt(handPai),
                        GameRuleUtil.getEqualInt(lastHandPais))) {// 玩家出的"三帶一"壓住牌桌上的"三帶一"
                    System.out.println("\"三帶一\"  " + handPaiStr
                            + " 壓住 \"三帶一\" " + lastHandPaisStr);
                    flag = true;
                } else {
                    System.out.println("\"三帶一\"  " + handPaiStr
                            + " 壓不住 \"三帶一\" " + lastHandPaisStr);
                    flag = false;
                }
            } else if (handPai[0] == 0 && handPai[1] == 1) {// 四張牌:兩鬼帶兩張
                if (paiZHuo.isEmpty()) {
                    System.out.println("\"兩鬼帶二\" " + handPaiStr);
                    flag = true;
                } else {
                    System.out.println("\"兩鬼帶二\" " + handPaiStr         if (isXEqual(handPai, 0, 1, 4)) {// 四張牌:"一炸"
                if (paiZHuo.isEmpty()) {// 牌桌為空
                    System.out.println("\"一炸\" " + handPaiStr);
                    flag = true;

                } else if (lastHandPais.length == 2
                        && lastHandPais[0] / 10 == 0
                        && lastHandPais[1] / 10 == 0) {// 桌牌上是"倆鬼"
                    System.out.println("\"一炸\"  " + handPaiStr + " 壓不住 \"兩鬼\" "
                            + lastHandPaisStr);
                } else if (!isXEqual(lastHandPais, 0, 1, 4)) {// 牌桌上不是"一炸"
                    System.out.println("\"一炸\" " + handPaiStr + " 壓住 "
                            + lastHandPaisStr);
                    flag = true;
                } else if (GameRuleUtil.commpareTwoPai(handPai[0],
                        lastHandPais[0])) {// 玩家的炸大于牌桌上的"一炸"
                    System.out.println("\"一炸\" " + handPaiStr + " 壓住 \"一炸\" "
                            + lastHandPaisStr);
                    flag = true;
                } else {
                    System.out.println("\"一炸\" " + handPaiStr + " 壓不住 \"一炸\" "
                            + lastHandPaisStr);
                    flag = false;
                }

            } else if (isXEqual(handPai, 0, 1, 3)) {// 四張牌："三帶一"
                if (paiZHuo.isEmpty()) {// 牌桌為空
                    System.out.println("\"三帶一\"" + handPaiStr);
                    flag = true;

                } else if (!isXEqual(lastHandPais, 0, 1, 3)) {// 牌桌上不是"三帶一"
                    System.out.println("\"三帶一\"  " + handPaiStr + " 壓不住 "
                            + lastHandPaisStr);
                    flag = false;
                } else if (GameRuleUtil.commpareTwoPai(
                        GameRuleUtil.getEqualInt(handPai),
                        GameRuleUtil.getEqualInt(lastHandPais))) {// 玩家出的"三帶一"壓住牌桌上的"三帶一"
                    System.out.println("\"三帶一\"  " + handPaiStr
                            + " 壓住 \"三帶一\" " + lastHandPaisStr);
                    flag = true;
                } else {
                    System.out.println("\"三帶一\"  " + handPaiStr
                            + " 壓不住 \"三帶一\" " + lastHandPaisStr);
                    flag = false;
                }
            } else if (handPai[0] == 0 && handPai[1] == 1) {// 四張牌:兩鬼帶兩張
                if (paiZHuo.isEmpty()) {
                    System.out.println("\"兩鬼帶二\" " + handPaiStr);
                    flag = true;
                } else {
                    System.out.println("\"兩鬼帶二\" " + handPaiStr + " 壓不住 "
                            + lastHandPaisStr);
                    flag = false;
                }
            } else {// 玩家出的四張牌:不符合規(guī)則
                System.out.println("四張牌 " + handPaiStr
                        + " 不是\"三帶一\" or \"一炸\" or  \" 兩鬼帶二\"狰闪，不符合游戲規(guī)則");
                flag = false;
            } + " 壓不住 "
                            + lastHandPaisStr);
                    flag = false;
                }
            } else {// 玩家出的四張牌:不符合規(guī)則
                System.out.println("四張牌 " + handPaiStr
                        + " 不是\"三帶一\" or \"一炸\" or  \" 兩鬼帶二\"疯搅，不符合游戲規(guī)則");
                flag = false;
            }

玩家出五張牌

// 五張牌按照規(guī)則，只能是順子
if (isShunZi(handPai)) {// 五張牌：順子
    if (paiZHuo.isEmpty()) {//
        System.out.println("\"順子\" " + handPaiStr);
        flag = true;
    } else if (isShunZi(lastHandPais)) {// 牌桌上的不是順子
        System.out.println("\"順子\" " + handPaiStr + " 壓不住 "
                + lastHandPaisStr);
        flag = false;
    } else if (GameRuleUtil
                .commpareTwoShunZi(handPai, lastHandPais)) {// 判斷玩家出的順子是否壓過牌桌上的順子
        System.out.println("\"順子\" " + handPaiStr + " 壓住 "
                + "\"順子\" " + lastHandPaisStr);
        flag = true;
    } else {
        System.out.println("\"順子\" " + handPaiStr + " 壓不住 "
                + "\"順子\" " + lastHandPaisStr);
        flag = false;
    }
} else {// 五張牌：不符合規(guī)則
    System.out.println("五張牌 " + handPaiStr + " 不是\"順子\"埋泵，不符合游戲規(guī)則");
    flag = false;
}

玩家出六張牌

// 玩家出6張牌
            if (isShunZi(handPai)) {// 六張牌：順子
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"順子\" " + handPaiStr);
                    flag = true;
                } else if (isShunZi(lastHandPais)) {// 牌桌上的不是順子
                    System.out.println("\"順子\" " + handPaiStr + " 壓不住 "
                            + lastHandPaisStr);
                    flag = false;
                } else if (GameRuleUtil
                        .commpareTwoShunZi(handPai, lastHandPais)) {// 玩家出的順子壓過牌桌上的順子
                    System.out.println("\"順子\" " + handPaiStr + " 壓住 "
                            + "\"順子\" " + lastHandPaisStr);
                    flag = true;
                } else {
                    System.out.println("\"順子\" " + handPaiStr + " 壓不住 "
                            + "\"順子\" " + lastHandPaisStr);
                    flag = false;
                }
            } else if (isFeiji(handPai)) {// 六張牌：飛機(jī)
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"飛機(jī)\" " + handPaiStr);
                    flag = true;
                } else if (isFeiji(lastHandPais)) {// 牌桌上的不是飛機(jī)
                    System.out.println("\"飛機(jī)\" " + handPaiStr + " 壓不住 "
                            + lastHandPaisStr);
                    flag = false;
                } else if (GameRuleUtil.commpareTwoFeiJi(handPai, lastHandPais)) {// 玩家出的飛機(jī)壓過牌桌上的飛機(jī)
                    System.out.println("\"飛機(jī)\" " + handPaiStr + " 壓住 \"飛機(jī)\""
                            + lastHandPaisStr);
                    flag = true;
                } else {
                    System.out.println("\"飛機(jī)\" " + handPaiStr + " 壓不住 \"飛機(jī)\""
                            + lastHandPaisStr);
                    flag = false;
                }
            } else if (isLiandui(handPai)) {// 六張牌：三連對
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"三連對\" " + handPaiStr);
                    flag = true;
                } else if (isLiandui(lastHandPais)) {// 牌桌上的不是連對
                    System.out.println("\"三連對\" " + handPaiStr + " 壓不住 "
                            + handPaiStr);
                    flag = false;
                } else if (GameRuleUtil.commpareTwoLianDui(handPai,
                        lastHandPais)) {// 玩家出的連對壓過牌桌上的連對
                    System.out.println("\"三連對\" " + handPaiStr
                            + " 壓住  \"三連對\" " + handPaiStr);
                    flag = true;
                } else {
                    System.out.println("\"三連對\" " + handPaiStr
                            + " 壓不住  \"三連對\" " + handPaiStr);
                    flag = false;
                }
            } else if (isXEqual(handPai, 0, 1, 4)) {// 六張牌：四帶二
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"四帶二\" " + handPaiStr);
                    flag = true;
                } else if (!isXEqual(lastHandPais, 0, 1, 4)) {// 牌桌上不是四帶二
                    System.out.println("\"四帶二\" " + handPaiStr + " 壓不住 "
                            + lastHandPaisStr);
                    flag = false;

                } else if (GameRuleUtil.commpareFourPaisBandTwoPai(handPai,
                        lastHandPais)) {// 玩家出的四帶二壓過桌牌上的四帶二
                    System.out.println("\"四帶二\" " + handPaiStr + " 壓住 \"四帶二\" "
                            + lastHandPaisStr);
                    flag = true;
                } else {
                    System.out.println("\"四帶二\" " + handPaiStr
                            + " 壓不住 \"四帶二\" " + lastHandPaisStr);
                    flag = false;
                }
            } else {// 玩家出的六張牌：不符合規(guī)則
                System.out.println("六張牌 " + handPaiStr
                        + " 不是\"順子\" or \"四帶二\" or \"三連對\" or \"飛機(jī)\"幔欧，不符合游戲規(guī)則");
                flag = false;
            }

玩家出七張牌

if (isShunZi(handPai)) {// 七張牌：順子
    if (paiZHuo.isEmpty()) {//
        System.out.println("\"順子\" " + handPaiStr);
        flag = true;
    } else if (isShunZi(lastHandPais)) {// 牌桌上的不是順子
        System.out.println("\"順子\" " + handPaiStr + " 壓住 "
                + lastHandPaisStr);
        flag = false;
    } else if (GameRuleUtil
                .commpareTwoShunZi(handPai, lastHandPais)) {// 判斷玩家出的順子是否壓過牌桌上的順子
        System.out.println("\"順子\" " + handPaiStr + " 壓住 \"順子\" "
                    + lastHandPaisStr);
        flag = true;
    } else {
        System.out.println("\"順子\" " + handPaiStr + " 壓不住 \"順子\" "
                + lastHandPaisStr);
        flag = false;
    }
} else {// 七張牌：不符合規(guī)則
    System.out.println("七張牌 " + handPaiStr + " 不是\"順子\"，不符合游戲規(guī)則");
    flag = false;
}

        case 8:// 玩家出8張牌
            if (isShunZi(handPai)) {// 八張牌:順子
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"順子\" " + handPaiStr);
                    flag = true;
                } else if (isShunZi(lastHandPais)) {// 牌桌上的不是順子
                    System.out.println("\"順子\" " + handPaiStr + " 壓不住  "
                            + lastHandPaisStr);
                    flag = false;
                } else if (GameRuleUtil
                        .commpareTwoShunZi(handPai, lastHandPais)) {// 玩家出的順子是否壓過牌桌上的順子
                    System.out.println("\"順子\" " + handPaiStr + " 壓住 \"順子\" "
                            + lastHandPaisStr);
                    flag = true;
                } else {
                    System.out.println("\"順子\" " + handPaiStr + " 壓不住 \"順子\" "
                            + lastHandPaisStr);
                    flag = false;
                }
            } else if (isFeijiBandTwo(handPai)) {// 八張牌：飛機(jī)帶兩張
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"飛機(jī)帶二\" " + handPaiStr);
                    flag = true;
                } else if (!isFeijiBandTwo(lastHandPais)) {// 牌桌上不是飛機(jī)帶兩張
                    System.out.println("\"飛機(jī)帶二\" " + handPaiStr + " 壓不住  "
                            + lastHandPaisStr);
                    flag = false;
                } else if (GameRuleUtil.commpareFeiJiBandTwoPai(handPai,
                        lastHandPais)) {// 玩家出的飛機(jī)帶兩張壓過牌桌上的飛機(jī)帶兩張
                    System.out.println("\"飛機(jī)帶二\" " + handPaiStr
                            + " 壓住  \"飛機(jī)帶二\" " + lastHandPaisStr);
                    flag = true;
                } else {
                    System.out.println("\"飛機(jī)帶二\" " + handPaiStr
                            + " 壓不住  \"飛機(jī)帶二\" " + lastHandPaisStr);
                    flag = false;
                }
            } else if (isLiandui(handPai)) {// 八張牌：四連對
                if (paiZHuo.isEmpty()) {
                    System.out.println("\"四連對\" " + handPaiStr);
                    flag = true;
                } else if (isLiandui(lastHandPais)) {// 牌桌上的不是連對
                    System.out.println("\"四連對\" " + handPaiStr + " 壓不住  "
                            + lastHandPaisStr);
                    flag = false;
                } else if (GameRuleUtil.commpareTwoLianDui(handPai,
                        lastHandPais)) {// 玩家出的連對壓過牌桌上的連對
                    System.out.println("\"四連對\" " + handPaiStr
                            + " 壓住  \"四連對\" " + lastHandPaisStr);
                    flag = true;
                } else {
                    System.out.println("\"四連對\" " + handPaiStr
                            + " 壓不住  \"四連對\" " + lastHandPaisStr);
                    flag = false;
                }
            } else {// 玩家出的八張牌：不符合規(guī)則
                System.out.println("八張牌 " + handPaiStr
                        + " 不是\"順子\" or \"四連對\" or \"飛機(jī)帶二\" or \"\"丽声，不符合游戲規(guī)則");
                flag = false;
            }
            break;
        case 9:// 玩家出9張牌
            if (isShunZi(handPai)) {// 九張牌：順子
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"順子\" " + handPaiStr);
                    flag = true;
                } else if (isShunZi(lastHandPais)) {// 牌桌上的不是順子
                    System.out.println("\"順子\" " + handPaiStr + " 壓不住 "
                            + lastHandPaisStr);
                    flag = false;
                } else if (GameRuleUtil
                        .commpareTwoShunZi(handPai, lastHandPais)) {// 判斷玩家出的順子是否壓過牌桌上的順子
                    System.out.println("\"順子\" " + handPaiStr + " 壓住 \"順子\" "
                            + lastHandPaisStr);
                    flag = true;
                } else {
                    System.out.println("\"順子\" " + handPaiStr + " 壓不住 \"順子\" "
                            + lastHandPaisStr);
                    flag = false;
                }
            } else {// 玩家出的九張牌：不符合規(guī)則
                System.out.println("九張牌 " + handPaiStr + " 不是\"順子\"礁蔗，不符合游戲規(guī)則");
                flag = false;
            }
            break;
        case 10:// 玩家出10張牌
            if (isShunZi(handPai)) {// 十張牌：順子
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"順子\" " + handPaiStr);
                    flag = true;
                } else if (isShunZi(lastHandPais)) {// 牌桌上的不是順子
                    System.out.println("\"順子\" " + handPaiStr + " 壓不住 "
                            + lastHandPaisStr);
                    flag = false;
                } else if (GameRuleUtil
                        .commpareTwoShunZi(handPai, lastHandPais)) {// 判斷玩家出的順子是否壓過牌桌上的順子
                    flag = true;
                    System.out.println("\"順子\" " + handPaiStr + " 壓住 \"順子\" "
                            + lastHandPaisStr);
                } else {
                    System.out.println("\"順子\" " + handPaiStr + " 壓不住 \"順子\" "
                            + lastHandPaisStr);
                    flag = false;
                }
            } else if (isLiandui(handPai)) {// 十張牌： 五連對
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"五連對\" " + handPaiStr);
                    flag = true;
                } else if (isLiandui(lastHandPais)) {// 牌桌上的不是連對
                    System.out.println("\"五連對\" " + handPaiStr + " 壓不住 "
                            + handPaiStr);
                    flag = false;
                } else if (GameRuleUtil.commpareTwoLianDui(handPai,
                        lastHandPais)) {// 玩家出的連對壓過牌桌上的連對
                    System.out.println("\"五連對\" " + handPaiStr
                            + " 壓住 \"五連對\"  " + handPaiStr);
                    flag = true;
                } else {
                    System.out.println("\"五連對\" " + handPaiStr
                            + " 壓不住 \"五連對\"  " + handPaiStr);
                    flag = false;
                }
            } else {// 玩家出的十張牌：不符合規(guī)則
                System.out.println("十張牌 " + handPaiStr
                        + " 不是\"順子\" or  \"五連對\" ，不符合游戲規(guī)則");
                flag = false;
            }
            break;
        case 11:// 玩家出11張牌
            if (isShunZi(handPai)) {// 十一張牌：順子
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"順子\" " + handPaiStr);
                    flag = true;
                } else if (isShunZi(lastHandPais)) {// 牌桌上的不是順子
                    System.out.println("\"順子\" " + handPaiStr + " 壓住 "
                            + lastHandPaisStr);
                    flag = false;
                } else if (GameRuleUtil
                        .commpareTwoShunZi(handPai, lastHandPais)) {// 判斷玩家出的順子是否壓過牌桌上的順子
                    System.out.println("\"順子\" " + handPaiStr + " 壓住 \"順子\" "
                            + lastHandPaisStr);
                    flag = true;
                } else {
                    flag = false;
                    System.out.println("\"順子\" " + handPaiStr + " 壓不住 \"順子\" "
                            + lastHandPaisStr);
                }
            } else {// 玩家出的十一張牌：不符合規(guī)則
                System.out.println("十一張牌 " + handPaiStr + " 不是\"順子\"恒序，不符合游戲規(guī)則");
                flag = false;
            }
            break;
        case 12:// 玩家出12張牌
            if (isShunZi(handPai)) {// 十二張牌：順子
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"順子\" " + handPaiStr);
                    flag = true;
                } else if (isShunZi(lastHandPais)) {// 牌桌上的不是順子
                    System.out.println("\"順子\" " + handPaiStr + " 壓不住  "
                            + lastHandPaisStr);
                    flag = false;
                } else if (GameRuleUtil
                        .commpareTwoShunZi(handPai, lastHandPais)) {// 判斷玩家出的順子是否壓過牌桌上的順子
                    System.out.println("\"順子\" " + handPaiStr + " 壓住 \"順子\" "
                            + lastHandPaisStr);
                    flag = true;
                } else {
                    System.out.println("\"順子\" " + handPaiStr + " 壓不住 \"順子\" "
                            + lastHandPaisStr);
                    flag = false;
                }
            } else if (isLiandui(handPai)) {// 十二張牌： 六連對
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"六連對\" " + handPaiStr
                            + " 壓住 \"六連對\"  " + handPaiStr);
                    flag = true;
                } else if (isLiandui(lastHandPais)) {// 牌桌上的不是連對
                    System.out.println("\"六連對\" " + handPaiStr + " 壓不住   "
                            + handPaiStr);
                    flag = false;
                } else if (GameRuleUtil.commpareTwoLianDui(handPai,
                        lastHandPais)) {// 玩家出的連對壓過牌桌上的連對
                    System.out.println("\"六連對\" " + handPaiStr
                            + " 壓住 \"六連對\"  " + handPaiStr);
                    flag = true;
                } else {
                    System.out.println("\"六連對\" " + handPaiStr
                            + " 壓不住 \"六連對\"  " + handPaiStr);
                    flag = false;
                }
            } else {// 玩家出的十二張牌：不符合規(guī)則
                System.out.println("十二張牌 " + handPaiStr
                        + " 不是\"順子\" or \"六連對\"瘦麸，不符合游戲規(guī)則");
                flag = false;
            }
            break;
        case 13:// 玩家出13張牌
            System.out.println("不能出十三張牌 " + handPaiStr + " ，不符合游戲規(guī)則");
            flag = false;
            break;
        case 14:// 玩家出14張牌
            if (isLiandui(handPai)) {// 十四張牌：七連對
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"七連對\" " + handPaiStr);
                    flag = true;
                } else if (isLiandui(lastHandPais)) {// 牌桌上的不是連對
                    System.out.println("\"七連對\" " + handPaiStr + " 壓不住 "
                            + handPaiStr);
                    flag = false;
                } else if (GameRuleUtil.commpareTwoLianDui(handPai,
                        lastHandPais)) {// 玩家出的連對壓過牌桌上的連對
                    System.out.println("\"七連對\" " + handPaiStr
                            + " 壓住 \"七連對\"   " + handPaiStr);
                    flag = true;
                } else {
                    System.out.println("\"七連對\" " + handPaiStr
                            + " 壓不住 \"七連對\"   " + handPaiStr);
                    flag = false;
                }
            } else {// 玩家出的十四張牌：不符合規(guī)則
                System.out.println("十四張牌 " + handPaiStr + " 不是\"七連對\"歧胁，不符合游戲規(guī)則");
                flag = false;
            }
            break;
        case 15:// 玩家出15張牌
            System.out.println("不能出十五張牌 " + handPaiStr + " 滋饲，不符合游戲規(guī)則");
            flag = false;
            break;
        case 16:// 玩家出16張牌
            if (isLiandui(handPai)) {// 十六張牌：八連對
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"八連對\" " + handPaiStr);
                    flag = true;
                } else if (isLiandui(lastHandPais)) {// 牌桌上的不是連對
                    System.out.println("\"八連對\" " + handPaiStr + " 壓不住 "
                            + handPaiStr);
                    flag = false;
                } else if (GameRuleUtil.commpareTwoLianDui(handPai,
                        lastHandPais)) {// 玩家出的連對壓過牌桌上的連對
                    System.out.println("\"八連對\" " + handPaiStr
                            + " 壓住 \"八連對\"   " + handPaiStr);
                    flag = true;
                } else {
                    System.out.println("\"八連對\" " + handPaiStr
                            + " 壓不住 \"八連對\"    " + handPaiStr);
                    flag = false;
                }
            } else {// 玩家出的十六張牌：不符合規(guī)則
                System.out.println("十六張牌 " + handPaiStr + " 不是\"八連對\"，不符合游戲規(guī)則");
                flag = false;
            }
            break;
        case 17:// 玩家出17張牌
            System.out.println("不能出十七張牌 " + handPaiStr + " 喊巍，不符合游戲規(guī)則");
            flag = false;
            break;
        case 18:// 玩家出18張牌
            if (isLiandui(handPai)) {// 十八張牌：九連對
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"九連對\" " + handPaiStr);
                    flag = true;
                } else if (isLiandui(lastHandPais)) {// 牌桌上的不是連對
                    System.out.println("\"九連對\" " + handPaiStr + " 壓不住 "
                            + handPaiStr);
                    flag = false;
                } else if (GameRuleUtil.commpareTwoLianDui(handPai,
                        lastHandPais)) {// 玩家出的連對壓過牌桌上的連對
                    System.out.println("\"九連對\" " + handPaiStr
                            + " 壓住 \"九連對\"  " + handPaiStr);
                    flag = true;
                } else {
                    System.out.println("\"九連對\" " + handPaiStr
                            + " 壓不住 \"九連對\" " + handPaiStr);
                    flag = false;
                }
            } else {// 玩家出的十八張牌：不符合規(guī)則
                System.out.println("十八張牌 " + handPaiStr + " 不是\"九連對\"屠缭，不符合游戲規(guī)則");
                flag = false;
            }
            break;
        case 19:// 玩家出19張牌
            System.out.println("不能出十九張牌 " + handPaiStr + " ，不符合游戲規(guī)則");
            flag = true;
            break;
        case 20:// 玩家出20張牌
            if (isLiandui(handPai)) {// 20張牌：十連對
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"十連對\" " + handPaiStr);
                    flag = true;
                } else if (isLiandui(lastHandPais)) {// 牌桌上的不是連對
                    flag = false;
                } else if (GameRuleUtil.commpareTwoLianDui(handPai,
                        lastHandPais)) {// 玩家出的連對壓過牌桌上的連對
                    flag = true;
                } else {
                    flag = false;
                }
            } else {// 玩家出的二十張牌：不符合規(guī)則
                System.out.println("二十張牌 " + handPaiStr + " 不是\"十連對\"崭参，不符合游戲規(guī)則");
                flag = false;
            }
            break;
        default:
            break;
        }

游戲玩家出牌

System.out.println("玩家 --- " + wanjiaA.name + " (  "+ wanjiaA.status + " ) --- 開始出牌" + "\n");
wanjiaA.operationStatus = "出牌";
wanjiaA.chupai = new int[] { 73, 74  };
System.out.println(" 出 " + wanjiaA.chupai.length + " 張牌 " + "\n");
Guize localGuize = localXipai.new Guize();
System.out.println(localXipai.transitionToList(
localXipai.sortBubblingFromMinToMax(wanjiaA.chupai)).toString()
        + "\n");

最后編輯于：2017.12.03 04:34:00

?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者

人面猴
序言：七十年代末呵曹，一起剝皮案震驚了整個濱河市，隨后出現(xiàn)的幾起案子，更是在濱河造成了極大的恐慌奄喂，老刑警劉巖铐殃，帶你破解...
沈念sama閱讀 211,817評論 6贊 492
死咒
序言：濱河連續(xù)發(fā)生了三起死亡事件，死亡現(xiàn)場離奇詭異跨新，居然都是意外死亡富腊，警方通過查閱死者的電腦和手機(jī)，發(fā)現(xiàn)死者居然都...
沈念sama閱讀 90,329評論 3贊 385
救了他兩次的神仙讓他今天三更去死
文/潘曉璐我一進(jìn)店門域帐，熙熙樓的掌柜王于貴愁眉苦臉地迎上來赘被，“玉大人，你說我怎么就攤上這事肖揣∶窦伲” “怎么了？”我有些...
開封第一講書人閱讀 157,354評論 0贊 348
道士緝兇錄：失蹤的賣姜人
文/不壞的土叔我叫張陵龙优，是天一觀的道長羊异。經(jīng)常有香客問我，道長彤断，這世上最難降的妖魔是什么球化？我笑而不...
開封第一講書人閱讀 56,498評論 1贊 284
?港島之戀（遺憾婚禮）
正文為了忘掉前任，我火速辦了婚禮瓦糟，結(jié)果婚禮上，老公的妹妹穿的比我還像新娘赴蝇。我一直安慰自己菩浙，他們只是感情好，可當(dāng)我...
茶點故事閱讀 65,600評論 6贊 386
惡毒庶女頂嫁案：這布局不是一般人想出來的
文/花漫我一把揭開白布句伶。她就那樣靜靜地躺著劲蜻，像睡著了一般。火紅的嫁衣襯著肌膚如雪考余。梳的紋絲不亂的頭發(fā)上先嬉，一...
開封第一講書人閱讀 49,829評論 1贊 290
城市分裂傳說
那天，我揣著相機(jī)與錄音楚堤，去河邊找鬼疫蔓。笑死，一個胖子當(dāng)著我的面吹牛身冬，可吹牛的內(nèi)容都是我干的衅胀。我是一名探鬼主播，決...
沈念sama閱讀 38,979評論 3贊 408
雙鴛鴦連環(huán)套：你想象不到人心有多黑
文/蒼蘭香墨我猛地睜開眼酥筝，長吁一口氣：“原來是場噩夢啊……” “哼滚躯！你這毒婦竟也來了？” 一聲冷哼從身側(cè)響起，我...
開封第一講書人閱讀 37,722評論 0贊 266
萬榮殺人案實錄
序言：老撾萬榮一對情侶失蹤掸掏，失蹤者是張志新（化名）和其女友劉穎茁影，沒想到半個月后，有當(dāng)?shù)厝嗽跇淞掷锇l(fā)現(xiàn)了一具尸體丧凤，經(jīng)...
沈念sama閱讀 44,189評論 1贊 303
?護(hù)林員之死
正文獨居荒郊野嶺守林人離奇死亡募闲，尸身上長有42處帶血的膿包…… 初始之章·張勛以下內(nèi)容為張勛視角年9月15日...
茶點故事閱讀 36,519評論 2贊 327
?白月光啟示錄
正文我和宋清朗相戀三年，在試婚紗的時候發(fā)現(xiàn)自己被綠了息裸。大學(xué)時的朋友給我發(fā)了我未婚夫和他白月光在一起吃飯的照片蝇更。...
茶點故事閱讀 38,654評論 1贊 340
活死人
序言：一個原本活蹦亂跳的男人離奇死亡，死狀恐怖呼盆，靈堂內(nèi)的尸體忽然破棺而出年扩，到底是詐尸還是另有隱情，我是刑警寧澤访圃，帶...
沈念sama閱讀 34,329評論 4贊 330
?日本核電站爆炸內(nèi)幕
正文年R本政府宣布厨幻，位于F島的核電站，受9級特大地震影響腿时，放射性物質(zhì)發(fā)生泄漏况脆。R本人自食惡果不足惜，卻給世界環(huán)境...
茶點故事閱讀 39,940評論 3贊 313
男人毒藥：我在死后第九天來索命
文/蒙蒙一批糟、第九天我趴在偏房一處隱蔽的房頂上張望格了。院中可真熱鬧，春花似錦徽鼎、人聲如沸盛末。這莊子的主人今日做“春日...
開封第一講書人閱讀 30,762評論 0贊 21
一樁弒父案否淤，背后竟有這般陰謀
文/蒼蘭香墨我抬頭看了看天上的太陽悄但。三九已至，卻和暖如春石抡，著一層夾襖步出監(jiān)牢的瞬間檐嚣，已是汗流浹背。一陣腳步聲響...
開封第一講書人閱讀 31,993評論 1贊 266
情欲美人皮
我被黑心中介騙來泰國打工啰扛，沒想到剛下飛機(jī)就差點兒被人妖公主榨干…… 1. 我叫王不留嚎京，地道東北人。一個月前我還...
沈念sama閱讀 46,382評論 2贊 360
代替公主和親
正文我出身青樓侠讯，卻偏偏與公主長得像挖藏，于是被迫代替她去往敵國和親。傳聞我的和親對象是個殘疾皇子厢漩，可洞房花燭夜當(dāng)晚...
茶點故事閱讀 43,543評論 2贊 349

Java斗地主游戲開發(fā)

推薦閱讀更多精彩內(nèi)容