自己实现斗地主引擎

对于所有类似斗地主这种卡牌类游戏,其实游戏思路都是差不多的。先判断出牌是否是‘有效牌型’,若是,再判断该牌型的权重值用来比较大小。本篇文章将介绍如何实现一个斗地主的卡牌游戏引擎,洗牌、发牌、牌型检查并比较大小。核心代码比较完整,后面给了一个GUI的demo,完成了洗牌、发牌、选牌出牌,牌型检查,但是没有实现电脑自动出牌的功能,有兴趣的可以down下来看一下。

Github源码 

 

实现思路

1)根据斗地主规则,罗列出所有可能出现的牌型。比如‘单张’、‘对子’、‘三连对’、‘五连顺’、‘六连顺’、‘飞机’、‘炸弹’等等。一共37种牌型;

2)对于上面的37种牌型,每种牌型又存在多种情况,对于‘单张’而言,存在3、4、A、2、小王、大王等等,并且其权重值依次增大。同理,对于‘五连顺’而言,存在3-4-5-6-7、4-5-6-7-8...10-J-Q-K-A等等,并且其权重值依次增大。枚举出所有细分牌型,并为其赋予权重值,下一次就会以O(1)的时间复杂度快速判断输入卡牌是否是有效牌型;

3)在斗地主游戏中,默认只有相同牌型才能比较大小(比较其权重值),但是‘炸弹’牌型(四张相同的卡牌或者一对王)是个例外;

4)斗地主游戏中,不分花色。所以一对‘红桃A+黑桃A’跟一对‘梅花A+方块A’是一样大的。因此在引擎计算中,需要先将所有有花色的输入卡牌,全部去除花色,然后再计算;

 

数据字典初始化

以‘K-Q-Q-Q-K-K-Q-K’输入手牌为例(输入手牌可以无序),存在以下数据字典:

[Key]       ==>  K-K-K-K-Q-Q-Q-Q(降序排序,保证key唯一)

[Values]  ==> 

             {Display=K-K-K-K-Q-Q-Q-Q,  Name=四带两对,     Weight=300}

             {Display=Q-Q-Q-Q-K-K-K-K,  Name=四带两对,     Weight=200}

             {Display=K-K-K-Q-Q-Q-K-Q,  Name=飞机带两张”,  Weight=300}

对于同一个输入手牌,对应三种牌型。对于任何输入,都能通过O(1)时间复杂度判断该输入是否有效,若有效,返回对应牌型数据(可以包含多个,绿色部分为相同牌型,可以比较大小)。

数据字典初始化需要一定时间,本机测试大约耗时5秒。关于牌型检查这里,通过机器学习应该可以快速判断出牌型,但是并不能得出其对应的权重值,要想得到权重值,还是需要通过枚举(有疑问?)

 

卡牌定义

4种花色

        /// <summary>
        /// 4 colors
        /// diamonds, clubs, hearts, spades
        /// </summary>
        public static List<String> CardColors = new List<string> {"D", "C", "H", "S" };

15张不带花色卡牌

        /// <summary>
        /// 15 kinds of card without color
        /// 3, 4, 5, 6, 7, 8, 9, 10, Jack, Queen, King, Ace, 2, Little joker, Big joker
        /// </summary>
        public static List<String> CardValues = new List<string> {"3", "4", "5", "6", "7", "8", "9", "T", "J", "Q", "K", "A", "2", "LJ", "BJ" };

54张全部带花色卡牌(‘K*H’代表‘红桃K’,‘4*D’代表‘方块4’)

        /// <summary>
        /// return all cards with color in the game
        /// 3*D 3*C 3*H 3*S 4*D 4*C 4*H 4*S 5*D 5*C 5*H 5*S  ... 2*D 2*C 2*H 2*S LJ BJ 
        /// </summary>
        public static List<String> Cards
        {
            get
            {
                List<String> cards = new List<string>();

                // 13*4==52
                for (int index = 0; index < 13; index++ )
                {
                    foreach (String card_color in CardColors)
                    {
                        cards.Add(CardValues[index] + "*" + card_color);  //  value*color
                    }
                }

                // 52+2 == 54
                cards.Add(CardValues[13]);
                cards.Add(CardValues[14]);

                return cards;
            }
        }

 

洗牌

随机打乱54张带花色卡牌,并以List<String>的形式返回

        /// <summary>
        /// shuffle the cards. 
        /// </summary>
        /// <returns>a list of 54 cards. has color but disordered.</returns>
        public List<String> Shuffle()
        {
            List<String> cards = EngineValues.Cards;

            Random rand = new Random(Guid.NewGuid().GetHashCode());
            List<String> newList = new List<String>();

            foreach (String card in cards)
            {
                newList.Insert(rand.Next(0, newList.Count), card);
            }

            // need reorder the first element
            newList.Remove(cards[0]);
            newList.Insert(rand.Next(0, newList.Count), cards[0]);

            return newList;
        }

 

发牌

传入5个参数,分别是:

  • 洗完牌后的list(作为输入, 54张)
  • 第一个人发牌list(作为输出, 17张)
  • 第二个人发牌list(作为输出, 17张)
  • 第三个人发牌list(作为输出, 17张)
  • 底牌list(作为输出, 3张)
        /// <summary>
        /// deal the cards to 3 parts, 17 cards(such as A*H, BJ, 4*D ...) for each part, another 3 cards will be asigned to the guy who is the landlord.
        /// </summary>
        /// <param name="original_cards">the original cards list, returned by Shuffle method.</param>
        /// <param name="first">the first part</param>
        /// <param name="second">the second part</param>
        /// <param name="third">the third part</param>
        /// <param name="last_cards">the last 3 cards</param>
        /// <returns>true if deal successfully</returns>
        public bool Deal(List<String> original_cards, List<String> first, List<String> second, List<String> third, List<String> last_cards)
        {
            // check if the parameters are valid
            if (original_cards == null 
                || original_cards.Count != 54
                || first == null
                || first.Count != 0
                || second == null
                || second.Count != 0
                || third == null
                || third.Count != 0
                || last_cards == null
                || last_cards.Count != 0)
            {
                return false;
            }

            // simulate player catch the card, everyone has 17 times.
            for (int index = 0; index < 17; index++)
            {
                first.Add(original_cards[index * 3]);
                second.Add(original_cards[index * 3 + 1]);
                third.Add(original_cards[index * 3 + 2]);
            }
            
            // the last 3 cards
            last_cards.Add(original_cards[51]);
            last_cards.Add(original_cards[52]);
            last_cards.Add(original_cards[53]);

            return true;
        }

 

检查牌型

根据输入手牌,直接通过数据字典查询,返回结果中包含对应权重值。

public List<CardType> Check(List<String> input)
{
    //format the input, remove color if it has, sort the card
    String formated_input = EngineTool.FormatCardStr(String.Join("-", input));
    List<CardType> result = new List<CardType>();
    if (EngineValues.Set.ContainsKey(formated_input))
    {
        result.AddRange(EngineValues.Set[formated_input]);
    }
    return result;
}

 

 

posted @ 2018-06-05 12:32  周见智  阅读(4607)  评论(9编辑  收藏  举报