斗地主算法
最近需要做一个类似于斗地主的游戏，由于只是类似斗地主的游戏，因此，规则方面和斗地主存在一些不同，但是在算法上，也是大同小异，现对该游戏算法进行总结：
1.定义牌对象
首先需要对牌对象进行定义，正常斗地主玩法下，一张牌只有一个属性，就是数字大小，而不管花色，而在我们的游戏中，同样数字的牌，不同花色之间还可以比较，因此，我们的牌一共有两个基本属性，分别为花色和大小。
1.1 规则
对于花色，规则定义如下：黑桃>梅花>方片>红桃
对于数字，规则定义如下：2最大，3最小
1.2 建模
我们将牌的牌面实际数字使用数字进行标记，使用数字3到15表示真实牌的3到2，其中11表示J，12表示Q，13表示K，14表示A，15表示2，其余数字分别代表真实牌面数字。
将牌的牌面花色同样使用数字进行标记：根据从大到小，分别标记为：4——黑桃，3——梅花，2——方片，1——红桃。
这样，对于一张牌的数字模型，使用以下公式进行标记：
牌数字模型大小 = 牌面数字模型大小 * 10 + 牌面花色模型大小
// 牌号点数：如3~J~A~2,使用3~15数字
private int cardNumber;
// 牌色：如4红桃, 3方片, 2梅花, 1黑桃
private int cardColor;
// 牌全称：例34是红桃3,152是梅花2,113是方片J
private String cardName;
// 牌描述：例红桃3,梅花2
private String cardDesc;
1.3 总结
经过上边的标记，我们很容易将一张牌的模型进行数字化，例如：
154——黑桃2
151——红桃2
83——梅花8
这样154>151，同样黑桃2大于红桃2
151>83，同样红桃2大于梅花8
2. 构建一副牌
构建一副牌可以从花色、牌面大小、牌的名称、牌的描述四个方面进行构建，其中花色（4——黑桃，3——梅花，2——方片，1——红桃），大小为：使用数字3到15表示真实牌的3到2，牌名称即牌大小和花色组成的数字大小，描述是通用的牌的叫法，比如：154——黑桃2 牌名称为154 描述为 黑桃2
这里需要主要的是：斗地主中存在王，大小王，共54张牌，而在我们的TienLen游戏中不存在大小王，只有52张牌
/**
* 初始化牌
* @return
*/
public List<CardInfo> initCard() {
List<CardInfo> cardList = new ArrayList<CardInfo>();
for (int i = 1; i < 5; i++) {
for (int j = 3; j < 16; j++) {
CardInfo cardInfo = new CardInfo();
cardInfo.setCardNumber(j);
cardInfo.setCardColor(i);
cardInfo.setCardName(j * 10 + i + "");
switch (i) {
case 1:
cardInfo.setCardDesc("红桃" + j);
break;
case 2:
cardInfo.setCardDesc("方片" + j);
break;
case 3:
cardInfo.setCardDesc("梅花" + j);
break;
case 4:
cardInfo.setCardDesc("黑桃" + j);
break;
}
cardList.add(cardInfo);
}
}
return cardList;
}
3. 洗牌
洗牌只需要将牌进行打乱即可，这里考虑使用随机数进行交换，模拟洗牌，但是这样的算法存在缺陷，即有可能洗完以后，牌仍然保持原样
/**
* 洗牌
*
* @param cardList 初始化号的牌
* @return
*/
public List<CardInfo> washCard(List<CardInfo> cardList) {
List<CardInfo> randomCardList = cardList;
for (int i = 0; i < 100; i++) {
Random random = new Random();
// 找出52以内的随机数，然后交换位置
int a = random.nextInt(52);
int b = random.nextInt(52);
CardInfo cardInfoTemp = randomCardList.get(a);
randomCardList.set(a, randomCardList.get(b));
randomCardList.set(b, cardInfoTemp);
}
return randomCardList;
}
4. 发牌
发牌算法很简单，将已经洗好的52张牌，顺序发给各个玩家。这里我们与斗地主区别在于，我们这里一共有四个玩家，因此需要将牌分为4份：
/**
* 发牌
*
* @param cardList 洗好的牌
* @return
*/
public List<CardInfo>[] handCard(List<CardInfo> cardList) {
List<CardInfo> playerCardList[] = new Vector[4];
for (int i = 0; i < 4; i++) {
playerCardList[i] = new Vector<CardInfo>();
}
for (int j = 0; j < 52; j++) {
switch (j % 4) {
case 0:
playerCardList[0].add(cardList.get(j));
break;
case 1:
playerCardList[1].add(cardList.get(j));
break;
case 2:
playerCardList[2].add(cardList.get(j));
break;
case 3:
playerCardList[3].add(cardList.get(j));
break;
default:
break;
}
}
return playerCardList;
}
5. 捋牌
也就是对牌进行排序，从大到小进行排序，这样出来的牌，便于往后进行分类等运算。
/**
* 排序，按照从大到小的顺序进行排
*
* @param cardList
* @return
*/
public List<CardInfo> sortCard(List<CardInfo> cardList) {
Collections.sort(cardList, new Comparator<CardInfo>() {
@Override
public int compare(CardInfo cardInfo1, CardInfo cardInfo2) {
int cardNum1 = Integer.valueOf(cardInfo1.getCardName());
int cardNum2 = Integer.valueOf(cardInfo2.getCardName());
if (cardNum1 > cardNum2) {
return -1;
} else if (cardNum1 == cardNum2) {
return 0;
} else {
return 1;
}
}
});
return cardList;
}
6. 出牌
出牌时，应该根据规则进行出牌，首先、判断用户所选择的牌是否符合规则，即是否是单牌、对子、三张、链子、炸弹等
6.1 单张牌
获取单张牌的算法很简单，任意一张牌，都可以作为单张牌使用，因此只需要将所有的牌都添加到单张牌的列表中即可。
/***
* 获取单张牌
*
* @param mCardList
* @return
*/
public List<List<CardInfo>> get1(List<CardInfo> mCardList) {
List<List<CardInfo>> all1List = new ArrayList<>();
List<CardInfo> cardList;
sortCardAsc(mCardList);
for (int i = 0, length = mCardList.size(); i < length; i++) {
cardList = new ArrayList<>();
cardList.add(mCardList.get(i));
all1List.add(cardList);
}
return all1List;
}
6.2 对子
获取对子时，需要注意，因为我们TienLen游戏的规则中，不仅需要比较牌面点数大小，还需要比较花色大小，所以，同样4个2，可能组合成多种对子，且大小不一样，比如黑桃2和梅花2，比如红桃2和方片2
/**
* 获取对子
* 这里对i+1 i+2 i+3分别和第i张牌进行对比，
* 举例：比如四个2，可以黑桃2和方片2一对，也可以是梅花2和红桃2一对
*
* @param mCardList
* @return
*/
public List<List<CardInfo>> get11(List<CardInfo> mCardList) {
// 先对牌进行排序
sortCardAsc(mCardList);
List<List<CardInfo>> all11CardList = new ArrayList<>();
List<CardInfo> cardList;
for (int i = 0, length = mCardList.size(); i < length; i++) {
if (i + 1 < length
&& mCardList.get(i).getCardNumber() == mCardList.get(i + 1).getCardNumber()) {
cardList = new ArrayList<>();
cardList.add(mCardList.get(i));
cardList.add(mCardList.get(i + 1));
all11CardList.add(cardList);
}
if (i + 2 < length
&& mCardList.get(i).getCardNumber() == mCardList.get(i + 2).getCardNumber()) {
cardList = new ArrayList<>();
cardList.add(mCardList.get(i));
cardList.add(mCardList.get(i + 2));
all11CardList.add(cardList);
}
if (i + 3 < length
&& mCardList.get(i).getCardNumber() == mCardList.get(i + 3).getCardNumber()) {
cardList = new ArrayList<>();
cardList.add(mCardList.get(i));
cardList.add(mCardList.get(i + 3));
all11CardList.add(cardList);
}
}
return all11CardList;
}
6.3 三个
在斗地主的规则中，好像也是三个也可以一起出，但是需要带一个或者一对，我们TienLen游戏中不需要带，也不能带，可以直接出，比如三个三，三个四，这样的牌，获取的算法和上边对子的获取算法一致
/***
* 获取三个
* 算法个获取对子的算法类似
*
* @param mCardList
* @return
*/
public List<List<CardInfo>> get111(List<CardInfo> mCardList) {
List<List<CardInfo>> all111List = new ArrayList<>();
List<CardInfo> cardList;
// 先对牌进行排序
sortCardAsc(mCardList);
for (int i = 0, length = mCardList.size(); i < length; i++) {
if (i + 2 < length
&& mCardList.get(i).getCardNumber() == mCardList.get(i + 2).getCardNumber()) {
cardList = new ArrayList<>();
cardList.add(mCardList.get(i));
cardList.add(mCardList.get(i + 1));
cardList.add(mCardList.get(i + 2));
all111List.add(cardList);
}
}
return all111List;
}
6.4 炸弹
炸弹，不论在斗地主中还是我们现在做的TienLen中，都是一样的作用，一样的获取方法，和获取对子，三个的方法一致，这里直接上代码：
/***
* 获取炸弹
*
* @param mCardList
* @return
*/
public List<List<CardInfo>> get1111(List<CardInfo> mCardList) {
List<List<CardInfo>> all1111List = new ArrayList<>();
List<CardInfo> cardList;
for (int i = 0, length = mCardList.size(); i < length; i++) {
if (i + 3 < length
&& mCardList.get(i).getCardNumber() == mCardList.get(i + 3).getCardNumber()) {
cardList = new ArrayList<>();
cardList.add(mCardList.get(i));
cardList.add(mCardList.get(i + 1));
cardList.add(mCardList.get(i + 2));
cardList.add(mCardList.get(i + 3));
all1111List.add(cardList);
}
}
return all1111List;
}
6.5 链子
终于说到了这个牌型——链子，链子在不同的玩法中，可以出不同的长度，在我们的TienLen中最少是三联，这里获取时，先对手牌进行排序，排好序后，进行遍历，找到能和当前牌连接起来的，且牌长度大于3的，均属于链子：
/**
* 获取链子
*
* @param mCardList
* @return
*/
public List<List<CardInfo>> get123(List<CardInfo> mCardList) {
// 链子长度必须大于3,即最少出3连
if (mCardList.size() < 3) {
return null;
}
// 构建返回数据
List<CardInfo> tempCardList = new ArrayList<>();
List<List<CardInfo>> all123List = new ArrayList<>();
// 先去掉2
for (int i = 0; i < mCardList.size(); i++) {
if (mCardList.get(i).getCardNumber() != 15) {
tempCardList.add(mCardList.get(i));
}
}
// 重新进行排序
sortCardAsc(tempCardList);
for (int i = 0; i < tempCardList.size(); i++) {
CardInfo tempCardInfo = tempCardList.get(i);
List<CardInfo> cardList = new ArrayList<>();
cardList.add(tempCardInfo);
List<CardInfo> cardListTempAfter = new ArrayList<>();
for (int j = i + 1; j < tempCardList.size(); j++) {
// 判断当前牌是否个下一个牌能连起来（当前牌是5，当下一个是5+1=6时，即连起来了，当连起来大于3个牌时，即可以认为是一连）
if ((tempCardInfo.getCardNumber() + 1) == tempCardList.get(j).getCardNumber()) {
cardListTempAfter.clear();
cardListTempAfter.addAll(cardList);
cardList.add(tempCardList.get(j));
tempCardInfo = tempCardList.get(j);
if (cardList.size() >= 3) {
List<CardInfo> cardListTemp = new ArrayList<>();
cardListTemp.addAll(cardList);
all123List.add(cardList);
cardList = new ArrayList<>();
cardList.addAll(cardListTemp);
}
} else if (tempCardInfo.getCardNumber() == tempCardList.get(j).getCardNumber()
&& tempCardInfo.getCardNumber() != tempCardList.get(i).getCardNumber()) {
List<CardInfo> cardListTemp = new ArrayList<>();
cardListTemp.addAll(cardListTempAfter);
if (cardListTemp.size() > 0
&& cardListTemp.get(cardListTemp.size() - 1).getCardNumber() != tempCardList
.get(j).getCardNumber()) {
cardListTempAfter.add(tempCardList.get(j));
if (cardListTempAfter.size() >= 3) {
all123List.add(cardListTempAfter);
cardListTempAfter = new ArrayList<>();
cardListTempAfter.addAll(cardListTemp);
}
}
}
}
}
return all123List;
}
6.6 双链
双链，也就是经常说的飞机带翅膀，双链的前提是对子，只有存在对子的情况下，才能找出来双链，所以，其算法也是一样，先找到所有的对子，然后去掉2，进行排序，再按照找链子的方法进行找，这样返回的就是双链。
/***
* 获取飞机
*
* @param mCardInfoList
* @return
*/
public List<List<CardInfo>> get112233(List<CardInfo> mCardInfoList) {
int length = mCardInfoList.size();
// 双链最少为3连，所以最少六张牌
if (length < 6) {
return null;
}
// 保存所有的对子
List<CardInfo> tempList = new ArrayList<>();
// 保存所有不包含2的对子
List<CardInfo> apairTempList = new ArrayList<>();
// 防止重复添加
List<Integer> integerList = new Vector<>();
// 返回结果
List<List<CardInfo>> all112233List = new ArrayList<>();
// 存储单个双对链子
List<CardInfo> cardList;
// 先获取所有的对子
for (int i = 0; i < length; i++) {
if (i + 1 < length
&& mCardInfoList.get(i).getCardNumber() == mCardInfoList.get(i + 1)
.getCardNumber()) {
tempList.add(mCardInfoList.get(i));
tempList.add(mCardInfoList.get(i + 1));
i = i + 1;
}
}
// 排序
sortCardAsc(tempList);
// 去除对2和相同的
for (int i = 0, tempLength = tempList.size(); i < tempLength; i++) {
if (!integerList.contains(Integer.valueOf(tempList.get(i).getCardNumber()))) {
apairTempList.add(tempList.get(i));
integerList.add(Integer.valueOf(tempList.get(i).getCardNumber()));
}
}
// 双对的链子最少三联
if (apairTempList.size() < 3) {
return null;
}
// 对之前拿到的对子List进行排序，正序
sortCardAsc(tempList);
// 到这里已经拿到了所有对子中的某一个单牌，只需拿出所有的链子
List<List<CardInfo>> get123TempList = get123(apairTempList);
for (int j = 0; j < get123TempList.size(); j++) {
List<CardInfo> list123 = get123TempList.get(j);
sortCardAsc(list123);
for (int k = 0; k < tempList.size(); k++) {
if (tempList.get(k).getCardName().equals(list123.get(0).getCardName())) {
cardList = new ArrayList<>();
for (int l = k; l < list123.size() * 2 + k; l++) {
cardList.add(tempList.get(l));
}
all112233List.add(cardList);
}
}
}
return all112233List;
}
7 出牌
出牌有两种情况，一种是手动选择的，一种是通过提示，自动出牌的。对于手动选择的，需要根据自己当前是否有首先出牌权，进行校验，
- 如果当前是自己的局，也就是说，上轮出牌的过程中，自己最大，这局自己首先出，所以只需要校验自己手动选择的牌是否符合规则。
- 如果当前是别人的局，也就是说，自己当前跟着别人的局出牌，只能和别人的类型一致，且大于对方，所以需要校验选择的牌类型是否和别人的一致，再校验是否比别人的大，才能出
对于通过提示出牌的，只适合第二种情况，也就是说，别人出牌，然后自己管，系统会进行提示
7.1 判断所选择的牌，是否符合已经定义的出牌类型，对应上边所述的第一种情况，只要符合规则均可以出
/**
* 获取出牌类型
*
* @param outCard
* @return
*/
public OutCardType getOutCardType(List<CardInfo> outCard) {
if (outCard != null) {
int cardLength = outCard.size();
if (outCard.get(0).getCardNumber() == outCard.get(cardLength - 1).getCardNumber()) {
switch (cardLength) {
case 1:
// 单牌
return OutCardType.type1;
case 2:
// 对子
return OutCardType.type11;
case 3:
// 三个
return OutCardType.type111;
case 4:
// 炸弹
return OutCardType.type1111;
}
}
// 判断链子，最少三张
if (outCard.size() >= 3) {
List<CardInfo> tempCardList = new ArrayList<>();
// 先去掉2
for (int i = 0; i < outCard.size(); i++) {
if (outCard.get(i).getCardNumber() != 15) {
tempCardList.add(outCard.get(i));
}
}
// 重新进行排序
sortCardAsc(tempCardList);
// 判断是否为链子
List<List<CardInfo>> get123 = get123(outCard);
if (get123 != null && get123.size() > 0) {
for (List<CardInfo> list : get123) {
if (list.size() == outCard.size()) {
return OutCardType.type123;
}
}
}
// 双对至少6张
if (outCard.size() >= 6) {
int length = outCard.size();
// 保存所有的对子
List<CardInfo> tempList = new ArrayList<>();
// 保存所有不包含2的对子
List<CardInfo> apairTempList = new ArrayList<>();
// 防止重复添加
List<Integer> integerList = new Vector<>();
// 先获取所有的对子
for (int i = 0; i < length; i++) {
if (i + 1 < length
&& outCard.get(i).getCardNumber() == outCard.get(i + 1)
.getCardNumber()) {
tempList.add(outCard.get(i));
tempList.add(outCard.get(i + 1));
i = i + 1;
}
}
// 所有的牌均为对子
if (tempList.size() == outCard.size()) {
// 去除对2
for (int i = 0, tempLength = tempList.size(); i < tempLength; i++) {
if (integerList.indexOf(outCard.get(i).getCardNumber()) < 0
&& tempList.get(i).getCardNumber() != 15) {
apairTempList.add(tempList.get(i));
integerList.add(tempList.get(i).getCardNumber());
}
i = i + 1;
}
// 到这里已经拿到了所有对子中的某一个单牌，只需拿出所有的链子
List<List<CardInfo>> get123TempList = get123(apairTempList);
for (int i = 0; i < get123TempList.size(); i++) {
if (get123TempList.get(i).size() == length / 2) {
return OutCardType.type112233;
}
}
}
}
}
}
return OutCardType.type0;
}
只有当选中牌的类型是已知类型，才能第一步判断出是否可以出牌，下一步则需要根据当前是不是自己轮，判断需要不需要压对方的牌
7.2 判断当前所选择的牌，是否符合规则，而且，是否比上一家出的牌大
/**
* 当上家出牌后，判断自己是否可以出牌
*
* @param outCard
* @param mAllCard
* @param mSelectCard
* @return
*/
public boolean whetherCanPlay(List<CardInfo> outCard, List<CardInfo> mAllCard,
List<CardInfo> mSelectCard) {
boolean isCardCanPlay = false;
// 获取对手牌型
OutCardType outCardType = getOutCardType(outCard);
OutCardType outCardTypeMy = getOutCardType(mSelectCard);
sortCard(outCard);
// 先对牌进行排序
sortCard(mSelectCard);
// 首先判断牌的张数是否一样
if (outCard.size() == mSelectCard.size() && outCardType == outCardTypeMy) {
int outCardName = Integer.valueOf(outCard.get(0).getCardName());
int mSelectCardName = Integer.valueOf(mSelectCard.get(0).getCardName());
// 相同，属于同一级牌之间压
switch (outCardType) {
case type1:
if (mSelectCardName > outCardName) {
isCardCanPlay = true;
}
break;
case type11:
if (mSelectCardName > outCardName) {
isCardCanPlay = true;
}
break;
case type111:
if (mSelectCardName > outCardName) {
isCardCanPlay = true;
}
break;
case type1111:
if (mSelectCardName > outCardName) {
isCardCanPlay = true;
}
break;
case type123:
if (mSelectCardName > outCardName) {
isCardCanPlay = true;
}
break;
case type112233:
if (mSelectCardName > outCardName) {
isCardCanPlay = true;
}
break;
default:
isCardCanPlay = false;
break;
}
} else {
// 当张数不一致时，有两种情况，即炸弹压2和连着的双对压对2
if (outCard.size() == 1 && mSelectCard.size() == 4) {
// 当别人为单个2且自己的Type为炸弹时
if (outCard.get(0).getCardNumber() == 15
&& getOutCardType(mSelectCard) == OutCardType.type1111) {
isCardCanPlay = true;
}
} else {
// 别人出牌为一对2，自己应该用33-44-55-66或者55-66-77-88压
if (outCard.size() == 2 && mSelectCard.size() >= 8) {
if (outCard.get(0).getCardNumber() == 15
&& getOutCardType(mSelectCard) == OutCardType.type112233) {
isCardCanPlay = true;
}
} else {
isCardCanPlay = false;
}
}
}
return isCardCanPlay;
}
这里边包含了部分规则，比如同样的牌类型，比较大小，同时33445566可以压对二这样的规则
8. 提示
提示算法比较简单，先获取上家出牌的类型，再获取自己手牌中对应类型的列表，逐个进行比较，直到找到合适的
AI
这里除了上述洗牌、发牌、出牌等算法之外，还有单机模式的AI算法，回头有空了整理下，我再发上来吧。
总结
在这片文章中，只是写了一个针对斗地主类类游戏的牌的算法，包含了牌模型构建、洗牌、发牌、出牌等算法的实现，虽然游戏规则不同，但是思路大同小异，希望有需要的同学可以参考下。
本博客所有文章除特别声明外，均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 沙僧！
