斗地主算法的设计与实现(二)--如何判断一手牌的类型(单,对子,三不带,三带一,四代二等)

最新推荐文章于 2023-07-06 00:00:00 发布
最新推荐文章于 2023-07-06 00:00:00 发布
阅读量2.2w 收藏 33
点赞数 13
分类专栏： 中国象棋-斗地主 斗地主算法的设计与实现 文章标签： 斗地主 游戏 算法 牌型 项目研发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FansUnion/article/details/12564949
版权

本篇主要讲解斗地主中如何判断一手牌的牌型。

牌型
　　火箭：即双王（大王和小王），最大的牌。
　　炸弹：四张点数相同的牌，如：7777。
　　单牌：任意一张单牌。
　　对牌：任意两张点数相同的牌。
　　三张：任意三张点数相同的牌，如888。
　　三带一：点数相同的三张牌+一张单牌或一对牌。如：333+6 或 444+99。
　　单顺：任意五张或五张以上点数相连的牌，如：45678或78910JQK。不包括 2和双王。
　　双顺：三对或更多的连续对牌，如：334455、7788991010JJ。不包括 2 点和双王。
　　三顺：二个或更多的连续三张牌，如：333444 、555666777888。不包括 2 点和双王。
　　飞机带翅膀：三顺＋同数量的单牌或同数量的对牌。如：444555+79 或333444555+7799JJ
　　四带二：四张牌＋两手牌。（注意：四带二不是炸弹）。如：5555＋3＋8 或 4444＋55＋77 。


友情提示：本篇是接着上1篇讲述的，建议先看看上1篇一张牌Card的构造过程。

斗地主算法的设计与实现--项目介绍&如何定义和构造一张牌

http://blog.csdn.net/fansunion/article/details/12516411

/**
 * 游戏规则 牌的类型共有10种：
 *
 * 1. 单 2.对子 3.3不带 4.3带1 5.炸弹 6.顺子 7.4带2 8.连队 9.飞机 10.对王
 *
 * @author LeiWen@FansUnion.cn,http://FansUnion.cn,
 *         http://blog.csdn.net/FansUnion
 *
 */

1.单

 

  /**
     * 判断牌是否为单
     *
     * @param myCards
     *            牌的集合
     * @return 如果为单，返回true；否则，返回false。
     */
    public static boolean isDan(List<Card> myCards) {
        // 默认不是单
        boolean flag = false;
        if (myCards != null && myCards.size() == 1) {
            flag = true;
        }
        return flag;
    }


2.对子

    

/**
     * 判断牌是否为对子
     *
     * @param myCards
     *            牌的集合
     * @return 如果为对子，返回true；否则，返回false。
     */
    public static boolean isDuiZi(List<Card> myCards) {
        // 默认不是对子
        boolean flag = false;

        if (myCards != null && myCards.size() == 2) {

            int grade1 = myCards.get(0).grade;
            int grade2 = myCards.get(1).grade;
            if (grade1 == grade2) {
                flag = true;
            }
        }

        return flag;

    }


3.3带1

    /**
   

  * 判断牌是否为3带1
     *
     * @param myCards
     *            牌的集合
     * @return 如果为3带1，被带牌的位置，0或3，否则返回-1。炸弹返回-1。
     */
    public static int isSanDaiYi(List<Card> myCards) {
        int flag = -1;
        // 默认不是3带1
        if (myCards != null && myCards.size() == 4) {
            // 对牌进行排序
            CardUtil.sortCards(myCards);

            int[] grades = new int[4];
            grades[0] = myCards.get(0).grade;
            grades[1] = myCards.get(1).grade;
            grades[2] = myCards.get(2).grade;
            grades[3] = myCards.get(3).grade;

            // 暂时认为炸弹不为3带1
            if ((grades[1] == grades[0]) && (grades[2] == grades[0])
                    && (grades[3] == grades[0])) {
                return -1;
            }
            // 3带1，被带的牌在牌头
            else if ((grades[1] == grades[0] && grades[2] == grades[0])) {
                return 0;
            }
            // 3带1，被带的牌在牌尾
            else if (grades[1] == grades[3] && grades[2] == grades[3]) {
                return 3;
            }
        }
        return flag;
    }


4.3不带

   

 /**
     * 判断牌是否为3不带
     *
     * @param myCards
     *            牌的集合
     * @return 如果为3不带，返回true；否则，返回false。
     */
    public static boolean isSanBuDai(List<Card> myCards) {
        // 默认不是3不带
        boolean flag = false;

        if (myCards != null && myCards.size() == 3) {
            int grade0 = myCards.get(0).grade;
            int grade1 = myCards.get(1).grade;
            int grade2 = myCards.get(2).grade;

            if (grade0 == grade1 && grade2 == grade0) {
                flag = true;
            }
        }
        return flag;
    }


5.顺子

   

 /**
     * 判断牌是否为顺子
     *
     * @param myCards
     *            牌的集合
     * @return 如果为顺子，返回true；否则，返回false。
     */
    public static boolean isShunZi(List<Card> myCards) {
        // 默认是顺子
        boolean flag = true;

        if (myCards != null) {

            int size = myCards.size();
            // 顺子牌的个数在5到12之间
            if (size < 5 || size > 12) {
                return false;
            }

            // 对牌进行排序
            CardUtil.sortCards(myCards);

            for (int n = 0; n < size - 1; n++) {
                int prev = myCards.get(n).grade;
                int next = myCards.get(n + 1).grade;
                // 小王、大王、2不能加入顺子
                if (prev == 17 || prev == 16 || prev == 15 || next == 17
                        || next == 16 || next == 15) {
                    flag = false;
                    break;
                } else {
                    if (prev - next != -1) {
                        flag = false;
                        break;
                    }

                }
            }
        }

        return flag;
    }


6.炸弹

    

/**
     * 判断牌是否为炸弹
     *
     * @param myCards
     *            牌的集合
     * @return 如果为炸弹，返回true；否则，返回false。
     */
    public static boolean isZhaDan(List<Card> myCards) {
        // 默认不是炸弹
        boolean flag = false;
        if (myCards != null && myCards.size() == 4) {

            int[] grades = new int[4];
            grades[0] = myCards.get(0).grade;
            grades[1] = myCards.get(1).grade;
            grades[2] = myCards.get(2).grade;
            grades[3] = myCards.get(3).grade;
            if ((grades[1] == grades[0]) && (grades[2] == grades[0])
                    && (grades[3] == grades[0])) {
                flag = true;
            }
        }
        return flag;
    }


7.王炸

  

  /**
     * 判断牌是否为王炸
     *
     * @param myCards
     *            牌的集合
     * @return 如果为王炸，返回true；否则，返回false。
     */
    public static boolean isDuiWang(List<Card> myCards) {
        // 默认不是对王
        boolean flag = false;

        if (myCards != null && myCards.size() == 2) {

            int gradeOne = myCards.get(0).grade;
            int gradeTwo = myCards.get(1).grade;

            // 只有小王和大王的等级之后才可能是33
            if (gradeOne + gradeTwo == 33) {
                flag = true;
            }
        }
        return flag;
    }


8.连对

 

   /**
     * 判断牌是否为连对
     *
     * @param myCards
     *            牌的集合
     * @return 如果为连对，返回true；否则，返回false。
     */
    public static boolean isLianDui(List<Card> myCards) {
        // 默认是连对
        boolean flag = true;
        if (myCards == null) {
            flag = false;
            return flag;
        }
        
        int size = myCards.size();
        if (size < 6 || size % 2 != 0) {
            flag = false;
        } else {
            // 对牌进行排序
            CardUtil.sortCards(myCards);
            for (int i = 0; i < size; i = i + 2) {
                if (myCards.get(i).grade != myCards.get(i + 1).grade) {
                    flag = false;
                    break;
                }

                if (i < size - 2) {
                    if (myCards.get(i).grade - myCards.get(i + 2).grade != -1) {
                        flag = false;
                        break;
                    }
                }
            }
        }

        return flag;
    }


9.飞机

 

   /**
     * 判断牌是否为飞机
     *
     * @param myCards
     *            牌的集合
     * @return 如果为飞机，返回true；否则，返回false。
     */
    public static boolean isFeiJi(List<Card> myCards) {
        boolean flag = false;
        // 默认不是单
        if (myCards != null) {

            int size = myCards.size();
            if (size >= 6) {
                // 对牌进行排序
                CardUtil.sortCards(myCards);

                if (size % 3 == 0 && size % 4 != 0) {
                    flag = isFeiJiBuDai(myCards);
                } else if (size % 3 != 0 && size % 4 == 0) {
                    flag = isFeiJiDai(myCards);
                } else if (size == 12) {
                    flag = isFeiJiBuDai(myCards) || isFeiJiDai(myCards);
                }
            }
        }
        return flag;
    }


10.飞机不带

 

   /**
     * 判断牌是否为飞机不带
     *
     * @param myCards
     *            牌的集合
     * @return 如果为飞机不带，返回true；否则，返回false。
     */
    public static boolean isFeiJiBuDai(List<Card> myCards) {
        if (myCards == null) {
            return false;
        }

        int size = myCards.size();
        int n = size / 3;

        int[] grades = new int[n];

        if (size % 3 != 0) {
            return false;
        } else {
            for (int i = 0; i < n; i++) {
                if (!isSanBuDai(myCards.subList(i * 3, i * 3 + 3))) {
                    return false;
                } else {
                    // 如果连续的3张牌是一样的，记录其中一张牌的grade
                    grades[i] = myCards.get(i * 3).grade;
                }
            }
        }

        for (int i = 0; i < n - 1; i++) {
            if (grades[i] == 15) {// 不允许出现2
                return false;
            }

            if (grades[i + 1] - grades[i] != 1) {
                System.out.println("等级连续,如 333444"
                        + (grades[i + 1] - grades[i]));
                return false;// grade必须连续,如 333444
            }
        }

        return true;
    }


11.飞机带

   

 /**
     * 判断牌是否为飞机带
     *
     * @param myCards
     *            牌的集合
     * @return 如果为飞机带，返回true；否则，返回false。
     */
    public static boolean isFeiJiDai(List<Card> myCards) {
        int size = myCards.size();
        int n = size / 4;// 此处为“除”，而非取模
        int i = 0;
        for (i = 0; i + 2 < size; i = i + 3) {
            int grade1 = myCards.get(i).grade;
            int grade2 = myCards.get(i + 1).grade;
            int grade3 = myCards.get(i + 2).grade;
            if (grade1 == grade2 && grade3 == grade1) {

                // return isFeiJiBuDai(myCards.subList(i, i + 3 *
                // n));8张牌时，下标越界,subList不能取到最后一个元素
                ArrayList<Card> cards = new ArrayList<Card>();
                for (int j = i; j < i + 3 * n; j++) {// 取字串
                    cards.add(myCards.get(j));
                }
                return isFeiJiBuDai(cards);
            }

        }

        return false;
    }


12.4带2

  

  /**
     * 判断牌是否为4带2
     *
     * @param myCards
     *            牌的集合
     * @return 如果为4带2，返回true；否则，返回false。
     */
    public static boolean isSiDaiEr(List<Card> myCards) {
        boolean flag = false;
        if (myCards != null && myCards.size() == 6) {

            // 对牌进行排序
            CardUtil.sortCards(myCards);
            for (int i = 0; i < 3; i++) {
                int grade1 = myCards.get(i).grade;
                int grade2 = myCards.get(i + 1).grade;
                int grade3 = myCards.get(i + 2).grade;
                int grade4 = myCards.get(i + 3).grade;

                if (grade2 == grade1 && grade3 == grade1 && grade4 == grade1) {
                    flag = true;
                }
            }
        }
        return flag;
    }


下一篇，将要介绍 如何比较2手牌的大小，敬请期待。

 

相关阅读

斗地主算法的设计与实现

面向对象实现斗地主程序的核心算法，包括洗牌、发牌、判断牌型、比较牌的大小、游戏规则等。

 

原文参见：http://FansUnion.cn/articles/2716

小雷FansUnion
关注
  • 13
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 24
    评论
专栏目录
棋牌游戏判断牌型算法---适合所有的棋牌游戏
棋牌游戏开发
04-03 2万+
斗地主牌型基本算法升级版本 好久没更新博客了，前段时间和朋友一起开了一个公司 做APP，最后失败了。现在又开始做棋牌游戏了，最近在看网狐的源码，发现里面斗地主的基本算法太强大了，现在想想我原来的算法简直是弱爆了，分享一下 希望能对你有一点点帮助。以下主要涉及到判断牌型，牌型大小比较2块，如果你想了解更多关于棋牌游戏的东西请访问我的 棋牌游
跑得快—扑克牌游戏出牌规则(JavaScript)
林0507
11-01 1万+
第一次写这种棋牌出牌的规则。第一想到的是正则，花了两天时间写出来，反复调试，大致应该没有BUG。代码有点乱，但是具体注释都写了。 规则JS/** * Created by jialin on 2016/10/21. */ (function (window) { var r = {}; /** * 牌型定义： * 1.单张 *
斗地主牌型相关算法
03-02
lua实现斗地主中的牌型判断，牌的比较，出牌提示的算法
逻辑智力测试题
忘川
05-06 7616
（-19至75，共95道题） 【-19】在临上刑场前，国王对预言家说：“我给你一个机会，你可以预言一下今天我将如何处死你。你如果预言对了，我就让你服毒死；否则，我就绞死你。”但是聪明的预言家的回答，使得国王无法将他处死。 答：预言家说：我将被绞死。 析：简单的悖论。 【-18】有三个箱子，一个只装苹果，一个只装橙，另一个装苹果和橙。三个箱子上的标签都标错。你只打开一个箱子，不能看里面，你拿出...
枚举算法(暑期基础班)
m0_62784756的博客
07-06 387
尽可能多；因此你需要写一个程序，依次输入 �,�,�n,L,R，并输出你最多能获得多少。
网络收集的逻辑思维题
weixin_42330344的博客
01-20 1万+
一个有意思的逻辑训练题目 题目如下： 有两个大于1小于100的自然数x,y，老师告诉小明两个数的和，告诉小强两个数的积。已知小明和小强足够聪明。 下面是两个人的对话： 小强：我不知道这两个数是多少。（<沉默中>...） 小明：我知道你不知道。（我不知道这两个数是多少，而且你也不知道。） 小强：那我知道了。（你说的对，不过我现在知道了。） 小明：那我也知道啦。（额...那我也知道啦。） 问这两个数是多少？ PS.
Week9 作业——B - 东东学打牌
alicemh的博客
05-15 146
题目 最近，东东沉迷于打牌。所以他找到 HRZ、ZJM 等人和他一起打牌。由于人数众多，东东稍微修改了亿下游戏规则： 所有扑克牌只按数字来算大小，忽略花色。 每张扑克牌的大小由一个值表示。A, 2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K 分别指代 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13。 每个玩家抽得 5 张扑克牌，组成一手牌...
斗地主判断牌型源码
w36371的博客
11-21 3151
这是看着别人的代码写的，这样写虽然很全面，但是毫无条理，我吧牌型打完之后感觉很不好，所以放弃，我给每一段加了注释，贴出代码让大家看一看 using UnityEngine; using System.Collections; using System.Collections.Generic; using System; using System.Linq; /// /// 首先对手
斗地主牌型判断实现（一）
harryptter的专栏
10-12 1405
#ifndef GAME_LOGIC_HEAD_FILE #define GAME_LOGIC_HEAD_FILE #pragma once #include "Stdafx.h" ////////////////////////////////////////////////////////////////////////////////// //排序类型 #define ST_ORDE
地主算法之判断牌型
棋牌游戏开发
05-17 1万+
地主算法之判断牌型                   by  wojiushi3344                       QQ:513670524                  每个游戏都有属于自己的规则，当然地主也不例外，常斗地主的朋友可能知道在斗地主里面一共有13种牌型，你所出的牌必须符合13种的一种才能够出得了牌，这个就叫地主的规则。那么我们下面可以通过一个枚举结构来表
斗地主算法的设计与实现-FansUnion-DouDiZhu-20131012.zip
10-12
斗地主项目的主要实现了，斗地主中的洗牌、发牌、判断牌型、排序等一系列算法，但这并不是一个完整的项目。 界面操作部分，功能很有限，仅供参考，有兴趣的同学自行完善。 我的CSDN博客还有很多优质原创文章，有...
Android应用源码之斗地主源码实现-IT计算机-毕业设计.zip
04-06
Android应用源码开发Demo，主要用于毕业设计学习。
cpp-一款基于cocos2dx引擎33版本开发的单机斗地主手机游戏
08-16
cpp-一款基于cocos2dx引擎33版本开发的单机斗地主手机游戏
Go-GO实现斗地主服务器并提供一个简单的用户界面
08-14
GO 实现的斗地主游戏，游戏代码规划兼容多中棋牌游戏，暂时只是先斗地主游戏
Python-skynet写的一个demo实现一个CS的斗地主的基本逻辑
08-10
skynet写的一个demo，实现一个C/S的斗地主的基本逻辑
斗地主算法的设计与实现(一)--项目介绍&如何定义和构造一张牌
热门推荐
放眼长期，稳中求进；知行合一，日拱一卒
10-09 1万+
大学期间，我在别人的基础上，写了一个简易的斗地主程序。 主要实现了面向对象设计，洗牌、发牌、判断牌型、比较牌的大小、游戏规则等算法。 通过这个斗地主小项目的练习，提高了我的面向对象设计能力，加深了对算法的理解。 最近把这些设计和算法分享给大家，过些天会上传斗地主程序的源码。
中国象棋程序的设计与实现(二)--源码
放眼长期，稳中求进；知行合一，日拱一卒
09-17 1万+
本篇将正式公布 中国象棋程序–高级版–楚汉棋兵 的所有源码。介绍一些相关信息，如源码下载地址、QQ交流群、源码结构、版权声明。其它更多文档，如 毕业设计论文、项目架构图图、心得体会、开发记录，将在本月全部公布。 有兴趣的同学，可以趁着 中秋节3天、国庆7天等假期，进行研究。我也将抽空选择性地回答一些问题。 源码注释比较多，不懂的可以在群里交流。
斗地主算法的设计与实现(六)--项目源码和说明
放眼长期，稳中求进；知行合一，日拱一卒
10-12 1万+
本篇将给出斗地主算法的源码，介绍斗地主这个项目的一些基本情况。 下载地址：http://download.csdn.net/detail/fansunion/6387589 特别说明：斗地主项目的主要实现了，斗地主中的洗牌、发牌、判断牌型、排序等一系列算法，但这并不是一个完整的项目。 界面操作部分，功能很有限，仅供参考，有兴趣的同学自行完善。
三带一牌型算法c++
最新发布
11-11
三带一牌型是斗地主中常见的牌型之一，玩家需要根据手中的牌来进行组合出合适的牌型。在算法c中，玩家需要遵循以下几个步骤来判断三带一牌型： 首先，玩家需要检查手中的牌中是否有符合三带一牌型的牌组合，即三张相同点数的牌加上一张其他点数的牌。如果有符合的牌组合，则可以继续下一步判断。 其次，玩家需要根据三带一的牌型大小来决定是否出牌。通常情况下，牌型中点数较大的牌是比较优势的，因此需要比较手中的三带一牌组合与桌面上已经出现的牌的大小，来决定是否出牌。 最后，玩家可以根据游戏情况来决定是否选择使用三带一牌型。如果当前局面需要冒一定的风险来获得胜利，可以选择出牌；如果当前局面不利或者其他玩家已经出了比较大的牌，可以选择保留三带一的牌型，等待更好的时机出手。 综上所述，算法c中的三带一牌型需要玩家根据手中牌的实际情况来判断是否出牌，同时也需要考虑游戏的整体局势和其他玩家的情况来做出决策。只有在适当的时机和情况下，使用三带一的牌型才能发挥出最大的作用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 24
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值