斗地主Console显示版

原创 2017年08月09日 20:23:20

斗地主:字符串+正则的简单实现


缘由:听同学说学了集合后,就可以基本实现斗地主功能,一开始听到觉得不可能吧,后面就认真构想了一下,觉得如果加上正则匹配扑克牌出牌规则,实现斗地主是可以的,只不过没有图形界面,只能在终端一个人玩,觉得写出来了也挺有意思的,于是我就开始斗地主的编写(ps:写了很久)。
自己测试很多次,没有发现什么bug。
如果有什么逻辑没考虑到,或者优化的地方希望评论告诉我,共同学习,共同进步(^_^)。

整体思路概述:

    1:生成扑克牌,给玩家随机发牌
        1.1:利用扑克牌字符串与索引一一对应关系,通过随机给玩家发索引,然后根据玩家的索引获取牌,来达到给玩家随机发牌的效果。
    2:轮流出牌
        2.1利用循环实现玩家轮流出牌,对每个玩家的出牌进行校验:
                a是否为扑克牌校验,
                b是否是来自玩家自己手中的牌,
                c正则匹配是否符合出牌规则,记录对应牌数据:牌的类型,和牌的大小
        2.2下一个玩家出牌(玩家可选择出牌或跳过),校验成功后,对牌类型和大小比较,满足出牌大小条件,则继续下一个玩家。(注:玩家选择跳过,跳过两次表示其它玩家要不起,那么则需要重置牌记录的数据)
    说明:
        1:3带1不能带一对牌,下面的正则匹配时:一对牌当作2个单牌匹配
        2:没把连炸弹带牌(333344445678)考虑进去
        3:可以把正则匹配方法单独提取出来测试牌    

下面是代码:

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class FightLandlord {
    private static Scanner sc;
    private static int skip = 0;// 记录玩家跳过的次数
    private static String name = "";// 玩家名字

    public static void main(String[] args) {
        playPoker();
    }

    // 修改:遍历拼接时直接添加到Map集合中
    public static void playPoker() {
        ArrayList<String> p1 = new ArrayList<String>();// 玩家1集合
        ArrayList<String> p2 = new ArrayList<String>();// 玩家2集合
        ArrayList<String> p3 = new ArrayList<String>();// 玩家3集合

        // -----------方法1: 根据字符串索引给玩家发牌-----------
        indexStringPoker(p1, p2, p3);
        String beforeW = "beforeW";// 初始玩家先出牌字符串
        String afterW = "afterW";// 初始玩家:后出牌字符串
        System.out.println("出牌简化:'0'代表 牌'10','小'='小☺',大='大☻',e代表跳过,忽略了大小写.(注:输入其它非扑克牌字符也是默认跳过:1,你...)");
        while (true) {
            // -----------方法2: 循环判断玩家出牌是否合理-----------
            name = "地主 p1_";// 玩家名提示
            beforeW = loopSyso(p1, beforeW, afterW, name);// 4
            name = "农民 p2_";
            beforeW = loopSyso(p2, beforeW, afterW, name);
            name = "农民 p3_";
            beforeW = loopSyso(p3, beforeW, afterW, name);
        }
    }

    // -------------------------------方法1-1:根据字符串索引给玩家发牌-------------------------------
    public static void indexStringPoker(ArrayList<String> p1, ArrayList<String> p2, ArrayList<String> p3) {
        // 为了方便排序,临时替换: a替换0 b=j c=q d=k e=A f=2 小=g 大=h;
        String cards = "3♣3♠3♥3♦4♣4♠4♥4♦5♣5♠5♥5♦6♣6♠6♥6♦7♣7♠7♥7♦8♣8♠8♥8♦9♣9♠9♥9♦a♣a♠a♥a♦b♣b♠b♥b♦c♣c♠c♥c♦d♣d♠d♥d♦e♣e♠e♥e♦f♣f♠f♥f♦g☺h☻";
        ArrayList<Integer> key = new ArrayList<Integer>();// key集合=对应牌索引
        for (int i = 0; i < 54; i++) {// 给集合添加内容:(0-53)
            key.add(i);
        }
        Collections.shuffle(key);// 打乱键(索引)=打乱牌
        // 给玩家添加牌
        for (int i = 0; i < 54; i++) {
            int index = key.get(i);
            if (i < 20)
                p1.add(cards.substring(2 * index, 2 * (index + 1)));
            if (20 <= i && i < 37)
                p2.add(cards.substring(2 * index, 2 * (index + 1)));
            if (i >= 37)
                p3.add(cards.substring(2 * index, 2 * (index + 1)));
        }
        // -----------方法1-1-1: 替换回来-->a替换0 b=j c=q d=k e=A f=2-----------
        replaceSort(p1);
        replaceSort(p2);
        replaceSort(p3);
        System.out.println("p1: " + p1 + p1.size());
        System.out.println("p2: " + p2 + p2.size());
        System.out.println("p3: " + p3 + p3.size());
    }

    // ----------------------方法1-1-1:建字符串替换回来,并转换为数组----------------------
    public static void replaceSort(ArrayList<String> p) {
        Collections.sort(p);// 对玩家牌排序
        String ps = p.toString();// 转换为字符串
        ps = ps.replaceAll("a", "0");
        ps = ps.replaceAll("b", "J");
        ps = ps.replaceAll("c", "Q");
        ps = ps.replaceAll("d", "K");
        ps = ps.replaceAll("e", "A");
        ps = ps.replaceAll("f", "2");
        // 必须完全排序,否则j索引跳过顺序混乱的牌.---->大小-->遍历时,j直接累加到了"大",最后的索引.当再依次遍历到小的时候.在大之后索引查找,找不到了
        ps = ps.replaceAll("g", "小");
        ps = ps.replaceAll("h", "大");
        ps = ps.replaceAll("[\\[\\]]", "");// 去除前后大括号
        String[] split = ps.split(",");// 转化为数组
        for (int i = 0; i < split.length; i++) {
            p.set(i, split[i]);
        }
    }

    // ------------------------方法2:循环出牌-------------------------------
    public static String loopSyso(ArrayList<String> p, String beforeW, String afterW, String name) {
        sc = new Scanner(System.in);
        // 接收玩家牌,判断
        w: while (true) {
            System.out.print(name + p + "\n\t\t" + name + "出牌:");
            afterW = sc.next();// 接收玩家的出牌

            // -----------方法2-1: 对玩家输入的牌进行排序-----------
            afterW = diySortString(afterW);
            if (afterW.contains("E")) {
                skip++;
                if (skip == 3) {
                    System.out.println("跳过一轮");
                    skip = 0;
                }
                System.out.print("_______________________________" + name + "跳过:" + skip + "次______________________\n");
                return beforeW;// 返回上家的牌
            }

            // 遍历玩家输入的字符串,记录对应牌索引()
            int[] pcopyI = new int[afterW.length()];// 默认为0
            int j = -1;// 记录上次遍历到的索引位置
            f: for (int i = 0; i < afterW.length(); i++) {// 遍历玩家字符串
                String s1 = afterW.substring(i, i + 1);// 拿到玩家字符串的每个字符
                // 不回头遍历:必须有序
                for (j++; j < p.size(); j++) {// 遍历玩家p牌对应的字符数组
                    String s = p.get(j);
                    if (s.contains(s1)) {// 对比是否有相同的牌: "3♣"包含3,匹配成功
                        pcopyI[i] = j;// 记录牌中被替换对应的索引
                        continue f;// 跳转到外循环,匹配下一个字符
                    }
                }
                System.out.println("你输入的牌有不存在的,请重新输入");
                continue w;// 有不匹配字符,则跳转到开始:提示玩家重新输入
            }

            // ----------方法2-2:校验比较牌大小------
            int[] w1 = regexMatches(beforeW);// 获取玩家"牌数据"(出牌类型,及对应出牌大小)
            // 都跳过,玩家可自定义出牌---位置必须放在w1=后用于重置array"牌数据"
            if (skip == 2) {// 跳过2次,说明其它玩家都不要,那么"牌数据"还原为初始值
                w1[0] = -1;
                w1[1] = 0;
            }
            // 当前玩家出牌
            int[] w1c = regexMatches(afterW);
            if (w1c[0] == -2) {// 牌不符合规则的终止条件:终止
                continue;// -->玩家重新输入
            }
            System.out.println("前类型=" + w1[1] + ",后类型=" + w1c[1] + ", 前:=" + w1[0] + ",后=" + w1c[0]);

            // 比较类型
            if (w1[1] == w1c[1] | w1c[1] == 10000 | w1[1] == 0) {
                if (w1[0] >= w1c[0]) {// 比较牌大小
                    w1c[0] = w1[0];// 还原上家牌索引
                    w1c[1] = w1[1];// 还原上家牌类型
                    System.out.println("要不起,请重新选择牌");
                    continue;
                }
            } else {// 类型不满足
                w1c[1] = w1[1];
                w1c[0] = w1[0];
                System.out.println("类型不匹配,请重新出牌");
                continue;
            }
            // 当玩家不是连续输入重置跳过次数=位置需在skip==2后//中间玩家输错,不至于更改
            if (!afterW.contains("E")) {
                skip = 0;
            }
            // 显示出牌
            System.out.print("________________________________" + name + afterW + "________________________\n");
            // 移除牌
            for (int i = 0; i < pcopyI.length; i++) {
                p.set(pcopyI[i], "");
            }
            break w;// 出牌成功跳出循环
        }
        // ---------------------------------判断玩家是否出完牌--------------------------
        for (int i = 0; i < p.size(); i++) {
            if (!p.get(i).equals("")) {
                break;
            }
            if (i == (p.size() - 1)) {
                System.out.println("________________________________" + name + " 先出完牌,game over");
                System.exit(3000);
                // return "over";//返回该上一层,判断是否退出
            }
        }
        beforeW = afterW;// 内存地址
        return beforeW;// 默认值
    }

    // -----------方法2-1:对用户输入的字符串进行排序-----------
    public static String diySortString(String str) {
        str = str.toUpperCase();// 忽略大小写
        String sortS = "34567890JQKA2小☺大☻";// 指定排序规则字符串
        if (!str.matches("[" + sortS + "]+")) {// 匹配是否非扑克牌字符,是跳过
            return "E";
        }
        ArrayList<Integer> strA = new ArrayList<Integer>();
        for (int i = 0; i < str.length(); i++) {
            strA.add(sortS.indexOf(str.charAt(i)));// 匹配待排序字符串中的每个字符,对应在规则字符串中的索引,并添加
        }
        Collections.sort(strA);// 将字符的索引从小到大排序
        String sortWp = "";
        for (int i = 0; i < strA.size(); i++) {
            sortWp = sortWp + sortS.charAt(strA.get(i));// 通过索引获取对应字符
        }
        return sortWp;
    }

    // ------------------------方法2-2: 正则表达式-------------------

    public static int[] regexMatches(String wp) {
        int[] array = { -1, 0 };// 初始"牌数据"
        String sCards = "34567890JQKA2小大";// 单牌=规则大小牌
        String linkCards1 = "34567890JQKA";// 单连牌
        String linkCards2 = "3344556677889900JJQQKKAA";// 对连牌
        String linkCards3 = "333444555666777888999000JJJQQQKKKAAA";// 3连牌
        String linkCards4 = "33334444555566667777888899990000JJJJQQQQKKKKAAAA";// 4连牌

        // 匹配出牌属于哪一类型
        int index = -1;
        if (wp.length() == 1) {
            index = sCards.indexOf(wp);
            array[0] = index;
            array[1] = 1;
            return array;// 单牌
        } else if (linkCards1.contains(wp) && wp.length() > 4) {
            index = linkCards1.indexOf(wp);
            array[0] = index;
            array[1] = 11;
            return array;// 单连牌
        } else if (wp.matches("(.)\\1")) {
            index = sCards.indexOf(wp.charAt(0));
            array[0] = index;
            array[1] = 2;
            return array;// 对牌
        } else if (linkCards2.contains(wp) && wp.length() > 5 && linkCards2.indexOf(wp) % 2 == 0) {
            index = linkCards2.indexOf(wp);
            array[0] = index;
            array[1] = 21;
            return array;// 对连牌
        } else if (wp.matches("(.)\\1\\1")) {
            index = linkCards3.indexOf(wp);
            array[0] = index;
            array[1] = 3;
            return array;// 三牌
        } else if (!wp.matches("(.)\\1{3}") && (wp.matches(".(.)\\1\\1")) | wp.matches("(.)\\1\\1.")) {// 防止误匹配4个相同的
            index = sCards.indexOf(wp.charAt(2));// 获取中间字符值,对应规则字符串中的索引,作为比较
            array[0] = index;
            array[1] = 31;
            return array;// 三带一
        } else if (linkCards3.contains(wp) && linkCards3.indexOf(wp) % 3 == 0 && wp.length() > 5) {
            index = linkCards3.indexOf(wp);
            array[0] = index;
            array[1] = 33;
            return array;// 三连牌
        } else if (wp.length() > 7 && linkCards3.contains(wp.replaceAll("[" + wp.replaceAll("(.)\\1\\1", "") + "]", ""))
                && wp.replaceAll("[" + wp.replaceAll("(.)\\1\\1", "") + "]", "").length() / 3 == wp
                        .replaceAll("(.)\\1\\1", "").length()) {
            // 长度8 12 // 满足连续关系// 三带1模式:匹配3个相同的数量/3等于额外数 ==4的倍数
            index = linkCards3.indexOf(wp.replaceAll("[" + wp.replaceAll("(.)\\1\\1", "") + "]", ""));
            array[0] = index;
            array[1] = 3311;
            return array;// 飞机
        } else if (linkCards4.contains(wp) && linkCards3.indexOf(wp) % 4 == 0) {
            array[0] = linkCards4.indexOf(wp);
            array[1] = 44;
            return array;// 四连牌
        } else if (wp.matches("(.)\\1{3}.{2}") | wp.matches("..(.)\\1{3}")) {
            index = sCards.indexOf(wp.charAt(2));// 44|5555|66
            array[0] = index;
            array[1] = 42;
            return array;// 四带二
        } else if (wp.matches("(.)\\1{3}") | wp.equals("小大")) {
            index = sCards.indexOf(wp.charAt(0));
            array[0] = index;
            array[1] = 10000;
            return array;// 炸弹
        } else {
            if (wp.matches("beforeW")) {// 初始值,则返回默认类型
                return array;
            } else {
                System.out.println("你输入的牌不符合规则");
                array[0] = -2;// 用于终止继续执行条件
                return array;
            }
        }
    }
}

u3d联机斗地主(1):出牌规则

1出牌类型 enum CardType { None = 0, One = 1, Two = 2, Three = 3,...
  • luoyikun
  • luoyikun
  • 2017年01月09日 22:46
  • 970

UOJ #151. 【NOIP2015】斗地主“加强”版【搜索+贪心

去年写了一遍,今天再写写试试233 当时是照着某beiyu大爷的代码人工ctrl+c,ctrl+v的233333,于是今年自己写一遍【毕竟每天考试都有暴搜/模拟题 …………忽然发现自己没有剪枝...
  • Flaze_
  • Flaze_
  • 2016年11月05日 13:18
  • 372

【源码】斗地主人机对战程序算法2012完整版

点宽即时通讯(DOTWIDE)通讯员(陈飞飞),我尽情享受阳光的照射和海风的吹拂,我连忙按键盘,我最喜欢的就是小马车了,妈妈带我去乡下奶奶家,雨水在树叶上留下了亮晶晶的小水珠,可美了,原来是谭老师邀请...
  • i_like_cpp
  • i_like_cpp
  • 2012年12月13日 12:00
  • 2595

[Android]单机斗地主,破解版,无广告

去除了其中的下载服务及通知信息,请点击这里下载 下载地址: 【北方网通】    【电信网通】 【下载说明】 1 点击上面的地址,打开下载页面 2 点击"普通下载"--等待30秒--点击"下...
  • pengqianhe
  • pengqianhe
  • 2012年12月20日 10:10
  • 14112

纯JAVA写的socket局域网斗地主游戏

前两天没项目做,就想着写点什么。 就写了这个小游戏没事跟同事玩玩。 5块钱一把,不带开挂的。 先来几张效果图 废话不多,开篇纪念。 部分源码 连接服务器类 publ...
  • laigezao
  • laigezao
  • 2018年02月08日 11:47
  • 5418

IOS游戏辅助--QQ欢乐斗地主记牌器的实现

转:http://bbs.pediy.com/showthread.php?p=1272700#post1272700 标 题: 【原创】IOS游戏辅助--QQ欢乐斗地主记牌器的实现 作 ...
  • zhangmiaoping23
  • zhangmiaoping23
  • 2016年11月12日 00:47
  • 1393

斗地主-源码集锦

#pragma once #include "MySprite.h" USING_NS_CC; class HelloWorld : public cocos2d::CCLayer { public:...
  • cb2688he2688
  • cb2688he2688
  • 2015年07月23日 20:31
  • 1925

java案例-实现斗地主游戏案例

java案例-实现斗地主游戏案例 1.需求分析: 模拟斗地主游戏,利用集合,Map实现斗地主的逻辑,并且可以看分派好的牌 2.具体实现: (1)在牌盒(字符串数组)存储四个花色: ...
  • Ag_nevergiveup
  • Ag_nevergiveup
  • 2017年05月18日 10:54
  • 1378

[真格邦]JAVA实战-三人斗地主

要求:模拟实现三人一副牌斗地主 分析: 一、面向对象分析:完成斗地主要建几个类?...
  • ysyneusoft
  • ysyneusoft
  • 2016年12月22日 14:50
  • 895

cocos2dx《单机斗地主》源码解剖之一 创建一副扑克牌(54张)

本项目基于cocos2dx引擎开发,根据网上搜索的斗地主文案(参见博客:斗地主规则)由本人独立完成,废话少说(本人不善言辞,我也说不出来什么废话)下面我来做个项目总结。 1.创建一副扑克牌,写代码首先...
  • oiy37215
  • oiy37215
  • 2015年02月12日 16:59
  • 3984
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:斗地主Console显示版
举报原因:
原因补充:

(最多只允许输入30个字)