斗地主+三人+叫地主

斗地主+三人+叫地主

斗地主+三人+叫地主

版权声明原作品版权声明本文版权声明

一、相关文章二、新增功能叫地主功能 方法CardsPower()

三、运行PlayWithLandlord_CallPoints_V1展示四、代码代码框架PlayWithLandlord_CallPoints_V1CardCardGroupCardProductsCardsFactoryCardTestCardUtilsGameConstantsPrompt

版权声明

原作品版权声明

java斗地主游戏开发 算法思路讲解 转载请注明出处 若本文侵犯原作者的版权,联系邮箱3063494684@qq.com删除本文

本文版权声明

代码改编于两人版 java斗地主游戏开发 算法思路讲解

1、本文所有内容文字资料,版权均属作者个人所有, 任何媒体、网站或个人不得复制内容用于发布/发表。 引用必须注明来源

2、本文下载仅供个人学习或研究,不得在任何网站以任何形式上传。

3、转载、链接、转贴必须注明来源,并且不能用作商用,只能用于学习或研究

除注明来源外,以下内容亦不可任意转载: a.本文所指向的非本人内容的相关链接内容; b.已作出不得转载或未经许可不得转载声明的内容; c.其他法律不允许或本人认为不适合的内容。

转载或引用本人内容不得进行如下活动: a.损害本人或他人利益; b.任何违法行为; c.任何可能破坏公秩良俗的行为; d.擅自同意他人继续转载、引用本文内容;

4、对不遵守本声明或其他违法、恶意使用本人内容者,本人保留追究其法律责任的权利。

署名:日星月云

一、相关文章

斗地主三人版 斗地主+三人+叫地主 斗地主+三人+叫地主+作弊(可设置) 斗地主+三人+叫地主+作弊(可设置)+积分属性 斗地主+三人+叫地主+作弊(可设置)+积分属性+记牌器(可设置)

二、新增功能

叫地主功能 方法CardsPower()

* 5--一分 7--两分 10--三分

* 预估玩家的初始手牌的牌力

* 炸弹分为5点

* 对于7890j炸弹为4(因为容易被拆)

* 对于王炸为8分

* 三条2是3分

* 三条是1点

* 对2是2点

* C是4分

* c是3分

*

三、运行PlayWithLandlord_CallPoints_V1展示

"C:\Program Files\Java\jdk-15.0.1\bin\java.exe" "-javaagent:E:\IntelliJ IDEA 2021.1\lib\idea_rt.jar=7607:E:\IntelliJ IDEA 2021.1\bin" -Dfile.encoding=UTF-8 -classpath C:\Users\lenovo\IdeaProjects\DouDiZhu\out\production\DouDiZhu;C:\Users\lenovo\.m2\repository\junit\junit\4.13.1\junit-4.13.1.jar;C:\Users\lenovo\.m2\repository\org\hamcrest\hamcrest-core\1.3\hamcrest-core-1.3.jar;C:\Users\lenovo\.m2\repository\org\junit\jupiter\junit-jupiter\5.7.0\junit-jupiter-5.7.0.jar;C:\Users\lenovo\.m2\repository\org\junit\jupiter\junit-jupiter-api\5.7.0\junit-jupiter-api-5.7.0.jar;C:\Users\lenovo\.m2\repository\org\apiguardian\apiguardian-api\1.1.0\apiguardian-api-1.1.0.jar;C:\Users\lenovo\.m2\repository\org\opentest4j\opentest4j\1.2.0\opentest4j-1.2.0.jar;C:\Users\lenovo\.m2\repository\org\junit\platform\junit-platform-commons\1.7.0\junit-platform-commons-1.7.0.jar;C:\Users\lenovo\.m2\repository\org\junit\jupiter\junit-jupiter-params\5.7.0\junit-jupiter-params-5.7.0.jar;C:\Users\lenovo\.m2\repository\org\junit\jupiter\junit-jupiter-engine\5.7.0\junit-jupiter-engine-5.7.0.jar;C:\Users\lenovo\.m2\repository\org\junit\platform\junit-platform-engine\1.7.0\junit-platform-engine-1.7.0.jar com.ddz.PlayWithLandlord_CallPoints_V1

地主牌为♥10

底牌为[J, 3, K]

您的扑克牌:[A, A, Q, Q, Q, Q, J, 9, 8, 7, 7, 7, 5, 5, 5, 4, 4]

上家扑克牌:[大王, 小王, 2, A, K, K, J, 10, 10, 9, 8, 8, 7, 5, 4, 3, 3]

下家扑克牌:[2, 2, 2, A, K, J, 10, 10, 9, 9, 8, 6, 6, 6, 6, 4, 3]

=====================================叫地主阶段=====================================

下家有地主牌♥10,下家先叫地主

===下家叫地主===

2分

===上家叫地主===

不叫

===玩家叫地主===

输入0,不叫 / 输入3,3分 -----> 3

3分

======玩家是地主======

底牌为[J, 3, K]

===================================================================================

======================================出牌阶段======================================

=======================玩家主动出牌=======================

您当前的扑克牌:[A, A, K, Q, Q, Q, Q, J, J, 9, 8, 7, 7, 7, 5, 5, 5, 4, 4, 3]

请您出牌:(输入?提示 输入,偷看电脑的牌)

5553

出牌成功:CardProduct{list=[5, 5, 5, 3], type=三带一, maxCard=5, len=4, group=[(num=2, sum=3), (num=0, sum=1)]}

玩家剩余牌数:16

=============下家=================

下家当前扑克牌:[2, 2, 2, A, K, J, 10, 10, 9, 9, 8, 6, 6, 6, 6, 4, 3]

下家出牌:[2, 2, 2, 3]

下家剩余牌数:13

======================================出牌阶段======================================

=============上家=================

上家当前扑克牌:[大王, 小王, 2, A, K, K, J, 10, 10, 9, 8, 8, 7, 5, 4, 3, 3]

上家出牌:[大王, 小王]

上家剩余牌数:15

=============玩家=================

上一次出牌:CardProduct{list=[大王, 小王], type=炸弹, maxCard=大王, len=2, group=[(num=13, sum=2)]}

您当前的扑克牌:[A, A, K, Q, Q, Q, Q, J, J, 9, 8, 7, 7, 7, 4, 4]

请您出牌:(输入.不出 输入?提示 输入,偷看电脑的牌)

.

=============下家=================

下家当前扑克牌:[A, K, J, 10, 10, 9, 9, 8, 6, 6, 6, 6, 4]

下家不要

======================================出牌阶段======================================

=======================上家主动出牌=======================

上家当前扑克牌:[2, A, K, K, J, 10, 10, 9, 8, 8, 7, 5, 4, 3, 3]

上家主动出牌:[J, 10, 9, 8, 7]

上家剩余牌数:10

=============玩家=================

上一次出牌:CardProduct{list=[J, 10, 9, 8, 7], type=顺子, maxCard=J, len=5, group=[(num=8, sum=1), (num=7, sum=1), (num=6, sum=1), (num=5, sum=1), (num=4, sum=1)]}

您当前的扑克牌:[A, A, K, Q, Q, Q, Q, J, J, 9, 8, 7, 7, 7, 4, 4]

请您出牌:(输入.不出 输入?提示 输入,偷看电脑的牌)

.

=============下家=================

下家当前扑克牌:[A, K, J, 10, 10, 9, 9, 8, 6, 6, 6, 6, 4]

下家出牌:[6, 6, 6, 6]

下家剩余牌数:9

======================================出牌阶段======================================

=============上家=================

上家当前扑克牌:[2, A, K, K, 10, 8, 5, 4, 3, 3]

上家不要

=============玩家=================

上一次出牌:CardProduct{list=[6, 6, 6, 6], type=炸弹, maxCard=6, len=4, group=[(num=3, sum=4)]}

您当前的扑克牌:[A, A, K, Q, Q, Q, Q, J, J, 9, 8, 7, 7, 7, 4, 4]

请您出牌:(输入.不出 输入?提示 输入,偷看电脑的牌)

.

=======================下家主动出牌=======================

下家当前扑克牌:[A, K, J, 10, 10, 9, 9, 8, 4]

下家主动出牌:[4]

下家剩余牌数:8

======================================出牌阶段======================================

=============上家=================

上家当前扑克牌:[2, A, K, K, 10, 8, 5, 4, 3, 3]

上家出牌:[5]

上家剩余牌数:9

=============玩家=================

上一次出牌:CardProduct{list=[5], type=单牌, maxCard=5, len=1, group=[(num=2, sum=1)]}

您当前的扑克牌:[A, A, K, Q, Q, Q, Q, J, J, 9, 8, 7, 7, 7, 4, 4]

请您出牌:(输入.不出 输入?提示 输入,偷看电脑的牌)

8

出牌成功:CardProduct{list=[8], type=单牌, maxCard=8, len=1, group=[(num=5, sum=1)]}

玩家剩余牌数:15

=============下家=================

下家当前扑克牌:[A, K, J, 10, 10, 9, 9, 8]

下家出牌:[J]

下家剩余牌数:7

======================================出牌阶段======================================

=============上家=================

上家当前扑克牌:[2, A, K, K, 10, 8, 4, 3, 3]

上家出牌:[A]

上家剩余牌数:8

=============玩家=================

上一次出牌:CardProduct{list=[A], type=单牌, maxCard=A, len=1, group=[(num=11, sum=1)]}

您当前的扑克牌:[A, A, K, Q, Q, Q, Q, J, J, 9, 7, 7, 7, 4, 4]

请您出牌:(输入.不出 输入?提示 输入,偷看电脑的牌)

.

=============下家=================

下家当前扑克牌:[A, K, 10, 10, 9, 9, 8]

下家不要

======================================出牌阶段======================================

=======================上家主动出牌=======================

上家当前扑克牌:[2, K, K, 10, 8, 4, 3, 3]

上家主动出牌:[3, 3]

上家剩余牌数:6

=============玩家=================

上一次出牌:CardProduct{list=[3, 3], type=对子, maxCard=3, len=2, group=[(num=0, sum=2)]}

您当前的扑克牌:[A, A, K, Q, Q, Q, Q, J, J, 9, 7, 7, 7, 4, 4]

请您出牌:(输入.不出 输入?提示 输入,偷看电脑的牌)

44

出牌成功:CardProduct{list=[4, 4], type=对子, maxCard=4, len=2, group=[(num=1, sum=2)]}

玩家剩余牌数:13

=============下家=================

下家当前扑克牌:[A, K, 10, 10, 9, 9, 8]

下家出牌:[9, 9]

下家剩余牌数:5

======================================出牌阶段======================================

=============上家=================

上家当前扑克牌:[2, K, K, 10, 8, 4]

上家出牌:[K, K]

上家剩余牌数:4

=============玩家=================

上一次出牌:CardProduct{list=[K, K], type=对子, maxCard=K, len=2, group=[(num=10, sum=2)]}

您当前的扑克牌:[A, A, K, Q, Q, Q, Q, J, J, 9, 7, 7, 7]

请您出牌:(输入.不出 输入?提示 输入,偷看电脑的牌)

11

出牌成功:CardProduct{list=[A, A], type=对子, maxCard=A, len=2, group=[(num=11, sum=2)]}

玩家剩余牌数:11

=============下家=================

下家当前扑克牌:[A, K, 10, 10, 8]

下家不要

======================================出牌阶段======================================

=============上家=================

上家当前扑克牌:[2, 10, 8, 4]

上家不要

=======================玩家主动出牌=======================

您当前的扑克牌:[K, Q, Q, Q, Q, J, J, 9, 7, 7, 7]

请您出牌:(输入?提示 输入,偷看电脑的牌)

7779

出牌成功:CardProduct{list=[7, 7, 7, 9], type=三带一, maxCard=7, len=4, group=[(num=4, sum=3), (num=6, sum=1)]}

玩家剩余牌数:7

=============下家=================

下家当前扑克牌:[A, K, 10, 10, 8]

下家不要

======================================出牌阶段======================================

=============上家=================

上家当前扑克牌:[2, 10, 8, 4]

上家不要

=======================玩家主动出牌=======================

您当前的扑克牌:[K, Q, Q, Q, Q, J, J]

请您出牌:(输入?提示 输入,偷看电脑的牌)

jj

出牌成功:CardProduct{list=[J, J], type=对子, maxCard=J, len=2, group=[(num=8, sum=2)]}

玩家剩余牌数:5

=============下家=================

下家当前扑克牌:[A, K, 10, 10, 8]

下家不要

======================================出牌阶段======================================

=============上家=================

上家当前扑克牌:[2, 10, 8, 4]

上家不要

=======================玩家主动出牌=======================

您当前的扑克牌:[K, Q, Q, Q, Q]

请您出牌:(输入?提示 输入,偷看电脑的牌)

k

出牌成功:CardProduct{list=[K], type=单牌, maxCard=K, len=1, group=[(num=10, sum=1)]}

玩家剩余牌数:4

=============下家=================

下家当前扑克牌:[A, K, 10, 10, 8]

下家出牌:[A]

下家剩余牌数:4

======================================出牌阶段======================================

=============上家=================

上家当前扑克牌:[2, 10, 8, 4]

上家出牌:[2]

上家剩余牌数:3

=============玩家=================

上一次出牌:CardProduct{list=[2], type=单牌, maxCard=2, len=1, group=[(num=12, sum=1)]}

您当前的扑克牌:[Q, Q, Q, Q]

请您出牌:(输入.不出 输入?提示 输入,偷看电脑的牌)

qqqq

出牌成功:CardProduct{list=[Q, Q, Q, Q], type=炸弹, maxCard=Q, len=4, group=[(num=9, sum=4)]}

玩家剩余牌数:0

===================================================================================

你赢啦!

Process finished with exit code 0

四、代码

代码框架

PlayWithLandlord_CallPoints_V1

package com.ddz;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import java.util.Scanner;

/*

* Cc代表大小王,0代表10

* 大小写jqk都可以代表JQK

* Aa1都代表A

*

* 多少副牌sum、是否包含345contains345可以在main方法中更改

*

* 四炸<双王炸<五炸<六炸<三王炸<七炸<八炸<四王炸

* 并且[大王, 大王]是可以打赢[大王, 小王]和[小王, 小王]的

*/

/**

* 斗地主+三人+叫地主+V1

*/

public class PlayWithLandlord_CallPoints_V1 {

private static List player;//玩家

private static List left;//上家

private static List right;//下家

private static CardProduct last = CardProduct.createNullType();

private static List holeCards = new ArrayList<>();//底牌

private static Card specialCard;//地主牌,最开始叫地主

/**

* 发牌

*

* @param sum 多少副牌

* @param contains345 是否包含345

*/

public static void licensing(int sum, boolean contains345) {

player = new ArrayList<>();

left = new ArrayList<>();

right = new ArrayList<>();

ArrayList list = new ArrayList<>();//牌堆

for (int i = 0; i < sum; i++) {

for (int j = contains345 ? GameConstants.ID_3_1 : GameConstants.ID_6_1; j < 54; j++) {

list.add(j);

}

}

int specialId;

while (true) {

specialId = (int) (Math.random() * list.size());

if (contains345 == false) {

if (specialId >= GameConstants.ID_3_1 && specialId < GameConstants.ID_6_1) {

continue;

}

}

specialCard = new Card(specialId);

break;

}

//底牌

while (holeCards.size() < 3) {

int cardId = (int) (Math.random() * list.size());

if (specialId != cardId) {

Card card = new Card(list.remove(cardId));

holeCards.add(card);

}

}

//发牌

while (list.size() > 0) {

player.add(new Card(list.remove((int) (Math.random() * list.size()))));

left.add(new Card(list.remove((int) (Math.random() * list.size()))));

right.add(new Card(list.remove((int) (Math.random() * list.size()))));

}

player.sort((o1, o2) -> o2.id - o1.id);

left.sort((o1, o2) -> o2.id - o1.id);

right.sort((o1, o2) -> o2.id - o1.id);

}

public static List searchIndexByNum(List list, List card) {

if (card.size() > list.size()) return null;

int[] cardNum = new int[list.size()];

for (int i = 0; i < list.size(); i++) {

cardNum[i] = list.get(i).num;

}

List indexes = new ArrayList<>();

for (int i = 0; i < card.size(); i++) {

if (card.get(i).num > GameConstants.NUM_2) {

final int id = card.get(i).id;

for (int j = 0; j < list.size(); j++) {

if (card.get(i).id == list.get(j).id && !indexes.contains(j)) {

indexes.add(j);

break;

}

}

} else {

for (int j = 0; j < cardNum.length; j++) {

if (card.get(i).num == cardNum[j] && !indexes.contains(j)) {

indexes.add(j);

break;

}

}

}

}

if (indexes.size() != card.size()) return null;

return indexes;

}

//判断花色

public static String Suit(Card card) {

if (card.id==GameConstants.ID_JOKER_1||card.id==GameConstants.ID_JOKER_2){

return "";

}

int suitId = card.id % 4;

switch (suitId) {

case 0:

return "♥";

case 1:

return "♦";

case 2:

return "♣";

case 3:

return "♠";

}

return null;

}

/**

* 5--一分 7--两分 10--三分

* 预估玩家的初始手牌的牌力

* 炸弹分为5点

* 对于7890j炸弹为4(因为容易被拆)

* 对于王炸为8分

* // * 10点--一分 16---两分 20--三分

* // * 对于3456QKA2C的炸弹分依次+1(3炸为5分...C炸为13分)

* 三条2是3分

* 三条是1点

* 对2是2点

* C是4分

* c是3分

*

* @param list 玩家的初始手牌

* @return 玩家的初始手牌的牌力

*/

public static int CardsPower(List list) {

int power = 0;

boolean hasCc = false;

List groups = CardUtils.createGroup(list);

Collections.sort(groups, (o1, o2) -> {

//order by sum desc,num desc

final int o = o2.sum - o1.sum;

if (o != 0) return o;

return o2.num - o1.num;

});

for (CardGroup cardGroup : groups) {

if (cardGroup.sum == 4) {

//大分

// int p = 5;

// switch (cardGroup.num) {

// case GameConstants.NUM_3:

// p += 0;

// case GameConstants.NUM_4:

// p += 1;

// case GameConstants.NUM_5:

// p += 1;

// case GameConstants.NUM_6:

// p += 1;

// break;

// case GameConstants.NUM_7:

// case GameConstants.NUM_8:

// case GameConstants.NUM_9:

// case GameConstants.NUM_10:

// case GameConstants.NUM_J:

// p=-1;

// break;

// case GameConstants.NUM_Q:

// p += 4;

// case GameConstants.NUM_K:

// p += 1;

// case GameConstants.NUM_A:

// p += 1;

// case GameConstants.NUM_2:

// p += 1;

// break;

//

// }

// power+=p;

switch (cardGroup.num) {

case GameConstants.NUM_7:

case GameConstants.NUM_8:

case GameConstants.NUM_9:

case GameConstants.NUM_10:

case GameConstants.NUM_J:

power += 4;

break;

default:

power += 5;

break;

}

} else if (cardGroup.sum == 3) {

if (cardGroup.num == GameConstants.NUM_2) {

power += 3;

} else {

power += 1;

}

} else if (cardGroup.sum == 2) {

if (cardGroup.num == GameConstants.NUM_2) {

power += 2;

} else if (cardGroup.num == GameConstants.NUM_JOKER) {

hasCc = true;

power += 8;

}

}

}

if (hasCc) {

} else if (list.contains(new Card(GameConstants.ID_JOKER_1))) {

power += 3;

} else if (list.contains(new Card(GameConstants.ID_JOKER_2))) {

power += 4;

}

return power;

}

public static int point(List list) {

int power = CardsPower(list);

if (power < 5) {

return 0;

} else if (power < 7) {

return 1;

} else if (power < 10) {

return 2;

} else {

return 3;

}

}

/**

*

* @param left 上家的牌

* @param player 玩家的牌

* @param right 下家的牌

* @param lc 上家是否拿地主牌,先叫

* @param mc 玩家是否拿地主牌,先叫

* @param rc 下家是否拿地主牌,先叫

* @return 返回上家、玩家、下家是否成为地主的List

*/

public static List CallLandlord(List left, List player, List right, boolean lc, boolean mc, boolean rc) {

System.out.println("=====================================叫地主阶段=====================================");

String ss;

if (lc){

ss="上家";

} else if (mc){

ss="玩家";

}else {

ss="下家";

}

System.out.println(ss+"有地主牌" + Suit(specialCard) + specialCard+","+ss+"先叫地主");

List result=new ArrayList<>();

boolean calling = true;

boolean lFirstCall=false;

boolean mFirstCall=false;

boolean rFirstCall=false;

boolean lCall0=false;

boolean mCall0=false;

boolean rCall0=false;

boolean lHasCalled=false;

boolean mHasCalled=false;

boolean rHasCalled=false;

int lPoint = 0;

int mPoint = 0;

int rPoint = 0;

int lastPoint=-1;

while (calling) {

if (lc) {

if (mFirstCall==false&&rFirstCall==false){

lFirstCall=true;

}

System.out.println("===上家叫地主===");

lPoint = point(left);

if (lPoint>lastPoint) {

lHasCalled=true;

switch (lPoint) {

case 0:

System.out.println("不叫");

lastPoint=0;

lCall0=true;

lc=false;

mc = true;

break;

case 1:

System.out.println("1分");

lastPoint = 1;

lc=false;

mc = true;

break;

case 2:

System.out.println("2分");

lastPoint = 2;

lc=false;

mc = true;

break;

case 3:

System.out.println("3分");

lastPoint = 3;

lc=false;

break;

}

}else {

System.out.println("不叫");

lPoint=0;

lCall0=true;

lc=false;

lHasCalled=true;

mc = true;

}

}

if (lastPoint==3||(lCall0&&mCall0&&rCall0)) {

break;

}

else if (lHasCalled&&mHasCalled&&rHasCalled){

break;

}

while (mc) {

if (lFirstCall==false&&rFirstCall==false){

mFirstCall=true;

}

System.out.println("===玩家叫地主===");

Scanner scanner=new Scanner(System.in);

String tip="输入0,不叫 / ";

switch (lastPoint){

case -1:

tip="输入0,不叫 / ";

case 0:

tip=tip+"输入1,1分 / ";

case 1:

tip=tip+"输入2,2分 / ";

case 2:

tip=tip+"输入3,3分 ";

}

System.out.print(tip+" -----> ");

String s = scanner.nextLine();

if (!s.equals("0")&&!s.equals("1")&&!s.equals("2")&&!s.equals("3")){

continue;

}

mPoint = Integer.parseInt(s);

if (mPoint<=lastPoint){

if (mPoint!=0){

continue;

}

}

switch (mPoint) {

case 0:

System.out.println("不叫");

if (lastPoint==0||lastPoint==-1){//此条件为上一次叫或玩家首次不叫,否则玩家不叫不会改变上一次的叫分

lastPoint=0;

}

mCall0=true;

mc=false;

mHasCalled=true;

rc=true;

break;

case 1:

System.out.println("1分");

lastPoint=1;

mc=false;

mHasCalled=true;

rc=true;

break;

case 2:

System.out.println("2分");

lastPoint=2;

mc=false;

mHasCalled=true;

rc=true;

break;

case 3:

System.out.println("3分");

lastPoint = 3;

mc=false;

mHasCalled=true;

break;

}

}

if (lastPoint==3||(lCall0&&mCall0&&rCall0)) {

break;

}

else if (lHasCalled&&mHasCalled&&rHasCalled){

break;

}

if (rc) {

if (mFirstCall==false&&lFirstCall==false){

rFirstCall=true;

}

System.out.println("===下家叫地主===");

rPoint = point(right);

if (rPoint>lastPoint) {

rHasCalled=true;

switch (rPoint) {

case 0:

System.out.println("不叫");

lastPoint=0;

rCall0=true;

rc=false;

lc = true;

break;

case 1:

System.out.println("1分");

lastPoint = 1;

rc=false;

lc = true;

break;

case 2:

System.out.println("2分");

lastPoint = 2;

rc=false;

lc = true;

break;

case 3:

System.out.println("3分");

rc=false;

lc = true;

lastPoint = 3;

break;

}

}else {

System.out.println("不叫");

rPoint=0;

rCall0=true;

lc = true;

rc=false;

rHasCalled=true;

}

}

if (lastPoint==3||(lCall0&&mCall0&&rCall0)) {

calling=false;

}

else if (lHasCalled&&mHasCalled&&rHasCalled){

break;

}

}

if (lCall0&&mCall0&&rCall0){

System.out.println("===========================");

System.out.println("都不叫,则拿地主牌的为地主");

if (lFirstCall){

lPoint=4;

}else if (mFirstCall){

mPoint=4;

}else if (rFirstCall){

rPoint=4;

}

}

boolean LandlordIsL=lPoint>mPoint&&lPoint>rPoint;

boolean LandlordIsM=lPointrPoint;

boolean LandlordIsR=rPoint>mPoint&&lPoint

if (LandlordIsL){

System.out.println("======上家是地主======");

System.out.println("底牌为"+holeCards);

}else if (LandlordIsM){

System.out.println("======玩家是地主======");

System.out.println("底牌为"+holeCards);

}else {

System.out.println("======下家是地主======");

System.out.println("底牌为"+holeCards);

}

result.add(LandlordIsL);

result.add(LandlordIsM);

result.add(LandlordIsR);

System.out.println("===================================================================================");

return result;

}

public static void main(String[] args) {

int sum = 1;//多少副牌

boolean contains345 = true;//是否包含345

licensing(sum, contains345);

System.out.println("地主牌为" + Suit(specialCard) + specialCard);

System.out.println("底牌为"+holeCards);

System.out.println("您的扑克牌:" + player);

System.out.println("上家扑克牌:" + left);

System.out.println("下家扑克牌:" + right);

//测试,显示牌力

// System.out.println(CardsPower(player));

// System.out.println(CardsPower(left));

// System.out.println(CardsPower(right));

boolean playing = true;

boolean toLeft = false;//出牌

boolean toMe = false;//我出

boolean toRight = false;

boolean lCall = left.contains(specialCard);

boolean mCall = player.contains(specialCard);

boolean rCall= right.contains(specialCard);

List booleans = CallLandlord(left, player, right, lCall, mCall, rCall);

boolean l=booleans.get(0);//成为地主并且主动出牌

boolean m=booleans.get(1);

boolean r=booleans.get(2);

if (l){

left.addAll(holeCards);

left.sort((o1, o2) -> o2.id - o1.id);

}else if (m){

player.addAll(holeCards);

player.sort((o1, o2) -> o2.id - o1.id);

}else {

right.addAll(holeCards);

right.sort((o1, o2) -> o2.id - o1.id);

}

boolean isMe = false;//me获胜

Scanner scanner = new Scanner(System.in);

while (playing) {

System.out.println("======================================出牌阶段======================================");

if (l) {

System.out.println("=======================上家主动出牌=======================");

System.out.println("上家当前扑克牌:" + left);

last = CardProduct.createNullType();

Prompt prompt = new Prompt(left, last);

if (prompt.prompt.size() > 0) {

CardProducts cardProducts = CardsFactory.builder(prompt.prompt.get(0));

int index = cardProducts.isGreaterThan(last);

if (index >= 0) {

last = cardProducts.list.get(index);

left.removeAll(last.list);

System.out.println("上家主动出牌:" + last.list);

System.out.println("上家剩余牌数:"+left.size());

if (left.size()==2){

System.out.println("上家就剩2张牌啦!!!");

}else if (left.size()==1){

System.out.println("上家就剩1张牌啦!!!");

}else

if (left.size() == 0) {

System.out.println("=======================================================================");

System.out.println("上家赢了!");

System.out.println("你输啦!");

break;

}

toLeft = false;

toMe = true;

}

}

}

if (toLeft) {

System.out.println("=============上家=================");

System.out.println("上家当前扑克牌:" + left);

Prompt prompt = new Prompt(left, last);

if (prompt.prompt.size() > 0) {

CardProducts cardProducts = CardsFactory.builder(prompt.prompt.get(0));

int index = cardProducts.isGreaterThan(last);

if (index >= 0) {

last = cardProducts.list.get(index);

left.removeAll(last.list);

System.out.println("上家出牌:" + last.list);

System.out.println("上家剩余牌数:"+left.size());

if (left.size()==2){

System.out.println("上家就剩2张牌啦!!!");

}else if (left.size()==1){

System.out.println("上家就剩1张牌啦!!!");

}else

if (left.size() == 0) {

System.out.println("=======================================================================");

System.out.println("上家赢了!");

System.out.println("你输啦!");

break;

}

m = false;

r = false;

l = true;

toLeft = false;

toMe = true;

}

} else {

System.out.println("上家不要");

toLeft = false;

toMe = true;

}

}

while (m) {

System.out.println("=======================玩家主动出牌=======================");

last = CardProduct.createNullType();

System.out.println("您当前的扑克牌:" + player);

System.out.println("请您出牌:(输入?提示 输入,偷看电脑的牌)");

String line = scanner.nextLine();

if (line == null || line.length() == 0) {

continue;

} else if ("?".equals(line)) {

System.out.println("提示:" + new Prompt(player, last).prompt);

continue;

} else if (",".equals(line)) {

System.out.println("上家当前扑克牌:" + left);

System.out.println("下家当前扑克牌:" + right);

continue;

}

List indexes = searchIndexByNum(player, CardUtils.CreateCards(line));

if (indexes == null) {

System.out.println("您输入的扑克牌无效请重新输入");

continue;

}

CardProducts cardProducts = CardsFactory.builder(CardUtils.getCardsByIndexes(player, indexes));

int index = cardProducts.isGreaterThan(last);

// if (index >= 0) {

CardProduct newCardProduct = cardProducts.list.get(index);

last = newCardProduct;

player.removeAll(last.list);

System.out.println("出牌成功:" + last);

System.out.println("玩家剩余牌数:"+player.size());

if (player.size()==2){

System.out.println("上家就剩2张牌啦!!!");

}else if (player.size()==1){

System.out.println("上家就剩1张牌啦!!!");

}else

if (player.size() == 0) {

System.out.println("=======================================================================");

System.out.println("你赢啦!");

isMe = true;

break;

}

toMe = false;

toRight = !toRight;

break;

// } else {

// System.out.println("不符合游戏规则:" + cardProducts);

//

// continue;

// }

}

if (isMe) {

break;

}

while (toMe) {

System.out.println("=============玩家=================");

System.out.println("上一次出牌:" + last);

System.out.println("您当前的扑克牌:" + player);

System.out.println("请您出牌:(输入.不出 输入?提示 输入,偷看电脑的牌)");

String line = scanner.nextLine();

if (line == null || line.length() == 0) {

continue;

} else if (".".equals(line)) {

toMe = false;

toRight = true;

break;

} else if ("?".equals(line)) {

System.out.println("提示:" + new Prompt(player, last).prompt);

continue;

} else if (",".equals(line)) {

System.out.println("上家当前扑克牌:" + left);

System.out.println("下家当前扑克牌:" + right);

continue;

} else {

List indexes = searchIndexByNum(player, CardUtils.CreateCards(line));

if (indexes == null) {

System.out.println("您输入的扑克牌无效请重新输入");

continue;

}

CardProducts cardProducts = CardsFactory.builder(CardUtils.getCardsByIndexes(player, indexes));

int index = cardProducts.isGreaterThan(last);

if (index >= 0) {

CardProduct newCardProduct = cardProducts.list.get(index);

last = newCardProduct;

player.removeAll(last.list);

System.out.println("出牌成功:" + last);

System.out.println("玩家剩余牌数:"+player.size());

if (player.size()==2){

System.out.println("玩家就剩2张牌啦!!!");

}else if (player.size()==1){

System.out.println("玩家就剩1张牌啦!!!");

}else

if (player.size() == 0) {

System.out.println("===================================================================================");

System.out.println("你赢啦!");

isMe = true;

break;

}

l = false;

r = false;

m = true;

toMe = false;

toRight = true;

} else {

System.out.println("不符合游戏规则:" + cardProducts);

continue;

}

}

}

if (isMe) {

break;

}

if (r) {

System.out.println("=======================下家主动出牌=======================");

System.out.println("下家当前扑克牌:" + right);

last = CardProduct.createNullType();

Prompt prompt = new Prompt(right, last);

if (prompt.prompt.size() > 0) {

CardProducts cardProducts = CardsFactory.builder(prompt.prompt.get(0));

int index = cardProducts.isGreaterThan(last);

if (index >= 0) {

last = cardProducts.list.get(index);

right.removeAll(last.list);

System.out.println("下家主动出牌:" + last.list);

System.out.println("下家剩余牌数:"+right.size());

if (right.size()==2){

System.out.println("下家就剩2张牌啦!!!");

}else if (right.size()==1){

System.out.println("上家就剩1张牌啦!!!");

}else

if (right.size() == 0) {

System.out.println("===================================================================================");

System.out.println("下家赢了!");

System.out.println("你输啦!");

break;

}

toRight = false;

toLeft = true;

}

}

}

if (toRight) {

System.out.println("=============下家=================");

System.out.println("下家当前扑克牌:" + right);

Prompt prompt = new Prompt(right, last);

if (prompt.prompt.size() > 0) {

CardProducts cardProducts = CardsFactory.builder(prompt.prompt.get(0));

int index = cardProducts.isGreaterThan(last);

if (index >= 0) {

last = cardProducts.list.get(index);

right.removeAll(last.list);

System.out.println("下家出牌:" + last.list);

System.out.println("下家剩余牌数:"+right.size());

if (right.size()==2){

System.out.println("上家就剩2张牌啦!!!");

}else if (right.size()==1){

System.out.println("上家就剩1张牌啦!!!");

}else

if (right.size() == 0) {

System.out.println("===================================================================================");

System.out.println("下家赢了!");

System.out.println("你输啦!");

break;

}

l = false;

m = false;

r = true;

toRight = false;

toLeft = true;

}

} else {

System.out.println("下家不要");

toRight = false;

toLeft = true;

}

}

}

}

}

Card

package com.ddz;

import java.util.Objects;

/**

* 定义牌的实体类

*

* 第二个构造方法是做测试用的

* 注意:这里用大小写的C代替大小王,0代表10,1和A都能代表A

*/

public class Card {

public final int id;

public final int num;

public Card(int id) {

this.id = id;

num = id / 4;

}

/**

* 这个构造方法是用来做测试用的

*

* @param s

*/

public Card(String s) {

if ("C".equals(s)) {

id = GameConstants.ID_JOKER_2;

num = id / 4;

return;

}

switch (s) {

case "3":

num = GameConstants.NUM_3;

break;

case "4":

num = GameConstants.NUM_4;

break;

case "5":

num = GameConstants.NUM_5;

break;

case "6":

num = GameConstants.NUM_6;

break;

case "7":

num = GameConstants.NUM_7;

break;

case "8":

num = GameConstants.NUM_8;

break;

case "9":

num = GameConstants.NUM_9;

break;

case "0":

num = GameConstants.NUM_10;

break;

case "J":

case "j":

num = GameConstants.NUM_J;

break;

case "Q":

case "q":

num = GameConstants.NUM_Q;

break;

case "K":

case "k":

num = GameConstants.NUM_K;

break;

case "1":

case "A":

case "a":

num = GameConstants.NUM_A;

break;

case "2":

num = GameConstants.NUM_2;

break;

case "c":

num = GameConstants.NUM_JOKER;

break;

default:

throw new RuntimeException();

}

id = num * 4;

}

public boolean is2() {

return num == GameConstants.NUM_2;

}

public boolean isJoker() {

return num == GameConstants.NUM_JOKER;

}

@Override

public String toString() {

switch (num) {

case GameConstants.NUM_3:

return "3";

case GameConstants.NUM_4:

return "4";

case GameConstants.NUM_5:

return "5";

case GameConstants.NUM_6:

return "6";

case GameConstants.NUM_7:

return "7";

case GameConstants.NUM_8:

return "8";

case GameConstants.NUM_9:

return "9";

case GameConstants.NUM_10:

return "10";

case GameConstants.NUM_J:

return "J";

case GameConstants.NUM_Q:

return "Q";

case GameConstants.NUM_K:

return "K";

case GameConstants.NUM_A:

return "A";

case GameConstants.NUM_2:

return "2";

case GameConstants.NUM_JOKER:

if (id == GameConstants.ID_JOKER_1) return "小王";

else return "大王";

}

return null;

}

@Override

public boolean equals(Object o) {

if (this == o) return true;

if (o == null || getClass() != o.getClass()) return false;

Card card = (Card) o;

return id == card.id && num == card.num;

}

@Override

public int hashCode() {

return Objects.hash(id, num);

}

}

CardGroup

package com.ddz;

import java.util.ArrayList;

import java.util.List;

/**

* 结果类和结果集

* 结果类

*/

public class CardProduct {

public final List list;

public final int type;

public final Card maxCard;

public final List group;

public CardProduct(List list, int type, Card maxCard, List group) {

this.list = list;

this.type = type;

this.maxCard = maxCard;

this.group = group;

}

/*

public boolean isGreaterThan(CardProduct cardProduct) {

if (type != GameConstants.TYPE_ERROR && type != GameConstants.TYPE_NULL

&& cardProduct.type == GameConstants.TYPE_NULL) {

return true;

} else if (type == GameConstants.TYPE_BOOM) {

if (cardProduct.type == GameConstants.TYPE_BOOM ) {//炸弹大小&&cardProduct.maxCard

if (maxCard.num>cardProduct.maxCard.num){

return true;

}else {

return false;

}

} else return true;

} else if (type == cardProduct.type && list.size() == cardProduct.list.size()) {//大小

if (maxCard.num>cardProduct.maxCard.num){

return true;

}else {

return false;

}

}

return false;

}

*/

public boolean isGreaterThan(CardProduct cardProduct) {

if (type != GameConstants.TYPE_ERROR && type != GameConstants.TYPE_NULL

&& cardProduct.type == GameConstants.TYPE_NULL) {

return true;

} else if (type == GameConstants.TYPE_BOOM) {

if (cardProduct.type == GameConstants.TYPE_BOOM) {

if (list.get(0).isJoker() && cardProduct.list.get(0).isJoker()) {

//王炸 炸 王炸

if (list.size() == cardProduct.list.size()) {

int bigJokerSum1 = 0, bigJokerSum2 = 0;

for (Card card : list) {

if (card.id == GameConstants.ID_JOKER_2) bigJokerSum1++;

}

for (Card card : cardProduct.list) {

if (card.id == GameConstants.ID_JOKER_2) bigJokerSum2++;

}

return bigJokerSum1 > bigJokerSum2;

} else return list.size() > cardProduct.list.size();

} else if (list.get(0).isJoker() && !cardProduct.list.get(0).isJoker()) {

//王炸 炸 炸弹

return list.size() * 2 >= cardProduct.list.size();

} else if (!list.get(0).isJoker() && cardProduct.list.get(0).isJoker()) {

//炸弹 炸 王炸

return list.size() > cardProduct.list.size() * 2;

} else if (!list.get(0).isJoker() && !cardProduct.list.get(0).isJoker()) {

//炸弹 炸 炸弹

if (list.size() > cardProduct.list.size()) return true;

else if (list.size() == cardProduct.list.size()) {

return list.get(0).num > cardProduct.list.get(0).num;

} else return false;

}

} else return true;

} else if (type == cardProduct.type && list.size() == cardProduct.list.size()) {

if (type == GameConstants.TYPE_1 && maxCard.num == GameConstants.NUM_JOKER && cardProduct.maxCard.num == GameConstants.NUM_JOKER) {

//由于大小王的num都是相同的 所以比较大小王的话要对比id

return maxCard.id > cardProduct.maxCard.id;

} else {

return maxCard.num > cardProduct.maxCard.num;

}

}

return false;

}

private String typeToString() {

switch (type) {

case GameConstants.TYPE_ERROR:

return "错误";

case GameConstants.TYPE_NULL:

return "无";

case GameConstants.TYPE_1:

return "单牌";

case GameConstants.TYPE_22:

return "对子";

case GameConstants.TYPE_333:

return "三个";

case GameConstants.TYPE_BOOM:

return "炸弹";

case GameConstants.TYPE_3331:

return "三带一";

case GameConstants.TYPE_33322:

return "三带一对";

case GameConstants.TYPE_444412:

return "四带二";

case GameConstants.TYPE_44441122:

return "四带两对";

case GameConstants.TYPE_34567:

return "顺子";

case GameConstants.TYPE_334455:

return "连对";

case GameConstants.TYPE_333444:

return "飞机";

case GameConstants.TYPE_33344412:

return "飞机带单牌";

case GameConstants.TYPE_3334441122:

return "飞机带对子";

}

return "未知";

}

@Override

public String toString() {

return "CardProduct{" +

"list=" + list +

", type=" + typeToString() +

", maxCard=" + maxCard +

", len=" + list.size() +

", group=" + group +

'}';

}

public static CardProduct createNullType() {

return new CardProduct(new ArrayList<>(), GameConstants.TYPE_NULL, null, null);

}

}

CardProducts

package com.ddz;

import java.util.ArrayList;

import java.util.List;

/**

* 结果类和结果集

* 结果类

*/

public class CardProduct {

public final List list;

public final int type;

public final Card maxCard;

public final List group;

public CardProduct(List list, int type, Card maxCard, List group) {

this.list = list;

this.type = type;

this.maxCard = maxCard;

this.group = group;

}

/*

public boolean isGreaterThan(CardProduct cardProduct) {

if (type != GameConstants.TYPE_ERROR && type != GameConstants.TYPE_NULL

&& cardProduct.type == GameConstants.TYPE_NULL) {

return true;

} else if (type == GameConstants.TYPE_BOOM) {

if (cardProduct.type == GameConstants.TYPE_BOOM ) {//炸弹大小&&cardProduct.maxCard

if (maxCard.num>cardProduct.maxCard.num){

return true;

}else {

return false;

}

} else return true;

} else if (type == cardProduct.type && list.size() == cardProduct.list.size()) {//大小

if (maxCard.num>cardProduct.maxCard.num){

return true;

}else {

return false;

}

}

return false;

}

*/

public boolean isGreaterThan(CardProduct cardProduct) {

if (type != GameConstants.TYPE_ERROR && type != GameConstants.TYPE_NULL

&& cardProduct.type == GameConstants.TYPE_NULL) {

return true;

} else if (type == GameConstants.TYPE_BOOM) {

if (cardProduct.type == GameConstants.TYPE_BOOM) {

if (list.get(0).isJoker() && cardProduct.list.get(0).isJoker()) {

//王炸 炸 王炸

if (list.size() == cardProduct.list.size()) {

int bigJokerSum1 = 0, bigJokerSum2 = 0;

for (Card card : list) {

if (card.id == GameConstants.ID_JOKER_2) bigJokerSum1++;

}

for (Card card : cardProduct.list) {

if (card.id == GameConstants.ID_JOKER_2) bigJokerSum2++;

}

return bigJokerSum1 > bigJokerSum2;

} else return list.size() > cardProduct.list.size();

} else if (list.get(0).isJoker() && !cardProduct.list.get(0).isJoker()) {

//王炸 炸 炸弹

return list.size() * 2 >= cardProduct.list.size();

} else if (!list.get(0).isJoker() && cardProduct.list.get(0).isJoker()) {

//炸弹 炸 王炸

return list.size() > cardProduct.list.size() * 2;

} else if (!list.get(0).isJoker() && !cardProduct.list.get(0).isJoker()) {

//炸弹 炸 炸弹

if (list.size() > cardProduct.list.size()) return true;

else if (list.size() == cardProduct.list.size()) {

return list.get(0).num > cardProduct.list.get(0).num;

} else return false;

}

} else return true;

} else if (type == cardProduct.type && list.size() == cardProduct.list.size()) {

if (type == GameConstants.TYPE_1 && maxCard.num == GameConstants.NUM_JOKER && cardProduct.maxCard.num == GameConstants.NUM_JOKER) {

//由于大小王的num都是相同的 所以比较大小王的话要对比id

return maxCard.id > cardProduct.maxCard.id;

} else {

return maxCard.num > cardProduct.maxCard.num;

}

}

return false;

}

private String typeToString() {

switch (type) {

case GameConstants.TYPE_ERROR:

return "错误";

case GameConstants.TYPE_NULL:

return "无";

case GameConstants.TYPE_1:

return "单牌";

case GameConstants.TYPE_22:

return "对子";

case GameConstants.TYPE_333:

return "三个";

case GameConstants.TYPE_BOOM:

return "炸弹";

case GameConstants.TYPE_3331:

return "三带一";

case GameConstants.TYPE_33322:

return "三带一对";

case GameConstants.TYPE_444412:

return "四带二";

case GameConstants.TYPE_44441122:

return "四带两对";

case GameConstants.TYPE_34567:

return "顺子";

case GameConstants.TYPE_334455:

return "连对";

case GameConstants.TYPE_333444:

return "飞机";

case GameConstants.TYPE_33344412:

return "飞机带单牌";

case GameConstants.TYPE_3334441122:

return "飞机带对子";

}

return "未知";

}

@Override

public String toString() {

return "CardProduct{" +

"list=" + list +

", type=" + typeToString() +

", maxCard=" + maxCard +

", len=" + list.size() +

", group=" + group +

'}';

}

public static CardProduct createNullType() {

return new CardProduct(new ArrayList<>(), GameConstants.TYPE_NULL, null, null);

}

}

CardsFactory

package com.ddz;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import java.util.stream.Collectors;

/**

* 判断玩家出的是什么牌 是否合法

*

*

*/

public class CardsFactory {

private final List list;//排序方式为 order by id desc

private final CardProducts products;

private final List groups;//排序方式为 order by sum desc,num desc

private CardsFactory(List list) {

this.list = list;

this.list.sort((o1, o2) -> o2.id - o1.id);

products = new CardProducts();

groups = CardUtils.createGroup(list);

Collections.sort(groups, (o1, o2) -> {

//order by sum desc,num desc

final int o = o2.sum - o1.sum;

if (o != 0) return o;

return o2.num - o1.num;

});

if (is1()) return;

if (is22()) return;

if (is333()) return;

if (isBoom()) return;

if (is3331()) return;

if (is33322()) return;

if (is34567()) return;

if (is334455()) return;

//33334444可被分为飞机和四带两对

boolean flag = false;

if (is444412()) flag = true;

if (is44441122()) flag = true;

if (is333444()) flag = true;

if (is33344412()) flag = true;

if (is3334441122()) flag = true;

if (!flag) {

List sorted = new ArrayList<>(list);

products.add(new CardProduct(sorted, GameConstants.TYPE_ERROR, list.get(0), groups));

}

}

/**

* 是否全部牌的num都一样

*

* @return

*/

public boolean isEqualsAll() {

return groups.size() == 1;

}

public boolean is1() {

if (list.size() == 1) {

List sorted = new ArrayList<>(list);

products.add(new CardProduct(sorted, GameConstants.TYPE_1, list.get(0), groups));

return true;

}

return false;

}

public boolean is22() {

if (list.size() == 2 && !list.get(0).isJoker() && isEqualsAll()) {

List sorted = new ArrayList<>(list);

products.add(new CardProduct(sorted, GameConstants.TYPE_22, list.get(0), groups));

return true;

}

return false;

}

public boolean is333() {

if (list.size() == 3 && !list.get(0).isJoker() && isEqualsAll()) {

List sorted = new ArrayList<>(list);

products.add(new CardProduct(sorted, GameConstants.TYPE_333, list.get(0), groups));

return true;

}

return false;

}

public boolean isBoom() {

if (list.size() >= 2) {

if (groups.size() == 1) {

if (groups.get(0).num == GameConstants.NUM_JOKER && groups.get(0).sum >= 2 || groups.get(0).sum >= 4) {

List sorted = new ArrayList<>(list);

products.add(new CardProduct(sorted, GameConstants.TYPE_BOOM, list.get(0), groups));

return true;

}

}

}

return false;

}

public boolean is3331() {

if (list.size() == 4) {

if (groups.get(0).sum == 3 && groups.get(0).num != GameConstants.NUM_JOKER) {

List sorted = new ArrayList<>(list);

CardUtils.moveToEnd(sorted, groups.get(1).num, groups.get(1).sum);

products.add(new CardProduct(sorted, GameConstants.TYPE_3331, sorted.get(0), groups));

return true;

}

}

return false;

}

public boolean is33322() {

if (list.size() == 5) {

if (CardUtils.indexOfByNum(list, GameConstants.NUM_JOKER) < 0)

if (groups.get(0).sum == 3 && groups.get(1).sum == 2 && groups.get(0).num != GameConstants.NUM_JOKER) {

List sorted = new ArrayList<>(list);

CardUtils.moveToEnd(sorted, groups.get(1).num, groups.get(1).sum);

products.add(new CardProduct(sorted, GameConstants.TYPE_33322, sorted.get(0), groups));

return true;

}

}

return false;

}

public boolean is444412() {

if (list.size() == 6) {

if (groups.get(0).sum >= 4) {

List sorted = new ArrayList<>(list);

CardUtils.moveToHead(sorted, groups.get(0).num, 4);

products.add(new CardProduct(sorted, GameConstants.TYPE_444412, sorted.get(0), groups));

return true;

}

}

return false;

}

public boolean is44441122() {

if (list.size() == 8) {

List temp = new ArrayList<>(groups);

temp.sort((o1, o2) -> o2.num - o1.num);//按num逆序

CardGroup ge4 = null;//找到num最大 且sum>=4的牌

for (CardGroup cardGroup : temp) {

if (cardGroup.sum >= 4) {

ge4 = cardGroup;

break;

}

}

if (ge4 != null) {

for (CardGroup cardGroup : temp) {

if (cardGroup.sum % 2 != 0) return false;

}

List sorted = new ArrayList<>(list);

CardUtils.moveToHead(sorted, ge4.num, 4);

products.add(new CardProduct(sorted, GameConstants.TYPE_44441122, sorted.get(0), groups));

return true;

}

}

return false;

}

public boolean is34567() {

if (list.size() >= 5) {

if (list.get(0).id < GameConstants.ID_2_1) {

for (int i = 0, len = list.size() - 1; i < len; i++) {

Card card1 = list.get(i);

Card card2 = list.get(i + 1);

if (card1.num - card2.num != 1) return false;

}

List sorted = new ArrayList<>(list);

products.add(new CardProduct(sorted, GameConstants.TYPE_34567, sorted.get(0), groups));

return true;

}

}

return false;

}

public boolean is334455() {

if (list.size() >= 6 && list.get(0).id < GameConstants.ID_2_1) {

if (groups.get(0).num < GameConstants.NUM_2 && groups.get(0).sum == 2) {

for (int i = 0, len = groups.size() - 1; i < len; i++) {

if (groups.get(i).num - groups.get(i + 1).num != 1 || groups.get(i + 1).sum != 2)

return false;

}

List sorted = new ArrayList<>(list);

products.add(new CardProduct(sorted, GameConstants.TYPE_334455, sorted.get(0), groups));

return true;

}

}

return false;

}

public boolean is333444() {

if (list.size() % 3 == 0 && list.size() >= 6 && groups.size() >= 2) {

if (groups.get(0).num < GameConstants.NUM_2 && groups.get(0).sum == 3) {

for (int i = 0, len = groups.size() - 1; i < len; i++) {

if (groups.get(i).num - groups.get(i + 1).num != 1 || groups.get(i + 1).sum != 3) return false;

}

List sorted = new ArrayList<>(list);

products.add(new CardProduct(sorted, GameConstants.TYPE_333444, sorted.get(0), groups));

return true;

}

}

return false;

}

public boolean is33344412() {

if (list.size() % 4 == 0 && list.size() >= 8) {

List ge3 = groups.stream().filter(cardGroup -> cardGroup.sum >= 3).sorted((o1, o2) -> o2.num - o1.num).collect(Collectors.toList());

ArrayList> base = new ArrayList<>();//可能不止一个三连 如333 444 666 777 888 999 000 JJJ

ArrayList continuous = new ArrayList<>();

for (int i = 0, len = ge3.size() - 1; i < len; i++) {

final CardGroup group1 = ge3.get(i);

final CardGroup group2 = ge3.get(i + 1);

if (group1.num - group2.num == 1 && group1.num < GameConstants.NUM_2) {

if (!continuous.contains(group1))

continuous.add(group1);

continuous.add(group2);

if (i == len - 1) base.add(continuous);

} else {

base.add(continuous);

continuous = new ArrayList<>();

}

}

for (ArrayList plane : base) {

while (plane.size() >= 2) {

if (plane.size() * 4 == list.size()) {

List sorted = new ArrayList<>(list);

for (int i = plane.size() - 1; i >= 0; i--) {

CardUtils.moveToHead(sorted, plane.get(i).num, 3);

}

products.add(new CardProduct(sorted, GameConstants.TYPE_33344412, sorted.get(0), groups));

return true;

} else {

plane.remove(plane.size() - 1);//切一节飞机尾

}

}

}

}

return false;

}

public boolean is3334441122() {

if (list.size() % 5 == 0 && list.size() >= 10) {

List ge3 = groups.stream().filter(cardGroup -> cardGroup.sum >= 3).sorted((o1, o2) -> o2.num - o1.num).collect(Collectors.toList());

ArrayList> base = new ArrayList<>();//可能不止一个三连 如333 444 666 777 888 999 000 JJJ

ArrayList continuous = new ArrayList<>();

for (int i = 0, len = ge3.size() - 1; i < len; i++) {

final CardGroup group1 = ge3.get(i);

final CardGroup group2 = ge3.get(i + 1);

if (group1.num - group2.num == 1 && group1.num < GameConstants.NUM_2) {

if (!continuous.contains(group1))

continuous.add(group1);

continuous.add(group2);

if (i == len - 1) base.add(continuous);

} else {

base.add(continuous);

continuous = new ArrayList<>();

}

}

for (ArrayList plane : base) {

int cut = 0;

while (plane.size() - cut >= 2) {

if ((plane.size() - cut) * 5 == list.size()) {

for (int i = 0; i < cut + 1; i++) {

List temp = plane.subList(i, i + plane.size() - cut);

//在this.groups里找到temp里存在的元素 并让他的sum-3 意思大概就是把当机身的牌从this.groups取走3张

List diff = this.groups.stream()

.map(cardGroup -> {

if (temp.stream().anyMatch(group -> group.num == cardGroup.num))

return new CardGroup(cardGroup.num, cardGroup.sum - 3);//为了不影响到原来的集合 这里选择new一个

else return cardGroup;

})

.collect(Collectors.toList());

//判断剩下的牌的sum是否都是偶数

if (diff.stream().allMatch(cardGroup -> cardGroup.sum % 2 == 0)) {

List sorted = new ArrayList<>(list);

for (int j = temp.size() - 1; j >= 0; j--) {

CardUtils.moveToHead(sorted, temp.get(j).num, 3);

}

products.add(new CardProduct(sorted, GameConstants.TYPE_3334441122, sorted.get(0), groups));

return true;

}

}

}

cut++;

}

}

}

return false;

}

public static CardProducts builder(List list) {

return new CardsFactory(list).products;

}

/**

* 测试用

*

* @param cards

* @return

*/

public static CardProducts builder(String cards) {

List list = new ArrayList<>();

for (int i = 0; i < cards.length(); i++) {

String s = cards.substring(i, i + 1);

if (!" ".equals(s)) list.add(new Card(s));

}

return builder(list);

}

}

CardTest

package com.ddz;

import java.util.ArrayList;

import java.util.List;

/**

* 测试类

*/

public class CardTest {

private static void typeTest() {

System.out.println("----------------------------------单排----------------------------------");

System.out.println(CardsFactory.builder("3"));

System.out.println(CardsFactory.builder("4"));

System.out.println(CardsFactory.builder("5"));

System.out.println(CardsFactory.builder("6"));

System.out.println(CardsFactory.builder("7"));

System.out.println(CardsFactory.builder("8"));

System.out.println(CardsFactory.builder("9"));

System.out.println(CardsFactory.builder("0"));

System.out.println(CardsFactory.builder("J"));

System.out.println(CardsFactory.builder("Q"));

System.out.println(CardsFactory.builder("K"));

System.out.println(CardsFactory.builder("A"));

System.out.println(CardsFactory.builder("2"));

System.out.println(CardsFactory.builder("C"));

System.out.println("----------------------------------对子----------------------------------");

System.out.println(CardsFactory.builder("33"));

System.out.println(CardsFactory.builder("44"));

System.out.println(CardsFactory.builder("55"));

System.out.println(CardsFactory.builder("66"));

System.out.println(CardsFactory.builder("77"));

System.out.println(CardsFactory.builder("88"));

System.out.println(CardsFactory.builder("99"));

System.out.println(CardsFactory.builder("00"));

System.out.println(CardsFactory.builder("JJ"));

System.out.println(CardsFactory.builder("QQ"));

System.out.println(CardsFactory.builder("KK"));

System.out.println(CardsFactory.builder("AA"));

System.out.println(CardsFactory.builder("22"));

System.out.println(CardsFactory.builder("CC") + " 炸弹");

System.out.println("----------------------------------3个----------------------------------");

System.out.println(CardsFactory.builder("333"));

System.out.println(CardsFactory.builder("444"));

System.out.println(CardsFactory.builder("555"));

System.out.println(CardsFactory.builder("666"));

System.out.println(CardsFactory.builder("777"));

System.out.println(CardsFactory.builder("888"));

System.out.println(CardsFactory.builder("999"));

System.out.println(CardsFactory.builder("000"));

System.out.println(CardsFactory.builder("JJJ"));

System.out.println(CardsFactory.builder("QQQ"));

System.out.println(CardsFactory.builder("KKK"));

System.out.println(CardsFactory.builder("AAA"));

System.out.println(CardsFactory.builder("222"));

System.out.println(CardsFactory.builder("CCC") + " 炸弹");

System.out.println("----------------------------------4个----------------------------------");

System.out.println(CardsFactory.builder("3333"));

System.out.println(CardsFactory.builder("4444"));

System.out.println(CardsFactory.builder("5555"));

System.out.println(CardsFactory.builder("6666"));

System.out.println(CardsFactory.builder("7777"));

System.out.println(CardsFactory.builder("8888"));

System.out.println(CardsFactory.builder("9999"));

System.out.println(CardsFactory.builder("0000"));

System.out.println(CardsFactory.builder("JJJJ"));

System.out.println(CardsFactory.builder("QQQQ"));

System.out.println(CardsFactory.builder("KKKK"));

System.out.println(CardsFactory.builder("AAAA"));

System.out.println(CardsFactory.builder("2222"));

System.out.println(CardsFactory.builder("CCCC"));

System.out.println("----------------------------------5个----------------------------------");

System.out.println(CardsFactory.builder("33333"));

System.out.println(CardsFactory.builder("44444"));

System.out.println(CardsFactory.builder("55555"));

System.out.println(CardsFactory.builder("66666"));

System.out.println(CardsFactory.builder("77777"));

System.out.println(CardsFactory.builder("88888"));

System.out.println(CardsFactory.builder("99999"));

System.out.println(CardsFactory.builder("00000"));

System.out.println(CardsFactory.builder("JJJJJ"));

System.out.println(CardsFactory.builder("QQQQQ"));

System.out.println(CardsFactory.builder("KKKKK"));

System.out.println(CardsFactory.builder("AAAAA"));

System.out.println(CardsFactory.builder("22222"));

System.out.println(CardsFactory.builder("CCCCC"));

System.out.println("----------------------------------6个----------------------------------");

System.out.println(CardsFactory.builder("333333"));

System.out.println(CardsFactory.builder("444444"));

System.out.println(CardsFactory.builder("555555"));

System.out.println(CardsFactory.builder("666666"));

System.out.println(CardsFactory.builder("777777"));

System.out.println(CardsFactory.builder("888888"));

System.out.println(CardsFactory.builder("999999"));

System.out.println(CardsFactory.builder("000000"));

System.out.println(CardsFactory.builder("JJJJJJ"));

System.out.println(CardsFactory.builder("QQQQQQ"));

System.out.println(CardsFactory.builder("KKKKKK"));

System.out.println(CardsFactory.builder("AAAAAA"));

System.out.println(CardsFactory.builder("222222"));

System.out.println(CardsFactory.builder("CCCCCC"));

System.out.println("----------------------------------7个----------------------------------");

System.out.println(CardsFactory.builder("3333333"));

System.out.println(CardsFactory.builder("4444444"));

System.out.println(CardsFactory.builder("5555555"));

System.out.println(CardsFactory.builder("6666666"));

System.out.println(CardsFactory.builder("7777777"));

System.out.println(CardsFactory.builder("8888888"));

System.out.println(CardsFactory.builder("9999999"));

System.out.println(CardsFactory.builder("0000000"));

System.out.println(CardsFactory.builder("JJJJJJJ"));

System.out.println(CardsFactory.builder("QQQQQQQ"));

System.out.println(CardsFactory.builder("KKKKKKK"));

System.out.println(CardsFactory.builder("AAAAAAA"));

System.out.println(CardsFactory.builder("2222222"));

System.out.println(CardsFactory.builder("CCCCCCC"));

System.out.println("----------------------------------8个----------------------------------");

System.out.println(CardsFactory.builder("33333333"));

System.out.println(CardsFactory.builder("44444444"));

System.out.println(CardsFactory.builder("55555555"));

System.out.println(CardsFactory.builder("66666666"));

System.out.println(CardsFactory.builder("77777777"));

System.out.println(CardsFactory.builder("88888888"));

System.out.println(CardsFactory.builder("99999999"));

System.out.println(CardsFactory.builder("00000000"));

System.out.println(CardsFactory.builder("JJJJJJJJ"));

System.out.println(CardsFactory.builder("QQQQQQQQ"));

System.out.println(CardsFactory.builder("KKKKKKKK"));

System.out.println(CardsFactory.builder("AAAAAAAA"));

System.out.println(CardsFactory.builder("22222222"));

System.out.println(CardsFactory.builder("CCCCCCCC"));

System.out.println("----------------------------------三带一----------------------------------");

System.out.println(CardsFactory.builder("3331"));

System.out.println(CardsFactory.builder("4442"));

System.out.println(CardsFactory.builder("5553"));

System.out.println(CardsFactory.builder("6664"));

System.out.println(CardsFactory.builder("7775"));

System.out.println(CardsFactory.builder("8886"));

System.out.println(CardsFactory.builder("9997"));

System.out.println(CardsFactory.builder("0008"));

System.out.println(CardsFactory.builder("JJJ9"));

System.out.println(CardsFactory.builder("QQQ0"));

System.out.println(CardsFactory.builder("KKKJ"));

System.out.println(CardsFactory.builder("AAAQ"));

System.out.println(CardsFactory.builder("222K"));

System.out.println(CardsFactory.builder("CCC1") + " 错误");

System.out.println("----------------------------------三带一对----------------------------------");

System.out.println(CardsFactory.builder("33311"));

System.out.println(CardsFactory.builder("44422"));

System.out.println(CardsFactory.builder("55533"));

System.out.println(CardsFactory.builder("66644"));

System.out.println(CardsFactory.builder("77755"));

System.out.println(CardsFactory.builder("88866"));

System.out.println(CardsFactory.builder("99977"));

System.out.println(CardsFactory.builder("00088"));

System.out.println(CardsFactory.builder("JJJ99"));

System.out.println(CardsFactory.builder("QQQ00"));

System.out.println(CardsFactory.builder("KKKJJ"));

System.out.println(CardsFactory.builder("AAAQQ"));

System.out.println(CardsFactory.builder("222KK"));

System.out.println(CardsFactory.builder("CCC11") + " 错误");

System.out.println(CardsFactory.builder("JcJCJ") + " 不能带对王");

System.out.println(CardsFactory.builder("222K1") + " 不是对子");

System.out.println("----------------------------------四带二----------------------------------");

System.out.println(CardsFactory.builder("444412"));

System.out.println(CardsFactory.builder("444466"));

System.out.println(CardsFactory.builder("444445"));

System.out.println(CardsFactory.builder("4444Cc"));

System.out.println("----------------------------------四带两对----------------------------------");

System.out.println(CardsFactory.builder("44441122"));

System.out.println(CardsFactory.builder("44446666"));

System.out.println(CardsFactory.builder("44444455"));

System.out.println(CardsFactory.builder("444466Cc"));

System.out.println(CardsFactory.builder("4444Cc33"));

System.out.println("----------------------------------顺子----------------------------------");

System.out.println(CardsFactory.builder("34567"));

System.out.println("----------------------------------连对----------------------------------");

System.out.println(CardsFactory.builder("334455"));

System.out.println("----------------------------------飞机----------------------------------");

System.out.println(CardsFactory.builder("333444"));

System.out.println("----------------------------------飞机带单排----------------------------------");

System.out.println(CardsFactory.builder("33 555666777 7"));

System.out.println(CardsFactory.builder("333444555666"));

System.out.println(CardsFactory.builder("33334444") + "飞机/四带两对");

System.out.println(CardsFactory.builder("33334445"));

System.out.println(CardsFactory.builder("33344445"));

System.out.println(CardsFactory.builder("33344455"));

System.out.println(CardsFactory.builder("33344456"));

System.out.println(CardsFactory.builder("333444555777"));

System.out.println(CardsFactory.builder("333555666777"));

System.out.println(CardsFactory.builder("222555666777"));

System.out.println(CardsFactory.builder("333444555444"));

System.out.println(CardsFactory.builder("222111KKKQQQ"));

System.out.println(CardsFactory.builder("333444555666"));

System.out.println(CardsFactory.builder("333 555 666 777 888 999 000 JJJ"));

System.out.println(CardsFactory.builder("333 555 666 777 888 999 000 QQQ"));

System.out.println(CardsFactory.builder("633 555 666 777 888 999 000 QQQ"));

System.out.println(CardsFactory.builder("333 444 666 777 888 999 000 JJJ"));

System.out.println(CardsFactory.builder("JJJ 000 888 777 666 555 444 333"));

System.out.println(CardsFactory.builder("222AAAKKK JJJ000999888777666555444333"));

System.out.println(CardsFactory.builder("333 444 555 666 777 888 999 000 JJJ QQQ KKK AAA"));

System.out.println("---------------------------------飞机带对子---------------------------------");

System.out.println(CardsFactory.builder("334445556667777") + " 头切");

System.out.println(CardsFactory.builder("334444555666777") + " 尾切");

System.out.println(CardsFactory.builder("334455 555666777"));

System.out.println(CardsFactory.builder("384455 555666777") + " 错误");

System.out.println(CardsFactory.builder("33334444455566677777") + " 飞机带单双");

System.out.println(CardsFactory.builder("444555666777888999 9447733") + " 飞机带单双");

System.out.println(CardsFactory.builder("33334444 555666777888"));

System.out.println(CardsFactory.builder("33334444 666777888999"));

System.out.println(CardsFactory.builder("333444555666 88889999"));

System.out.println(CardsFactory.builder("3333344455"));

System.out.println(CardsFactory.builder("3334444455"));

System.out.println(CardsFactory.builder("3344444555"));

}

private static void outCardTest() {

//TODO 55554444压44445566和33334445

//TODO 444555666777 压 333444555777

System.out.println("---------------------------------成功区 下面不能出现-1---------------------------------");

System.out.println(CardsFactory.builder("C").isGreaterThan(CardsFactory.builder("c").list.get(0)));

System.out.println(CardsFactory.builder("C").isGreaterThan(CardsFactory.builder("2").list.get(0)));

System.out.println(CardsFactory.builder("c").isGreaterThan(CardsFactory.builder("1").list.get(0)));

System.out.println(CardsFactory.builder("77").isGreaterThan(CardsFactory.builder("66").list.get(0)));

System.out.println(CardsFactory.builder("CC").isGreaterThan(CardsFactory.builder("Cc").list.get(0)));

System.out.println(CardsFactory.builder("Cc").isGreaterThan(CardsFactory.builder("cc").list.get(0)));

System.out.println(CardsFactory.builder("CC").isGreaterThan(CardsFactory.builder("cc").list.get(0)));

System.out.println(CardsFactory.builder("55554444").isGreaterThan(CardsFactory.builder("44445656").list.get(0)));

System.out.println(CardsFactory.builder("55554444").isGreaterThan(CardsFactory.builder("33334445").list.get(0)));

System.out.println(CardsFactory.builder("444555666777").isGreaterThan(CardsFactory.builder("333444555777").list.get(0)));

System.out.println("---------------------------------失败区 下面只能出现-1---------------------------------");

//黑桃6压方块6测试

Card card4 = new Card(GameConstants.ID_6_4);

Card card1 = new Card(GameConstants.ID_6_1);

List list1 = new ArrayList<>();

list1.add(card4);

List list2 = new ArrayList<>();

list2.add(card1);

System.out.println(CardsFactory.builder(list1).isGreaterThan(CardsFactory.builder(list2).list.get(0)));

System.out.println(CardsFactory.builder(list2).isGreaterThan(CardsFactory.builder(list1).list.get(0)));

System.out.println(CardsFactory.builder("6").isGreaterThan(CardsFactory.builder("6").list.get(0)));

System.out.println(CardsFactory.builder("66").isGreaterThan(CardsFactory.builder("66").list.get(0)));

System.out.println(CardsFactory.builder("Cc").isGreaterThan(CardsFactory.builder("cC").list.get(0)));

}

private static void prompt() {

System.out.println("----------------------------------单牌----------------------------------");

//单独提示 小王大王 优先提示单牌 出小王提示大王

System.out.println(new Prompt(CardUtils.CreateCards("34567890JQKA2cC"), CardsFactory.builder("5").list.get(0)));

System.out.println(new Prompt(CardUtils.CreateCards("3300JQQKA22Cc"), CardsFactory.builder("5").list.get(0)));

System.out.println(new Prompt(CardUtils.CreateCards("Cc2k6"), CardsFactory.builder("A").list.get(0)));

System.out.println(new Prompt(CardUtils.CreateCards("Cc654"), CardsFactory.builder("c").list.get(0)));

System.out.println(new Prompt(CardUtils.CreateCards("Cc654"), CardsFactory.builder("C").list.get(0)));

System.out.println("----------------------------------对子----------------------------------");

System.out.println(new Prompt(CardUtils.CreateCards("3344556677889900JJQQKKA22ccCC"), CardsFactory.builder("55").list.get(0)));

System.out.println(new Prompt(CardUtils.CreateCards("8888000JJQQQKKKKAA222cCC"), CardsFactory.builder("55").list.get(0)));

System.out.println("----------------------------------三个----------------------------------");

System.out.println(new Prompt(CardUtils.CreateCards("77788899"), CardsFactory.builder("888").list.get(0)));

System.out.println(new Prompt(CardUtils.CreateCards("777888999"), CardsFactory.builder("888").list.get(0)));

System.out.println(new Prompt(CardUtils.CreateCards("77778888000ccc"), CardsFactory.builder("888").list.get(0)));

System.out.println(new Prompt(CardUtils.CreateCards("77778888000CCC"), CardsFactory.builder("888").list.get(0)));

System.out.println("----------------------------------炸弹----------------------------------");

System.out.println("----------------------------------三带一----------------------------------");

System.out.println(new Prompt(CardUtils.CreateCards("555666c"), CardsFactory.builder("4441").list.get(0)));

System.out.println(new Prompt(CardUtils.CreateCards("CCC6"), CardsFactory.builder("4441").list.get(0)));

System.out.println(new Prompt(CardUtils.CreateCards("33334444555666777"), CardsFactory.builder("4441").list.get(0)));

System.out.println(new Prompt(CardUtils.CreateCards("333456cccCCC777"), CardsFactory.builder("4441").list.get(0)));

System.out.println("----------------------------------三带一对----------------------------------");

System.out.println(new Prompt(CardUtils.CreateCards("555666cC"), CardsFactory.builder("44411").list.get(0)));

System.out.println(new Prompt(CardUtils.CreateCards("33334444555666777"), CardsFactory.builder("44422").list.get(0)));

System.out.println(new Prompt(CardUtils.CreateCards("333445566cccCCC777"), CardsFactory.builder("444133").list.get(0)));

System.out.println(new Prompt(CardUtils.CreateCards("333445566cccCCC777"), CardsFactory.builder("4441CC").list.get(0)));

System.out.println("----------------------------------四带二----------------------------------");

System.out.println(new Prompt(CardUtils.CreateCards("44446666"), CardsFactory.builder("555512").list.get(0)));

System.out.println("----------------------------------四带两队----------------------------------");

System.out.println(new Prompt(CardUtils.CreateCards("444455556666"), CardsFactory.builder("33334444").list.get(0)));

System.out.println(new Prompt(CardUtils.CreateCards("4444455556666"), CardsFactory.builder("33334444").list.get(0)));//TODO

System.out.println("----------------------------------顺子----------------------------------");

System.out.println(new Prompt(CardUtils.CreateCards("34567890JQKA2cC"), CardsFactory.builder("34567").list.get(0)));

System.out.println(new Prompt(CardUtils.CreateCards("34567890JQKA2cC"), CardsFactory.builder("345678").list.get(0)));

System.out.println(new Prompt(CardUtils.CreateCards("34567890JQKA2cC"), CardsFactory.builder("3456789").list.get(0)));

System.out.println("----------------------------------连对----------------------------------");

System.out.println(new Prompt(CardUtils.CreateCards("34567890JQKA234567890JQKA2cC"), CardsFactory.builder("334455").list.get(0)));

System.out.println(new Prompt(CardUtils.CreateCards("34567890JQKA234567890JQKA2cC"), CardsFactory.builder("33445566").list.get(0)));

System.out.println(new Prompt(CardUtils.CreateCards("34567890JQKA234567890JQKA2cC"), CardsFactory.builder("3344556677").list.get(0)));

System.out.println("----------------------------------飞机----------------------------------");

System.out.println(new Prompt(CardUtils.CreateCards("34567890JQKA234567890JQKA234567890JQKA2cC"), CardsFactory.builder("333444").list.get(0)));

System.out.println(new Prompt(CardUtils.CreateCards("34567890JQKA234567890JQKA234567890JQKA2cC"), CardsFactory.builder("333444555").list.get(0)));

System.out.println(new Prompt(CardUtils.CreateCards("34567890JQKA234567890JQKA234567890JQKA2cC"), CardsFactory.builder("333444555666").list.get(0)));

System.out.println("----------------------------------飞机带单牌----------------------------------");

System.out.println(new Prompt(CardUtils.CreateCards("44455566678"), CardsFactory.builder("44433365").list.get(0)));

System.out.println(new Prompt(CardUtils.CreateCards("444555666"), CardsFactory.builder("33344456").list.get(0)));

System.out.println(new Prompt(CardUtils.CreateCards("333444666777888"), CardsFactory.builder("33344456").list.get(0)));

System.out.println(new Prompt(CardUtils.CreateCards("4444555666789"), CardsFactory.builder("33344456").list.get(0)));

System.out.println(new Prompt(CardUtils.CreateCards("4445556666"), CardsFactory.builder("33344456").list.get(0)));

System.out.println("----------------------------------飞机带对子----------------------------------");

System.out.println(new Prompt(CardUtils.CreateCards("777666Cc3344"), CardsFactory.builder("3334445566").list.get(0)));

System.out.println(new Prompt(CardUtils.CreateCards("34567890JQKA234567890JQKA234567890JQKA2cC"), CardsFactory.builder("3334445566").list.get(0)));

System.out.println(new Prompt(CardUtils.CreateCards("34567890JQKA234567890JQKA234567890JQKA2cC"), CardsFactory.builder("333444555112244").list.get(0)));

System.out.println(new Prompt(CardUtils.CreateCards("34567890JQKA234567890JQKA234567890JQKA2cC"), CardsFactory.builder("33344455566611227788").list.get(0)));

System.out.println("----------------------------------NULL----------------------------------");

System.out.println(new Prompt(CardUtils.CreateCards("66778"), CardProduct.createNullType()));

}

public static void main(String[] args) {

typeTest();

outCardTest();

prompt();

}

}

CardUtils

package com.ddz;

import java.util.*;

import java.util.stream.Collectors;

/**

* 创建工具类

*

*

*/

public class CardUtils {

public static List CreateCards(String cards) {

List list = new ArrayList<>();

for (int i = 0; i < cards.length(); i++) {

String s = cards.substring(i, i + 1);

if (!" ".equals(s)) list.add(new Card(s));

}

return list;

}

/**

* 这个方法的作用是统计list中每张牌出现的次数

*

* @param list

* @return

*/

public static List createGroup(List list) {

List groups = new ArrayList<>();

LinkedList temp = new LinkedList<>(list);

Map map = new HashMap<>();// key=cardNum value=sum

while (temp.size() > 0) {

final Card card = temp.removeLast();

final Integer sum = map.get(card.num);

if (sum == null)

map.put(card.num, 1);

else

map.put(card.num, sum.intValue() + 1);

}

for (Map.Entry entry : map.entrySet()) {

groups.add(new CardGroup(entry.getKey(), entry.getValue()));

}

return groups;

}

/**

* 删除大小王 返回新的List

*

* @param list

* @return

*/

public static List removeJokers(List list) {

return list.stream().filter(cardGroup -> cardGroup.num != GameConstants.NUM_JOKER).collect(Collectors.toList());

}

public static int indexOfById(List list, int id) {

for (int i = 0; i < list.size(); i++) {

if (list.get(i).id == id) return i;

}

return -1;

}

public static int indexOfByNum(List list, int num) {

for (int i = 0; i < list.size(); i++) {

if (list.get(i).num == num) return i;

}

return -1;

}

/**

* 获取list中第一张为num的牌

*

* @param list

* @param num

* @return

*/

public static Card getCardByNum(List list, int num) {

for (int i = 0; i < list.size(); i++) {

if (list.get(i).num == num)

return list.get(i);

}

return null;

}

/**

* 从list头部开始搜索 返回len张为num的牌(list必须是排好序的)

*

* @param list

* @param num

* @param len 长度

* @return

*/

public static List getCardByNum(List list, int num, int len) {

for (int i = 0; i < list.size(); i++) {

if (list.get(i).num == num)

return list.subList(i, i + len);// subList后的list不能添加或删除

}

return new ArrayList<>();

}

/**

* 获取list中最后一张为num的牌

*

* @param list

* @param num

* @return

*/

public static Card getLastCardByNum(List list, int num) {

for (int i = list.size() - 1; i >= 0; i--) {

if (list.get(i).num == num)

return list.get(i);

}

return null;

}

/**

* 从list尾部开始搜索 返回len张为num的牌(list必须是排好序的)

*

* @param list

* @param num

* @param len 长度

* @return

*/

public static List getLastCardByNum(List list, int num, int len) {

for (int i = list.size() - 1; i >= 0; i--) {

if (list.get(i).num == num)

return list.subList(i - len + 1, i + 1);// subList后的list不能添加或删除

}

return new ArrayList<>();

}

/**

* 根据索引返回一个新的list

*

* @param list

* @param indexes

*/

public static List getCardsByIndexes(List list, List indexes) {

List newList = new ArrayList<>(indexes.size());

for (int i = 0; i < indexes.size(); i++) {

newList.add(list.get(indexes.get(i)));

}

return newList;

}

/**

* 根据索引从list删除 返回一个新的list

*

* @param list

* @param indexes

*/

public static List removeByIndex(List list, List indexes) {

List newList = new ArrayList<>();

for (int i = 0; i < list.size(); i++) {

if (!indexes.contains(i)) newList.add(list.get(i));

}

return newList;

}

/**

* 把牌号为num的牌全部移动到前面(list必须是排好序的)

*

* @param num

* @param len 移动的牌数

*/

public static void moveToHead(List list, int num, int len) {

ArrayList temp = new ArrayList<>();

int i = 0;

while (i < list.size() && temp.size() < len) {

if (list.get(i).num == num) temp.add(list.remove(i));

else i++;

}

list.addAll(0, temp);

}

/**

* 把牌号为num的牌全部移动到后面(list必须是排好序的)

*

* @param num

* @param len 移动的牌数

*/

public static void moveToEnd(List list, int num, int len) {

ArrayList temp = new ArrayList<>();

int i = 0;

while (i < list.size() && temp.size() < len) {

if (list.get(i).num == num) temp.add(list.remove(i));

else i++;

}

list.addAll(temp);

}

}

GameConstants

package com.ddz;

/**

* 先定义个常量的类

* ID_3_1 指的是红桃3

* ID_K_2 指的是方片K

* NUM_3 指的是三 不区分花色

* 用id/4就能得出这张牌的num了

*

*/

public class GameConstants {

public static final int TYPE_Farmer=1;

public static final int TYPE_Landlord=2;

public static final int NUM_3 = 0;

public static final int NUM_4 = 1;

public static final int NUM_5 = 2;

public static final int NUM_6 = 3;

public static final int NUM_7 = 4;

public static final int NUM_8 = 5;

public static final int NUM_9 = 6;

public static final int NUM_10 = 7;

public static final int NUM_J = 8;

public static final int NUM_Q = 9;

public static final int NUM_K = 10;

public static final int NUM_A = 11;

public static final int NUM_2 = 12;

public static final int NUM_JOKER = 13;

public static final int ID_3_1 = 0;

public static final int ID_3_2 = 1;

public static final int ID_3_3 = 2;

public static final int ID_3_4 = 3;

public static final int ID_4_1 = 4;

public static final int ID_4_2 = 5;

public static final int ID_4_3 = 6;

public static final int ID_4_4 = 7;

public static final int ID_5_1 = 8;

public static final int ID_5_2 = 9;

public static final int ID_5_3 = 10;

public static final int ID_5_4 = 11;

public static final int ID_6_1 = 12;

public static final int ID_6_2 = 13;

public static final int ID_6_3 = 14;

public static final int ID_6_4 = 15;

public static final int ID_7_1 = 16;

public static final int ID_7_2 = 17;

public static final int ID_7_3 = 18;

public static final int ID_7_4 = 19;

public static final int ID_8_1 = 20;

public static final int ID_8_2 = 21;

public static final int ID_8_3 = 22;

public static final int ID_8_4 = 23;

public static final int ID_9_1 = 24;

public static final int ID_9_2 = 25;

public static final int ID_9_3 = 26;

public static final int ID_9_4 = 27;

public static final int ID_10_1 = 28;

public static final int ID_10_2 = 29;

public static final int ID_10_3 = 30;

public static final int ID_10_4 = 31;

public static final int ID_J_1 = 32;

public static final int ID_J_2 = 33;

public static final int ID_J_3 = 34;

public static final int ID_J_4 = 35;

public static final int ID_Q_1 = 36;

public static final int ID_Q_2 = 37;

public static final int ID_Q_3 = 38;

public static final int ID_Q_4 = 39;

public static final int ID_K_1 = 40;

public static final int ID_K_2 = 41;

public static final int ID_K_3 = 42;

public static final int ID_K_4 = 43;

public static final int ID_A_1 = 44;

public static final int ID_A_2 = 45;

public static final int ID_A_3 = 46;

public static final int ID_A_4 = 47;

public static final int ID_2_1 = 48;

public static final int ID_2_2 = 49;

public static final int ID_2_3 = 50;

public static final int ID_2_4 = 51;

public static final int ID_JOKER_1 = 52;

public static final int ID_JOKER_2 = 53;

public static final int TYPE_ERROR = -1;

public static final int TYPE_NULL = 0;

public static final int TYPE_1 = 1;

public static final int TYPE_22 = 2;

public static final int TYPE_333 = 3;

public static final int TYPE_BOOM = 4;

public static final int TYPE_3331 = 5;

public static final int TYPE_33322 = 6;

public static final int TYPE_444412 = 7;

public static final int TYPE_44441122 = 8;

public static final int TYPE_34567 = 9;

public static final int TYPE_334455 = 10;

public static final int TYPE_333444 = 11;

public static final int TYPE_33344412 = 12;

public static final int TYPE_3334441122 = 13;

}

Prompt

package com.ddz;

import java.util.ArrayList;

import java.util.Comparator;

import java.util.List;

import java.util.stream.Collectors;

/**

* 提示功能

*/

public class Prompt {

private final List list;//从小到大

private final List groups;//按num从小到大

private final CardProduct last;

public final List> prompt;

public Prompt(List list, CardProduct last) {

this.list = new ArrayList<>(list);

this.groups = CardUtils.createGroup(list);

//从小到大排序

this.list.sort((o1, o2) -> o1.id - o2.id);

this.groups.sort(Comparator.comparingInt(o -> o.num));

this.last = last;

prompt = new ArrayList<>();

if (last.type == GameConstants.TYPE_ERROR) return;

else if (last.type == GameConstants.TYPE_NULL) prompt.addAll(findNull());

else if (last.type == GameConstants.TYPE_1) prompt.addAll(find1(last.maxCard.num, last.maxCard.id));

else if (last.type == GameConstants.TYPE_22) prompt.addAll(find22(last.maxCard.num));

else if (last.type == GameConstants.TYPE_333) prompt.addAll(find333(last.maxCard.num));

else if (last.type == GameConstants.TYPE_3331) prompt.addAll(find3331(last.maxCard.num));

else if (last.type == GameConstants.TYPE_33322) prompt.addAll(find33322(last.maxCard.num));

else if (last.type == GameConstants.TYPE_444412) prompt.addAll(find444412(last.maxCard.num));

else if (last.type == GameConstants.TYPE_44441122) prompt.addAll(find44441122(last.maxCard.num));

else if (last.type == GameConstants.TYPE_34567) prompt.addAll(find34567(last.maxCard.num, last.list.size()));

else if (last.type == GameConstants.TYPE_334455) prompt.addAll(find334455(last.maxCard.num, last.list.size()));

else if (last.type == GameConstants.TYPE_333444) prompt.addAll(find333444(last.maxCard.num, last.list.size()));

else if (last.type == GameConstants.TYPE_33344412)

prompt.addAll(find33344412(last.maxCard.num, last.list.size()));

else if (last.type == GameConstants.TYPE_3334441122)

prompt.addAll(find3334441122(last.maxCard.num, last.list.size()));

prompt.addAll(findBoom(last));

}

public List> findNull() {

//判断能不能一次把所有牌打完 如果能就直接打完

if (CardsFactory.builder(list).list.get(0).type != GameConstants.TYPE_ERROR) {

List> find = new ArrayList<>();

find.add(list);

return find;

}

//查找飞机带对子

if (list.size() > 10) {

final int length = list.size() - list.size() % 5;

for (int i = length; i >= 10; i -= 5) {

List> find = find3334441122(null, i);

if (find.size() > 0) return find;

}

}

//查找飞机带单排

if (list.size() > 8) {

final int length = list.size() - list.size() % 4;

for (int i = length; i >= 8; i -= 4) {

List> find = find33344412(null, i);

if (find.size() > 0) return find;

}

}

//查找飞机

if (list.size() > 6) {

for (int i = list.size() - list.size() % 3; i >= 6; i -= 3) {

List> find = find333444(null, i);

if (find.size() > 0) return find;

}

//查找连对

for (int i = list.size() - list.size() % 2; i >= 6; i -= 2) {

List> find = find334455(null, i);

if (find.size() > 0) return find;

}

}

if (list.size() > 5) {

//查找顺子

for (int i = list.size() - 1; i >= 5; i -= 1) {

List> find = find34567(null, i);

if (find.size() > 0) return find;

}

//查找三带一对

List> find = find33322(null);

if (find.size() > 0) return find;

}

if (list.size() > 4) {

//查找三带一

List> find = find3331(null);

if (find.size() > 0) return find;

}

//最后手段

List> find = new ArrayList<>();

List temp = new ArrayList<>();

List temp1 = new ArrayList<>();

for (CardGroup group : groups) {

if (group.sum < 4 || (group.num == GameConstants.NUM_JOKER && group.sum < 2)) {

temp.add(group);

} else {

temp1.add(group);

}

}

temp.addAll(temp1);

CardGroup group = temp.get(0);

find.add(CardUtils.getCardByNum(list, group.num, group.sum));

return find;

}

public List> find1(int maxCardNum, int maxCardId) {

List> find = new ArrayList<>();

List groups = new ArrayList<>();

for (CardGroup cardGroup : this.groups) {

if (cardGroup.num > maxCardNum) groups.add(cardGroup);

}

groups.sort((o1, o2) -> {

//order by sum desc,num desc

final int o = o1.sum - o2.sum;

if (o != 0) return o;

return o1.num - o2.num;

});

// groups.sort(Comparator.comparingInt((CardGroup o) -> o.sum).thenComparingInt(o -> o.num));

for (CardGroup group : groups) {

find.add(CardUtils.getCardByNum(list, group.num, 1));

}

if (maxCardId < GameConstants.ID_JOKER_2) {

for (Card card : list) {

if (card.id == GameConstants.ID_JOKER_2) {

List cards = new ArrayList<>();

cards.add(card);

find.add(cards);

break;

}

}

}

return find;

}

public List> find22(int maxCardNum) {

List> find = new ArrayList<>();

List groups = new ArrayList<>();

for (CardGroup cardGroup : this.groups) {

if (cardGroup.num > maxCardNum && cardGroup.sum >= 2 && cardGroup.sum < 4 && cardGroup.num != GameConstants.NUM_JOKER)

groups.add(cardGroup);

}

groups.sort((o1, o2) -> {

//order by sum desc,num desc

final int o = o1.sum - o2.sum;

if (o != 0) return o;

return o1.num - o2.num;

});

for (CardGroup group : groups) {

find.add(CardUtils.getCardByNum(list, group.num, 2));

}

return find;

}

public List> find333(int maxCardNum) {

List> find = new ArrayList<>();

List groups = new ArrayList<>();

for (CardGroup cardGroup : this.groups) {

if (cardGroup.num > maxCardNum && cardGroup.sum == 3 && cardGroup.num != GameConstants.NUM_JOKER)

groups.add(cardGroup);

}

groups.sort((o1, o2) -> {

//order by sum desc,num desc

final int o = o1.sum - o2.sum;

if (o != 0) return o;

return o1.num - o2.num;

});

for (CardGroup group : groups) {

find.add(CardUtils.getCardByNum(list, group.num, 3));

}

return find;

}

public List> findBoom(CardProduct last) {

List> find = new ArrayList<>();

List booms = new ArrayList<>();

for (CardGroup cardGroup : groups) {

if (cardGroup.num == GameConstants.NUM_JOKER && cardGroup.sum >= 2 || cardGroup.sum >= 4) {

booms.add(cardGroup);

}

}

booms.sort((o1, o2) -> {

final int o;

if (o1.num == GameConstants.NUM_JOKER) {

o = o1.sum * 2 - o2.sum;

} else if (o2.num == GameConstants.NUM_JOKER) {

o = o1.sum - o2.sum * 2;

} else {

o = o1.sum - o2.sum;

}

if (o != 0)

return o;

return o1.num - o2.num;

});

for (CardGroup cardGroup : booms) {

find.add(CardUtils.getCardByNum(list, cardGroup.num, cardGroup.sum));

}

// 拆

List> split = new ArrayList<>();

for (List boom : find) {

if (boom.size() > 4 && boom.get(0).num != GameConstants.NUM_JOKER) {

for (int i = 0; i < boom.size() - 4; i++) {

// 拆普通炸

List cards = new ArrayList<>(boom);

cards.remove(0);

for (int j = 0; j < i; j++)

cards.remove(cards.size() - 1);

split.add(cards);

}

} else if (boom.size() > 2 && boom.get(0).num == GameConstants.NUM_JOKER) {

// 拆王炸

List joker1List = new ArrayList<>();

List joker2List = new ArrayList<>();

for (Card card : boom) {

if (card.id == GameConstants.ID_JOKER_1)

joker1List.add(card);

else

joker2List.add(card);

}

for (int i = 2, len = boom.size(); i < len; i++) {

for (int j = 0; j <= i; j++) {// j=大王数量

if (i - j <= joker1List.size() && j <= joker2List.size()) {

List cards = new ArrayList<>();

for (int k = 0; k < i - j; k++)

cards.add(joker1List.get(k));

for (int k = 0; k < j; k++)

cards.add(joker2List.get(k));

split.add(cards);

}

}

}

}

}

find.addAll(split);

// 只留下打得过的炸

if (last != null && last.type == GameConstants.TYPE_BOOM) {

int i = 0;

while (i < find.size()) {

if (CardsFactory.builder(find.get(i)).isGreaterThan(last) < 0) {

find.remove(i);

} else {

i++;

}

}

}

return find;

}

public List> find3331(Integer maxCardNum) {

List> find = new ArrayList<>();

for (CardGroup group : CardUtils.removeJokers(groups)) {

if ((maxCardNum == null || group.num > maxCardNum) && group.sum == 3) {

List cards = new ArrayList<>(CardUtils.getCardByNum(list, group.num, 3));

List fill = getMinSingleCard(cards, true, 1);

if (fill.size() == 1) {

cards.addAll(fill);

find.add(cards);

}

}

}

return find;

}

public List> find33322(Integer maxCardNum) {

List> find = new ArrayList<>();

for (CardGroup group : CardUtils.removeJokers(groups)) {

if ((maxCardNum == null || group.num > maxCardNum) && group.sum == 3) {

List cards = new ArrayList<>(CardUtils.getCardByNum(list, group.num, 3));

List fill = getMinDoubleCards(cards, true, 1);

if (fill.size() == 2) {

cards.addAll(fill);

find.add(cards);

}

}

}

return find;

}

public List> find444412(int maxCardNum) {

List> find = new ArrayList<>();

for (CardGroup group : CardUtils.removeJokers(groups)) {

if (group.num > maxCardNum && group.sum == 4) {

List cards = new ArrayList<>(CardUtils.getCardByNum(list, group.num, 4));

List fill = getMinSingleCard(cards, true, 2);

if (fill.size() == 2) {

cards.addAll(fill);

find.add(cards);

}

}

}

return find;

}

public List> find44441122(int maxCardNum) {

List> find = new ArrayList<>();

for (CardGroup group : CardUtils.removeJokers(groups)) {

if (group.num > maxCardNum && group.sum == 4) {

List cards = new ArrayList<>(CardUtils.getCardByNum(list, group.num, 4));

List fill = getMinDoubleCards(cards, true, 2);

if (fill.size() == 4) {

cards.addAll(fill);

find.add(cards);

}

}

}

return find;

}

public List> find34567(Integer maxCardNum, int len) {

List> find = new ArrayList<>();

List> continuous = new ArrayList<>();

int start = 0;

int end = start + 1;

while (start + len <= groups.size()) {

if (groups.get(end).num - groups.get(start).num == end - start && groups.get(end).num < GameConstants.NUM_2

&& end < groups.size()) {

if (end + 1 - start == len) {

if (maxCardNum == null || groups.get(end).num > maxCardNum) {

List tempGroups = new ArrayList<>();

for (int i = start; i <= end; i++) {

tempGroups.add(groups.get(i));

}

continuous.add(tempGroups);

}

start++;

end = start + 1;

} else {

end++;

}

} else {

start++;

end = start + 1;

}

}

for (List cardGroups : continuous) {

List temp = new ArrayList<>();

for (CardGroup cardGroup : cardGroups) {

temp.add(CardUtils.getCardByNum(list, cardGroup.num));

}

find.add(temp);

}

return find;

}

public List> find334455(Integer maxCardNum, int length) {

List> find = new ArrayList<>();

List> continuous = new ArrayList<>();

List ge2AndLt4 = this.groups.stream().filter(cardGroup -> cardGroup.sum >= 2 && cardGroup.sum < 4).sorted(Comparator.comparingInt(o -> o.num)).collect(Collectors.toList());

int len = length / 2;// len为消除重复num后的长度

int start = 0;

int end = start + 1;

while (start + len <= ge2AndLt4.size()) {

if (ge2AndLt4.get(end).num - ge2AndLt4.get(start).num == end - start && ge2AndLt4.get(end).num < GameConstants.NUM_2

&& end < ge2AndLt4.size()) {

if (end + 1 - start == len) {

if (maxCardNum == null || ge2AndLt4.get(end).num > maxCardNum) {

List tempGroups = new ArrayList<>();

for (int i = start; i <= end; i++) {

tempGroups.add(ge2AndLt4.get(i));

}

continuous.add(tempGroups);

}

start++;

end = start + 1;

} else {

end++;

}

} else {

start++;

end = start + 1;

}

}

for (List cardGroups : continuous) {

List temp = new ArrayList<>();

for (CardGroup cardGroup : cardGroups) {

temp.addAll(CardUtils.getCardByNum(list, cardGroup.num, 2));

}

find.add(temp);

}

return find;

}

public List> find333444(Integer maxCardNum, int length) {

List> find = new ArrayList<>();

List> continuous = new ArrayList<>();

List eq3 = groups.stream().filter(cardGroup -> cardGroup.sum == 3).sorted(Comparator.comparingInt(o -> o.num)).collect(Collectors.toList());

int len = length / 3;// len为消除重复num后的长度

int start = 0;

int end = start + 1;

while (start + len <= eq3.size()) {

if (eq3.get(end).num - eq3.get(start).num == end - start && eq3.get(end).num < GameConstants.NUM_2

&& end < eq3.size()) {

if (end + 1 - start == len) {

if (maxCardNum == null || eq3.get(end).num > maxCardNum) {

List tempGroups = new ArrayList<>();

for (int i = start; i <= end; i++) {

tempGroups.add(eq3.get(i));

}

continuous.add(tempGroups);

}

start++;

end = start + 1;

} else {

end++;

}

} else {

start++;

end = start + 1;

}

}

for (List cardGroups : continuous) {

List temp = new ArrayList<>();

for (CardGroup cardGroup : cardGroups) {

temp.addAll(CardUtils.getCardByNum(list, cardGroup.num, 3));

}

find.add(temp);

}

return find;

}

public List> find33344412(Integer maxCardNum, int length) {

List> find = new ArrayList<>();

List> continuous = new ArrayList<>();

List eq3 = groups.stream().filter(cardGroup -> cardGroup.sum == 3).sorted(Comparator.comparingInt(o -> o.num)).collect(Collectors.toList());

int len = length / 4;// len为三顺长度 如333444555的话len就等于3

int start = 0;

int end = start + 1;

while (start + len <= eq3.size()) {

if (eq3.get(end).num - eq3.get(start).num == end - start && eq3.get(end).num < GameConstants.NUM_2 && end < eq3.size()) {

if (end + 1 - start == len) {

if (maxCardNum == null || eq3.get(end).num > maxCardNum) {

List tempGroups = new ArrayList<>();

for (int i = start; i <= end; i++) {

tempGroups.add(eq3.get(i));

}

continuous.add(tempGroups);

}

start++;

end = start + 1;

} else {

end++;

}

} else {

start++;

end = start + 1;

}

}

for (List cardGroups : continuous) {

List temp = new ArrayList<>();

for (CardGroup cardGroup : cardGroups) {

temp.addAll(CardUtils.getCardByNum(list, cardGroup.num, 3));

}

List fill = getMinSingleCard(temp, true, len);

if (fill.size() == len) {

temp.addAll(fill);

find.add(temp);

}

}

return find;

}

public List> find3334441122(Integer maxCardNum, int length) {

List> find = new ArrayList<>();

List> continuous = new ArrayList<>();

List eq3 = groups.stream().filter(cardGroup -> cardGroup.sum == 3).sorted(Comparator.comparingInt(o -> o.num)).collect(Collectors.toList());

int len = length / 5;// len为三顺长度 如333444555的话len就等于3

int start = 0;

int end = start + 1;

while (start + len <= eq3.size()) {

if (eq3.get(end).num - eq3.get(start).num == end - start && eq3.get(end).num < GameConstants.NUM_2 && end < eq3.size()) {

if (end + 1 - start == len) {

if (maxCardNum == null || eq3.get(end).num > maxCardNum) {

List tempGroups = new ArrayList<>();

for (int i = start; i <= end; i++) {

tempGroups.add(eq3.get(i));

}

continuous.add(tempGroups);

}

start++;

end = start + 1;

} else {

end++;

}

} else {

start++;

end = start + 1;

}

}

for (List cardGroups : continuous) {

List temp = new ArrayList<>();

for (CardGroup cardGroup : cardGroups) {

temp.addAll(CardUtils.getCardByNum(list, cardGroup.num, 3));

}

List fill = getMinDoubleCards(temp, true, len);

if (fill.size() == len * 2) {

temp.addAll(fill);

find.add(temp);

}

}

return find;

}

/**

* 获取最小单牌

*

* @param notIn

* @param removeAll 为false时只删除相同的牌 为true时删除num相等的牌

* @param len 获取的单排数量 最多返回len张牌 也可能一张都不返回

* @return

*/

public List getMinSingleCard(List notIn, boolean removeAll, int len) {

List result = new ArrayList<>();

List temp;

if (removeAll) {

temp = list.stream().filter(card -> notIn.stream().noneMatch(card1 -> card.num == card1.num)).collect(Collectors.toList());

} else {

temp = new ArrayList<>(list);

temp.removeAll(notIn);

}

List groups = CardUtils.createGroup(temp);

groups.sort(Comparator.comparingInt((CardGroup o) -> o.sum).thenComparingInt(o -> o.num));// order by sum,num

int index = 0;

while (result.size() < len && index < groups.size()) {

CardGroup cardGroup = groups.get(index);

if (cardGroup.sum > 0) {

cardGroup.sum--;

Card card = CardUtils.getCardByNum(list, cardGroup.num);

result.add(card);

} else

index++;

}

return result;

}

/**

* 获取最小对子(不包括大小王)

*

* @param notIn

* @param removeAll 为false时只删除相同的牌 为true时删除num相等的牌

* @param len 获取的对子数量 最多返回len*2张牌 也可能一张都不返回

* @return

*/

public List getMinDoubleCards(List notIn, boolean removeAll, int len) {

List result = new ArrayList<>();

List temp;

//获取对子不能包含对王

if (removeAll) {

temp = list.stream().filter(card -> card.num != GameConstants.NUM_JOKER && notIn.stream().noneMatch(card1 -> card.num == card1.num)).collect(Collectors.toList());

} else {

temp = list.stream().filter(card -> card.num != GameConstants.NUM_JOKER && notIn.stream().noneMatch(card1 -> card == card1)).collect(Collectors.toList());

}

List groups = CardUtils.createGroup(temp);

groups.sort(Comparator.comparingInt((CardGroup o) -> o.sum).thenComparingInt(o -> o.num));// order by sum,num

if (groups.size() > 0) {

int index = 0;

while (result.size() < len * 2 && index < groups.size()) {

CardGroup cardGroup = groups.get(index);

if (cardGroup.sum >= 2) {

cardGroup.sum -= 2;

List cards = CardUtils.getCardByNum(list, cardGroup.num, 2);

result.addAll(cards);

} else

index++;

}

}

return result;

}

@Override

public String toString() {

return "当前扑克牌:" + list + " 上家出牌:" + last.list + " 提示(" + prompt.size() + "):" + prompt;

}

}

相关文章

即时游戏有哪些好玩 人气高的即时游戏盘点

365bet在线网址 08-15

2025年能借3万的借款平台,资质正规、下款迅速,急用钱能快速到账的有这些发布时间:2025-1-13 14:30阅读:1583

beat365手机版官方网站正规 08-19

机械硬盘拆卸图文教程

365bet在线网址 07-10

餿的意思,餿的解释,餿的拼音,餿的部首,餿的笔顺

beat365手机版官方网站正规 07-04