斗地主
三。判断工具类
1.计算面值算法
/**
* 计算面值
* 当为非炸弹时，面值为各值相加
* 当为炸弹时，面值为个值相加 + 一副牌总值
* 当为王炸时，面值为两副牌总值
* 一副牌总值 416 （除大小王）
* @return
*/
public static Integer countValue(String s,Integer type){
Integer value = 0;
if (4 == type){
String[] split = s.split("");
for (String s1 : split) {
if ("W".equals(s1) || "w".equals(s1)){
value += 208;
}else {
value += 104;
}
}
}
if (type == 3 || type == 7){
Pattern p = Pattern.compile(CANONICAL_XXX);
Matcher m = p.matcher(s);
while (m.find()){
String group = m.group();
Integer integer = valueMap.get(group.split("")[0]);
value += integer * 18;
}
}
value = simpleCountValue(s,value);
return value;
}
2.获得一副牌，一种类型的所有组合
/**
* 获得一副牌，一种类型的所有组合
* num 连续的个数，默认5
* type =
* 1 获取所有单排
* 2 获取所有对子
* 3 获取所有三带一
* 4 获取所有炸弹
* 5 获取所有顺子
* 6 获取所有连对
* 7 获取所有飞机
*/
public static List<Poker> getPoker(String s, Integer type,Integer num){
List<Poker> list = new ArrayList<>();
Pattern p;
Matcher matcher;
if (type == 1){
p = Pattern.compile(CANONICAL_X);
matcher = p.matcher(s);
while (matcher.find()){
String group = matcher.group();
Poker poker = new Poker();
poker.setName(group);
poker.setType(type);
poker.setValue(countValue(group,type));
poker.setSize(group.length());
list.add(poker);
}
}
else if (type == 2){
p = Pattern.compile(CANONICAL_XX);
matcher = p.matcher(s);
while (matcher.find()){
String group = matcher.group();
Poker poker = new Poker();
poker.setName(group);
poker.setType(type);
poker.setValue(countValue(group,type));
poker.setSize(group.length());
list.add(poker);
}
}
else if (type == 3){
List<Poker> newPoker = new ArrayList<>();
p = Pattern.compile(CANONICAL_XXX);
matcher = p.matcher(s);
while (matcher.find()){
String group = matcher.group();
Poker poker = new Poker();
poker.setName(group);
newPoker.add(poker);
}
for (Poker poker : newPoker) {
String newS = s.replace(poker.getName(),"");
List<Poker> poker1 = getPoker(newS, 1, 5);
for (Poker poker2 : poker1) {
if (!poker.getName().contains(poker2.getName())){
Poker poker3 = new Poker();
String pokerName = poker.getName() + poker2.getName();
poker3.setName(pokerName);
poker3.setValue(countValue(pokerName,type));
poker3.setSize(pokerName.length());
poker3.setType(type);
list.add(poker3);
}
}
}
}
else if (type == 4){
p = Pattern.compile(CANONICAL_XXXX_Min);
matcher = p.matcher(s);
while (matcher.find()){
String group = matcher.group();
for (int i = 4; i <= group.length(); i++) {
Poker poker = new Poker();
poker.setName(group.substring(0,i));
poker.setType(type);
poker.setValue(countValue(group.substring(0,i),type));
poker.setSize(4);
list.add(poker);
}
}
int num_w = 0;
int num_W = 0;
String[] split = s.split("");
for (String s1 : split) {
if ("W".equals(s1)){
num_W++;
}else if ("w".equals(s1)){
num_w++;
}
}
if (num_w > 0 && num_W > 0){
for (int i = num_w > num_W ? num_W : num_w; num_w > 0 && num_W > 0; i--) {
Poker poker = new Poker();
String name = "";
for (int j = 0; j < i; j++) {
name = "W" + name + "w";
}
poker.setName(name);
poker.setType(type);
poker.setValue(countValue(name,type));
poker.setSize(4);
list.add(poker);
num_w--;
num_W--;
}
}
// if (s.contains("Ww")){
// Poker poker = new Poker();
// poker.setName("Ww");
// poker.setType(type);
// poker.setValue(countValue("Ww",type));
// poker.setSize(2);
// list.add(poker);
// }
}
else if (type == 5){
//去重
String[] split = s.split("");
String newS = "";
for (int i = 0; i < split.length; i++) {
if (i == 0 || !split[i].equals(split[i-1])){
newS += split[i];
}
}
newS = pxPoker(newS,1);
List<String> newSL = new ArrayList<>();
String[] split1 = newS.split("");
for (int i = 0; i < split1.length; i++) {
StringBuilder s1 = new StringBuilder("");
if (i+num-1<split1.length){
for (int j = 0; j < num; j++) {
s1.append(split1[i+j]);
}
}
int n = num;
Boolean b = puanDuanLX(s1.toString(),num);
while (b && i+n < split1.length){
if (puanDuanLX(s1.toString()+split1[i+n],num)){
s1.append(split1[i+n]);
n++;
}else {
break;
}
}
if (b){
newSL.add(s1.toString());
}
}
for (String s1 : newSL) {
for (int i = num-1; i < s1.length(); i++) {
Poker poker = new Poker();
poker.setType(type);
String pokerStr = "";
for (int j = 0; j <= i; j++) {
pokerStr += s1.split("")[j];
}
poker.setName(pokerStr);
poker.setValue(countValue(pokerStr,type));
poker.setSize(pokerStr.length());
list.add(poker);
}
}
}
else if (type == 6){
String newS0 = "";
//先正序排序
s = pxPoker(s,1);
//找出所有
p = Pattern.compile(CANONICAL_XX);
matcher = p.matcher(s);
while (matcher.find()){
String group = matcher.group();
newS0 += group;
}
list = getPoker(newS0, 5, 3);
for (Poker poker1 : list) {
String name = poker1.getName();
String s0 = "";
String[] split = name.split("");
for (String s1 : split) {
s0 += s1 + s1;
}
poker1.setName(s0);
poker1.setType(type);
poker1.setValue(countValue(s0,type));
poker1.setSize(s0.length());
}
}
else if (type == 7){
String newS0 = "";
//先正序排序
s = pxPoker(s,1);
//找出所有
p = Pattern.compile(CANONICAL_XXX);
matcher = p.matcher(s);
while (matcher.find()){
String group = matcher.group();
newS0 += group;
}
List<Poker> list0 = getPoker(newS0, 5, 2);
for (Poker poker1 : list0) {
String name = poker1.getName();
String s0 = "";
String[] split = name.split("");
for (String s1 : split) {
s0 += s1 + s1 + s1;
}
int size = s0.length() / 3;
String replace = s.replace(s0, "");
String[] sp = replace.split("");
LinkedHashSet<String> allMakeUp = getAllMakeUp(sp, size, 0);
for (String s1 : allMakeUp) {
Poker poker = new Poker();
poker.setName(s0 + s1);
poker.setValue(countValue(s0 + s1,type));
poker.setType(type);
poker.setSize((s0 + s1).length());
list.add(poker);
}
}
}
return list;
}
3.获取所有组合的字符串
这个其实就是找顺子时，先找的最长的顺子，然后再枚举出所有符合规则的顺子
/**
* 获取所有组合的字符串
* @param ss
* @param n
* @return
*/
public static LinkedHashSet<String> getAllMakeUp(String[] ss,int n,int m){
LinkedHashSet<String> list = new LinkedHashSet<>();
for (int i = m; i < ss.length; i++) {
String s = ss[i];
if (n > 1){
LinkedHashSet<String> allMakeUp = getAllMakeUp(ss, n - 1, i + 1);
for (String s1 : allMakeUp) {
list.add(s + s1);
}
}else {
list.add(s);
}
}
return list;
}
4.判断连续
这个就不止可以用在斗地主了，其他扑克游戏也行
/**
* 判断连续
* @param s 需要判断的字符串
* @param num 至少连续的次数
* @return
*/
public static Boolean puanDuanLX(String s ,int num){
Boolean b = false;
Pattern p;
Matcher matcher;
//验证顺子
p = Pattern.compile(CANONICAL_ABCDE_N.replace("N",(num-1) + ""));
matcher = p.matcher(s);
boolean b1 = matcher.find();
String group1 = "";
if (b1){
group1 = matcher.group();
}
if (group1.length() == s.length()){
b = true;
}
return b;
}
5.给牌排序
这个类型2还没写，后面有空会补上，其实就是相当于齐牌，有些人喜欢把顺子啊三带啊这些摆好放在一边，这里就是来实现这个逻辑
/**
* 给牌排序
*
* @param s 牌
* @param type 排序类型，0 乱序；1 正序； -1 反序 ；2 归类排序（相当于玩家习惯的齐牌规则）
* @return
*/
public static String pxPoker(String s,Integer type){
String newS = "";
List<Poker> pokers = new ArrayList<>();
String[] split = s.split("");
for (String s1 : split) {
Poker poker = new Poker();
poker.setName(s1);
poker.setValue(valueMap.get(s1));
pokers.add(poker);
}
switch (type){
case 0:
break;
case 1:
pokers = pokers.stream().sorted(Comparator.comparing(Poker::getValue)).collect(Collectors.toList());
for (Poker poker : pokers) {
newS += poker.getName();
}
break;
case -1:
pokers = pokers.stream().sorted(Comparator.comparing(Poker::getValue).reversed()).collect(Collectors.toList());
for (Poker poker : pokers) {
newS += poker.getName();
}
break;
case 2:
break;
default:
newS = s;
break;
}
return newS;
}
6.判断是否符合出牌规则
这里也有一份，其实差不多的，方便ai使用
/**
* 判断是否符合出牌规则
* x 单 1
* xx 对 2
* xxxy 三带一 3
* xxxx Ww 炸弹 4
* abcde...顺子 5
* aabbcc...连对 6
* aaabbb... xy... 飞机 7
* @param s
* @return null 格式错误 1 单牌 2 对子 3 三带一 4 炸弹 5 顺子 6 连对 7 飞机
*/
public static Integer panDuanGZ(String s){
Integer b = null;
String[] split = s.split("");
Pattern p;
Matcher matcher;
if (split.length == 0){
return b;
}
else if (split.length == 1){
p = Pattern.compile(CANONICAL_X);
matcher = p.matcher(s);
boolean b1 = matcher.find();
if (b1){
b = 1;
}
}
else if (split.length == 2){
if (s.equals("Ww") || s.equals("wW")){
b = 4;
}else{
p = Pattern.compile(CANONICAL_XX);
matcher = p.matcher(s);
Boolean b1 = matcher.find();
if (b1){
b = 2;
}
}
}
else if (split.length == 3){
return b;
}
else if (split.length == 4){
p = Pattern.compile(CANONICAL_XXXX);
matcher = p.matcher(s);
Boolean b1 = matcher.find();
p = Pattern.compile(CANONICAL_XXXY);
matcher = p.matcher(s);
Boolean b2 = matcher.find();
if (b1){
b = 4;
}else if (b2){
b = 3;
}
}
else if (split.length > 4){
//验证超级炸弹
p = Pattern.compile(CANONICAL_XXXX_Min);
matcher = p.matcher(s);
Boolean cjzd = matcher.find();
if (cjzd && matcher.group().length() == s.length()){
return 4;
}
String s1 = "";
int num = 0;
String newStr = "";
//先验证飞机
p = Pattern.compile(CANONICAL_XXX);
matcher = p.matcher(s);
while (matcher.find()){
String group = matcher.group();
num++;
s1 +=group;
newStr += group.split("")[0];
}
Boolean aBoolean1 = puanDuanLX(newStr, 2);
if (s.length() - s1.length() == num && aBoolean1){
return 7;
}
//验证连对
p = Pattern.compile(CANONICAL_XX);
matcher = p.matcher(s);
Boolean b6 = false;
while (matcher.find()){
b6 = true;
String group = matcher.group();
s1 +=group;
newStr += group.split("")[0];
}
if (b6){
Boolean aBoolean2 = puanDuanLX(newStr, 3);
if (aBoolean2){
return 6;
}
}
//验证顺子
Boolean aBoolean = puanDuanLX(s, 5);
if (aBoolean){
return 5;
}
}
return b;
}
7.不想看你吹，直接看完整代码
package com.fxp.linuxdemo.game.poker;
import com.fxp.linuxdemo.domain.bean.Poker;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
/**
* @Author: fxp
* @Date: 2023/3/21 14:38
* @Description 牌面判断类
*/
public class PokerPanDuan {
/**
* 正则单牌
*/
private static final String CANONICAL_NP = "[^2-9XJQKAWw\\-\\*]";
/**
* 正则单牌
*/
private static final String CANONICAL_X = "[2-9XJQKAWw\\*]";
/**
* 正则对子
*/
private static final String CANONICAL_XX = "([2-9XJQKAWw\\*])\\1{1}";
/**
* 正则至少N次重复
*/
private static final String CANONICAL_XX_N = "([2-9XJQKAWw\\*])\\1{N,}";
/**
* 正则三个
*/
private static final String CANONICAL_XXX = "([2-9XJQKAWw\\*])\\1{2}";
/**
* 正则炸弹
*/
private static final String CANONICAL_XXXX = "([2-9XJQKAWw\\*])\\1{3}";
/**
* 正则至少重复4次
*/
private static final String CANONICAL_XXXX_Min = "([2-9XJQKAWw\\*])\\1{4,}";
/**
* 正则三带一
*/
private static final String CANONICAL_XXXY = "([2-9XJQKAWw\\*])\\1{2}[2-9XJQKAWw\\*]";
/**
* 顺子
*/
private static final String CANONICAL_ABCDE = "(3(?=4)|4(?=5)|5(?=6)|6(?=7)|7(?=8)|8(?=9)|9(?=X)|X(?=J)|J(?=Q)|Q(?=K)|K(?=A)){4,}";
/**
* 顺子
*/
private static final String CANONICAL_EDCBA = "((?<=3)4|(?<=4)5|(?<=5)6|(?<=6)7|(?<=7)8|(?<=8)9|(?<=9)X|(?<=X)J|(?<=J)Q|(?<=Q)K|(?<=K)A){4,}";
/**
* 连续 至少两次
*/
private static final String CANONICAL_ABCDE_N = "(3(?=4)|4(?=5)|5(?=6)|6(?=7)|7(?=8)|8(?=9)|9(?=X)|X(?=J)|J(?=Q)|Q(?=K)|K(?=A)){N,}[3-9XJQKA]";
/**
* 连续 至少两次
*/
private static final String CANONICAL_EDCBA_N = "((?<=3)4|(?<=4)5|(?<=5)6|(?<=6)7|(?<=7)8|(?<=8)9|(?<=9)X|(?<=X)J|(?<=J)Q|(?<=Q)K|(?<=K)A){N,}";
public static final Map<String, Integer> valueMap = new HashMap<String, Integer>(){
{
put("3",3);
put("4",4);
put("5",5);
put("6",6);
put("7",7);
put("8",8);
put("9",9);
put("X",10);
put("J",11);
put("Q",12);
put("K",13);
put("A",14);
put("2",15);
put("w",16);
put("W",17);
}
};
/**
* 计算面值
* 当为非炸弹时，面值为各值相加
* 当为炸弹时，面值为个值相加 + 一副牌总值
* 当为王炸时，面值为两副牌总值
* 一副牌总值 416 （除大小王）
* @return
*/
public static Integer countValue(String s,Integer type){
Integer value = 0;
if (4 == type){
String[] split = s.split("");
for (String s1 : split) {
if ("W".equals(s1) || "w".equals(s1)){
value += 208;
}else {
value += 104;
}
}
}
if (type == 3 || type == 7){
Pattern p = Pattern.compile(CANONICAL_XXX);
Matcher m = p.matcher(s);
while (m.find()){
String group = m.group();
Integer integer = valueMap.get(group.split("")[0]);
value += integer * 18;
}
}
value = simpleCountValue(s,value);
return value;
}
public static Integer simpleCountValue(String s,Integer value){
if (null == value){
value = 0;
}
String[] split = s.split("");
for (String s1 : split) {
value += valueMap.get(s1);
}
return value;
}
/**
* 获得一副牌，一种类型的所有组合
* num 连续的个数，默认5
* type =
* 1 获取所有单排
* 2 获取所有对子
* 3 获取所有三带一
* 4 获取所有炸弹
* 5 获取所有顺子
* 6 获取所有连对
* 7 获取所有飞机
*/
public static List<Poker> getPoker(String s, Integer type,Integer num){
List<Poker> list = new ArrayList<>();
Pattern p;
Matcher matcher;
if (type == 1){
p = Pattern.compile(CANONICAL_X);
matcher = p.matcher(s);
while (matcher.find()){
String group = matcher.group();
Poker poker = new Poker();
poker.setName(group);
poker.setType(type);
poker.setValue(countValue(group,type));
poker.setSize(group.length());
list.add(poker);
}
}
else if (type == 2){
p = Pattern.compile(CANONICAL_XX);
matcher = p.matcher(s);
while (matcher.find()){
String group = matcher.group();
Poker poker = new Poker();
poker.setName(group);
poker.setType(type);
poker.setValue(countValue(group,type));
poker.setSize(group.length());
list.add(poker);
}
}
else if (type == 3){
List<Poker> newPoker = new ArrayList<>();
p = Pattern.compile(CANONICAL_XXX);
matcher = p.matcher(s);
while (matcher.find()){
String group = matcher.group();
Poker poker = new Poker();
poker.setName(group);
newPoker.add(poker);
}
for (Poker poker : newPoker) {
String newS = s.replace(poker.getName(),"");
List<Poker> poker1 = getPoker(newS, 1, 5);
for (Poker poker2 : poker1) {
if (!poker.getName().contains(poker2.getName())){
Poker poker3 = new Poker();
String pokerName = poker.getName() + poker2.getName();
poker3.setName(pokerName);
poker3.setValue(countValue(pokerName,type));
poker3.setSize(pokerName.length());
poker3.setType(type);
list.add(poker3);
}
}
}
}
else if (type == 4){
p = Pattern.compile(CANONICAL_XXXX_Min);
matcher = p.matcher(s);
while (matcher.find()){
String group = matcher.group();
for (int i = 4; i <= group.length(); i++) {
Poker poker = new Poker();
poker.setName(group.substring(0,i));
poker.setType(type);
poker.setValue(countValue(group.substring(0,i),type));
poker.setSize(4);
list.add(poker);
}
}
int num_w = 0;
int num_W = 0;
String[] split = s.split("");
for (String s1 : split) {
if ("W".equals(s1)){
num_W++;
}else if ("w".equals(s1)){
num_w++;
}
}
if (num_w > 0 && num_W > 0){
for (int i = num_w > num_W ? num_W : num_w; num_w > 0 && num_W > 0; i--) {
Poker poker = new Poker();
String name = "";
for (int j = 0; j < i; j++) {
name = "W" + name + "w";
}
poker.setName(name);
poker.setType(type);
poker.setValue(countValue(name,type));
poker.setSize(4);
list.add(poker);
num_w--;
num_W--;
}
}
// if (s.contains("Ww")){
// Poker poker = new Poker();
// poker.setName("Ww");
// poker.setType(type);
// poker.setValue(countValue("Ww",type));
// poker.setSize(2);
// list.add(poker);
// }
}
else if (type == 5){
//去重
String[] split = s.split("");
String newS = "";
for (int i = 0; i < split.length; i++) {
if (i == 0 || !split[i].equals(split[i-1])){
newS += split[i];
}
}
newS = pxPoker(newS,1);
List<String> newSL = new ArrayList<>();
String[] split1 = newS.split("");
for (int i = 0; i < split1.length; i++) {
StringBuilder s1 = new StringBuilder("");
if (i+num-1<split1.length){
for (int j = 0; j < num; j++) {
s1.append(split1[i+j]);
}
}
int n = num;
Boolean b = puanDuanLX(s1.toString(),num);
while (b && i+n < split1.length){
if (puanDuanLX(s1.toString()+split1[i+n],num)){
s1.append(split1[i+n]);
n++;
}else {
break;
}
}
if (b){
newSL.add(s1.toString());
}
}
for (String s1 : newSL) {
for (int i = num-1; i < s1.length(); i++) {
Poker poker = new Poker();
poker.setType(type);
String pokerStr = "";
for (int j = 0; j <= i; j++) {
pokerStr += s1.split("")[j];
}
poker.setName(pokerStr);
poker.setValue(countValue(pokerStr,type));
poker.setSize(pokerStr.length());
list.add(poker);
}
}
}
else if (type == 6){
String newS0 = "";
//先正序排序
s = pxPoker(s,1);
//找出所有
p = Pattern.compile(CANONICAL_XX);
matcher = p.matcher(s);
while (matcher.find()){
String group = matcher.group();
newS0 += group;
}
list = getPoker(newS0, 5, 3);
for (Poker poker1 : list) {
String name = poker1.getName();
String s0 = "";
String[] split = name.split("");
for (String s1 : split) {
s0 += s1 + s1;
}
poker1.setName(s0);
poker1.setType(type);
poker1.setValue(countValue(s0,type));
poker1.setSize(s0.length());
}
}
else if (type == 7){
String newS0 = "";
//先正序排序
s = pxPoker(s,1);
//找出所有
p = Pattern.compile(CANONICAL_XXX);
matcher = p.matcher(s);
while (matcher.find()){
String group = matcher.group();
newS0 += group;
}
List<Poker> list0 = getPoker(newS0, 5, 2);
for (Poker poker1 : list0) {
String name = poker1.getName();
String s0 = "";
String[] split = name.split("");
for (String s1 : split) {
s0 += s1 + s1 + s1;
}
int size = s0.length() / 3;
String replace = s.replace(s0, "");
String[] sp = replace.split("");
LinkedHashSet<String> allMakeUp = getAllMakeUp(sp, size, 0);
for (String s1 : allMakeUp) {
Poker poker = new Poker();
poker.setName(s0 + s1);
poker.setValue(countValue(s0 + s1,type));
poker.setType(type);
poker.setSize((s0 + s1).length());
list.add(poker);
}
}
}
return list;
}
/**
* 获取所有组合的字符串
* @param ss
* @param n
* @return
*/
public static LinkedHashSet<String> getAllMakeUp(String[] ss,int n,int m){
LinkedHashSet<String> list = new LinkedHashSet<>();
for (int i = m; i < ss.length; i++) {
String s = ss[i];
if (n > 1){
LinkedHashSet<String> allMakeUp = getAllMakeUp(ss, n - 1, i + 1);
for (String s1 : allMakeUp) {
list.add(s + s1);
}
}else {
list.add(s);
}
}
return list;
}
/**
* 判断连续
* @param s 需要判断的字符串
* @param num 至少连续的次数
* @return
*/
public static Boolean puanDuanLX(String s ,int num){
Boolean b = false;
Pattern p;
Matcher matcher;
//验证顺子
p = Pattern.compile(CANONICAL_ABCDE_N.replace("N",(num-1) + ""));
matcher = p.matcher(s);
boolean b1 = matcher.find();
String group1 = "";
if (b1){
group1 = matcher.group();
}
if (group1.length() == s.length()){
b = true;
}
return b;
}
/**
* 给牌排序
*
* @param s 牌
* @param type 排序类型，0 乱序；1 正序； -1 反序 ；2 归类排序（相当于玩家习惯的齐牌规则）
* @return
*/
public static String pxPoker(String s,Integer type){
String newS = "";
List<Poker> pokers = new ArrayList<>();
String[] split = s.split("");
for (String s1 : split) {
Poker poker = new Poker();
poker.setName(s1);
poker.setValue(valueMap.get(s1));
pokers.add(poker);
}
switch (type){
case 0:
break;
case 1:
pokers = pokers.stream().sorted(Comparator.comparing(Poker::getValue)).collect(Collectors.toList());
for (Poker poker : pokers) {
newS += poker.getName();
}
break;
case -1:
pokers = pokers.stream().sorted(Comparator.comparing(Poker::getValue).reversed()).collect(Collectors.toList());
for (Poker poker : pokers) {
newS += poker.getName();
}
break;
case 2:
break;
default:
newS = s;
break;
}
return newS;
}
/**
* 判断是否符合出牌规则
* x 单 1
* xx 对 2
* xxxy 三带一 3
* xxxx Ww 炸弹 4
* abcde...顺子 5
* aabbcc...连对 6
* aaabbb... xy... 飞机 7
* @param s
* @return null 格式错误 1 单牌 2 对子 3 三带一 4 炸弹 5 顺子 6 连对 7 飞机
*/
public static Integer panDuanGZ(String s){
Integer b = null;
String[] split = s.split("");
Pattern p;
Matcher matcher;
if (split.length == 0){
return b;
}
else if (split.length == 1){
p = Pattern.compile(CANONICAL_X);
matcher = p.matcher(s);
boolean b1 = matcher.find();
if (b1){
b = 1;
}
}
else if (split.length == 2){
if (s.equals("Ww") || s.equals("wW")){
b = 4;
}else{
p = Pattern.compile(CANONICAL_XX);
matcher = p.matcher(s);
Boolean b1 = matcher.find();
if (b1){
b = 2;
}
}
}
else if (split.length == 3){
return b;
}
else if (split.length == 4){
p = Pattern.compile(CANONICAL_XXXX);
matcher = p.matcher(s);
Boolean b1 = matcher.find();
p = Pattern.compile(CANONICAL_XXXY);
matcher = p.matcher(s);
Boolean b2 = matcher.find();
if (b1){
b = 4;
}else if (b2){
b = 3;
}
}
else if (split.length > 4){
//验证超级炸弹
p = Pattern.compile(CANONICAL_XXXX_Min);
matcher = p.matcher(s);
Boolean cjzd = matcher.find();
if (cjzd && matcher.group().length() == s.length()){
return 4;
}
String s1 = "";
int num = 0;
String newStr = "";
//先验证飞机
p = Pattern.compile(CANONICAL_XXX);
matcher = p.matcher(s);
while (matcher.find()){
String group = matcher.group();
num++;
s1 +=group;
newStr += group.split("")[0];
}
Boolean aBoolean1 = puanDuanLX(newStr, 2);
if (s.length() - s1.length() == num && aBoolean1){
return 7;
}
//验证连对
p = Pattern.compile(CANONICAL_XX);
matcher = p.matcher(s);
Boolean b6 = false;
while (matcher.find()){
b6 = true;
String group = matcher.group();
s1 +=group;
newStr += group.split("")[0];
}
if (b6){
Boolean aBoolean2 = puanDuanLX(newStr, 3);
if (aBoolean2){
return 6;
}
}
//验证顺子
Boolean aBoolean = puanDuanLX(s, 5);
if (aBoolean){
return 5;
}
}
return b;
}
public static List<Poker> getPokerList(String s){
List<Poker> pokers = new ArrayList<>();
String[] split = s.split("");
for (String s1 : split) {
Poker poker = new Poker();
poker.setName(s1);
poker.setShow(true);
pokers.add(poker);
}
return pokers;
}
public static void main(String[] args) {
// Boolean aBoolean = puanDuanLX("56789XJQKA", 5);
// System.out.println("aBoolean = " + aBoolean);
// String s = pxPoker("487485499XX", -1);
// System.out.println("s = " + s);
// List<Poker> list = getPoker("345567789XXJJQKA", 6,5);
// System.out.println("list = " + list);
// Integer integer = panDuanGZ("88899935");
// System.out.println("integer = " + integer);
Integer integer = countValue("3333", 4);
System.out.println("integer = " + integer);
// List<String> allMakeUp = getAllMakeUp("12345".split(""), 4, 0);
// System.out.println("allMakeUp = " + allMakeUp);
List<Poker> poker = getPoker("WwX9998433333", 4, 5);
System.out.println("poker = " + poker);
// Integer integer = panDuanGZ("9999");
// System.out.println("integer = " + integer);
}
}
四。ai思维类
这里我们就用一个ai思维实例类来介绍（只做了这一版，其他的要不是太简单，要不就是没做完）
1.ai思维介绍
主要是围绕这个逻辑来写的，当然这是一个非常笨的ai，并不会更具桌面信息来判断出牌
但是没有关系，下代ai再说（大概思维是会先枚举出所有出牌种类，然后更具每次的桌面变化更新这个枚举，再选择步数最少或让队友出牌规则来出牌，当然这个应该近期没时间去弄了）
/**
* 接拍
* 对手出牌，能接必街
* 对有出牌，不接
*
* 先手
* 出牌顺序，飞机 -》连对 -> 三带 -》顺子 —》对子 -》 单排 -》炸弹
*
* 出三带时，判断是否为 222
* 是 判断手牌数量，为4出 不为4不出（最后一手才出222）
*
* 出对子时，判断是否为 22
* 是 判断手牌数量，为2出，不为2不出（最后一手才出22）
*
* 当手上有对应类型的牌，但又没有能打过对方的牌时
* 判断手上炸弹数量
* == 1 当对方的手牌 <= 2 时出，否则不出
* > 1 出
*
* 接拍逻辑
* 最大牌为对手，下家也为对手，说明队友 不要，尽可能接
*
* 最大牌为对手，下家为队友，说明自己先接牌，
* 若出牌为对子，单排，排除其他类型牌接
* 若对手牌 <= 2 出炸弹
* 若手上炸弹 >= 2 可出炸弹
*
* 最大牌为队友，下家为队友，不接
*
* 最大牌为队友，下家为对手，
* 牌型不为单牌，对子，不接
* 为单牌，对子，排除自己的飞机，连对，三带，顺子
*
* 同类型牌种 优先选择长度 长的，面值小的
*/
2.不想废话了直接上代码
package com.fxp.linuxdemo.game.poker.ai;
import com.fxp.linuxdemo.domain.bean.Poker;
import com.fxp.linuxdemo.game.poker.*;
import lombok.Data;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
/**
* @Author: fxp
* @Date: 2023/3/24 10:49
* @Description
*/
@Data
public class Ai_3 extends Ai {
/**
* 接拍
* 对手出牌，能接必街
* 对有出牌，不接
*
* 先手
* 出牌顺序，飞机 -》连对 -> 三带 -》顺子 —》对子 -》 单排 -》炸弹
*
* 出三带时，判断是否为 222
* 是 判断手牌数量，为4出 不为4不出（最后一手才出222）
*
* 出对子时，判断是否为 22
* 是 判断手牌数量，为2出，不为2不出（最后一手才出22）
*
* 当手上有对应类型的牌，但又没有能打过对方的牌时
* 判断手上炸弹数量
* == 1 当对方的手牌 <= 2 时出，否则不出
* > 1 出
*
* 接拍逻辑
* 最大牌为对手，下家也为对手，说明队友 不要，尽可能接
*
* 最大牌为对手，下家为队友，说明自己先接牌，
* 若出牌为对子，单排，排除其他类型牌接
* 若对手牌 <= 2 出炸弹
* 若手上炸弹 >= 2 可出炸弹
*
* 最大牌为队友，下家为队友，不接
*
* 最大牌为队友，下家为对手，
* 牌型不为单牌，对子，不接
* 为单牌，对子，排除自己的飞机，连对，三带，顺子
*
* 同类型牌种 优先选择长度 长的，面值小的
*/
{
setType(3);
}
/**
* 正则 X 出现 N 次
*/
private static final String CANONICAL_XN = "(X)\\1{N}";
/**
* 正则三个
*/
private static final String CANONICAL_XXX = "([2-9XJQKA\\*])\\1{2}";
private static final List<Integer> yxsx = new ArrayList<Integer>(){
{
add(7);
add(6);
add(3);
add(5);
add(2);
add(1);
add(4);
}
};
private static final List<String> notOutBigPoke = new ArrayList<String>(){
{
add("2");
add("W");
add("w");
}
};
@Override
public String outPoker(OutPokerVo vo) {
TableTopInformation tableTopInformation = getTableTopInformation();
Player next = tableTopInformation.nextPlayer(getName());
Map<String, Integer> troopsMap = tableTopInformation.getTroopsMap();
Map<String, List<Poker>> playerPokerMap = tableTopInformation.getPlayerPokerMap();
Map<String, Integer> surplusPokerMap = getSurplusPokerMap(playerPokerMap);
List<Poker> myPoker = playerPokerMap.get(getName());
String max = vo.getMax();
Integer type = PokerPanDuan.panDuanGZ(max);
String s = vo.getS();
String maxPlayer = vo.getMaxPlayer();
if ("".equals(max)){
//先手出牌
List<Poker> pokers = new ArrayList<>();
for (Integer integer : yxsx) {
List<Poker> poker = PokerPanDuan.getPoker(s, integer, 5);
if ((integer == 3 && s.length() != 4) || (integer == 2 && s.length() != 2)){
removePoker(poker,"2",integer);
}
if (null != poker && poker.size() != 0){
pokers = poker;
break;
}
}
pokers = pokers.stream().sorted(Comparator.comparing(Poker::getSize).reversed().thenComparing(Poker::getValue)).collect(Collectors.toList());
Poker poker = pokers.get(0);
return poker.getName();
}
else {
//接牌
Integer integer1 = troopsMap.get(maxPlayer);
Integer integer2 = troopsMap.get(getName());
Integer integerNext = troopsMap.get(next.getName());
//最大牌为队友，下家为队友，不接
if (integer1.equals(integer2) && integer2.equals(integerNext)){
return "-";
}
//最大牌为队友，下家为对手，
// * 牌型不为单牌，对子，不接
// * 为单牌，对子，且为 A,2,W,w 时不接
// 排除自己的飞机，连对，三带，顺子
//
if (integer1.equals(integer2) && !integer2.equals(integerNext)){
if (!(type == 1 || type == 2)){
return "-";
}else {
String[] split = max.split("");
for (String s1 : split) {
if (notOutBigPoke.contains(s1)){
return "-";
}
}
s = getRemovePoker(myPoker,4,7,6,3,5);
}
}
//最大牌为对手，下家为队友，说明自己先接牌，
// * 若出牌为对子，单排，排除其他类型牌接
if (!integer1.equals(integer2) && integer2.equals(integerNext)){
if (type == 1 || type == 2){
s = getRemovePoker(myPoker,4,7,6,3,5);
}
}
if (null == type){
type = PokerPanDuan.panDuanGZ(max);
}
Integer integer = PokerPanDuan.countValue(max, type);
List<Poker> poker = PokerPanDuan.getPoker(s, type, 5);
Boolean chaXun4 = false;
if (type != 4 && poker.size() == 0){
poker = PokerPanDuan.getPoker(s, 4, 5);
chaXun4 = true;
}
if (null == poker || poker.size() == 0){
return "-";
}else {
poker = poker.stream().sorted(Comparator.comparing(Poker::getValue)).collect(Collectors.toList());
for (Poker poker1 : poker) {
if (poker1.getValue() > integer){
Boolean b = (poker1.getType() == 5 || poker1.getType() == 6) && poker1.getName().length() != max.length();
if (b){
continue;
}
return poker1.getName();
}
}
if (!chaXun4){
poker = PokerPanDuan.getPoker(s, 4, 5);
if (null == poker || poker.size() == 0){
return "-";
}else {
poker = poker.stream().sorted(Comparator.comparing(Poker::getValue)).collect(Collectors.toList());
if (poker.size() == 1){
Integer integer3 = surplusPokerMap.get(maxPlayer);
if (integer3 <= 2){
if (poker.get(0).getValue() > integer){
return poker.get(0).getName();
}
}
}else {
for (Poker poker1 : poker) {
if (poker1.getValue() > integer){
return poker1.getName();
}
}
}
}
}
}
}
return "-";
}
@Override
public Boolean robDiZhu(String s) {
return null;
}
public void removePoker(List<Poker> poker,String num,Integer type){
Iterator<Poker> iterator = poker.iterator();
while (iterator .hasNext()) {
Poker p = iterator .next();
Pattern pattern = Pattern.compile(CANONICAL_XN.replace("X",num).replace("N",(type-1) + ""));
Matcher matcher = pattern.matcher(p.getName());
if (matcher.find()){
iterator.remove();
}
}
}
/**
* 获取排除后的牌
* pokers 当前牌
* type 要排除的类型
*/
public String getRemovePoker(List<Poker> pokers,Integer... types){
String newS = getPokerStr(pokers);
List<Poker> newP = getPokerList(newS);
for (Integer type : types) {
newS = getRemovePoker(newP,type);
newP = getPokerList(newS);
}
return newS;
}
/**
* 获取排除后的牌
* pokers 当前牌
* type 要排除的类型
*/
public String getRemovePoker(List<Poker> pokers,Integer type){
String newS = "";
String s = getPokerStr(pokers);
List<Poker> newPokerList = getPokerList(s);
List<Poker> poker = PokerPanDuan.getPoker(s, type, 5);
String outStr = createOutStr(poker, type);
outPoker(newPokerList,outStr);
newS = getPokerStr(newPokerList);
return newS;
}
public List<Poker> getPokerList(String s){
List<Poker> pokers = new ArrayList<>();
String[] split = s.split("");
for (String s1 : split) {
Poker poker = new Poker();
poker.setName(s1);
poker.setShow(true);
pokers.add(poker);
}
return pokers;
}
public String getPokerStr(List<Poker> pokers){
StringBuilder s = new StringBuilder("");
for (Poker poker : pokers) {
if (poker.getShow()){
s.append(poker.getName());
}
}
return s.toString();
}
public Boolean outPoker(List<Poker> pokers,String s){
Boolean b = true;
String[] split = s.split("");
List<Poker> updateList = new ArrayList<>();
for (String s1 : split) {
for (Poker poker : pokers) {
if (poker.getName().equals(s1) && poker.getShow()){
updateList.add(poker);
poker.setShow(false);
break;
}
}
}
return b;
}
/**
* 生成排除的牌str
* @param pokers
* @param type
* @return
*/
public String createOutStr(List<Poker> pokers,Integer type){
StringBuilder s = new StringBuilder("");
if (type == 6){
Set<String> set = new HashSet<>();
for (Poker poker : pokers) {
String name = poker.getName();
String[] split = name.split("");
for (int i = 0; i < split.length; i += 2) {
set.add(split[i]+split[i+1]);
}
}
for (String s1 : set) {
s.append(s1);
}
}
else if (type == 5){
Set<String> set = new HashSet<>();
for (Poker poker : pokers) {
String name = poker.getName();
String[] split = name.split("");
for (int i = 0; i < split.length; i++) {
set.add(split[i]);
}
}
for (String s1 : set) {
s.append(s1);
}
}
else if (type == 7 || type == 3){
Set<String> set = new HashSet<>();
for (Poker poker : pokers) {
Pattern pattern = Pattern.compile(CANONICAL_XXX);
Matcher matcher = pattern.matcher(poker.getName());
while (matcher.find()){
set.add(matcher.group());
}
}
for (String s1 : set) {
s.append(s1);
}
}
else {
for (Poker poker : pokers) {
s.append(poker.getName());
}
}
return s.toString();
}
private Map<String,Integer> getSurplusPokerMap(Map<String, List<Poker>> playerPokerMap){
if (null != surplusPokerMap){
return surplusPokerMap;
}
Map<String,Integer> surplusPokerMap = new HashMap<>(3);
for (String s : playerPokerMap.keySet()) {
List<Poker> pokers = playerPokerMap.get(s);
int size = pokers.stream().filter(a -> a.getShow()).collect(Collectors.toList()).size();
surplusPokerMap.put(s,size);
}
return surplusPokerMap;
}
private Map<String,Integer> surplusPokerMap;
public static void main(String[] args) {
Ai_3 ai = new Ai_3();
ai.setName("1");
TableTopInformation tableTopInformation = new TableTopInformation();
Map<String,Integer> map = new HashMap<>();
map.put("2",0);
map.put("1",2);
map.put("3",2);
tableTopInformation.setTroopsMap(map);
Map<String,Integer> map1 = new HashMap<>();
map1.put("2",13);
List<Player> playerList = new ArrayList<>();
playerList.add(Player.builder().name("2").build());
playerList.add(Player.builder().name("3").build());
playerList.add(Player.builder().name("1").build());
tableTopInformation.setPlayerList(playerList);
Map<String,List<Poker>> pokerMap = new HashMap<>();
pokerMap.put("1",ai.getPokerList("QQQQQX9998433"));
tableTopInformation.setPlayerPokerMap(pokerMap);
ai.setSurplusPokerMap(map1);
ai.setTableTopInformation(tableTopInformation);
String s = ai.outPoker(OutPokerVo.builder().s("9877776666").max("").maxPlayer("").build());
System.out.println("s = " + s);
}
}
943
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
