德州扑克输赢判断-C#

首先讲一下思路吧。

德州扑克一把有7张牌，可能组成10种牌型，所以，在网络游戏中，不可能是两两比较，然后排序，最简单的做法就是对每个玩家的手牌计算一个权值，然后对最终玩家的权值进行排序即可得到最终的输赢顺序。

其实这个是我的毕业设计，在大三的时候，我曾在一位学长王总的带领下做过一个德州扑克的记录软件，那个软件比较简单，只是有记录员记录现实世界中正在进行的游戏，然后把玩家的牌，叫牌操作和游戏结果记录下来，以供将来重放时做教学使用。当时的项目并没有输赢判断的功能，而是由记录员自己输入输赢的玩家顺序。大四时的毕业设计，我就想可以在这个基础上实现一个在线的网络游戏，不再需要记录员这个角色，虽然并没有实现，但过程中的各种问题也都想到了解决方案，包括本文要讲的输赢算法的实现，当时就是太懒了，毕业论文就用了一个星期就写完了，下下周就是初版的截止时间，这周末我才开始写毕设，到下周日的时候检查了重复率就把初稿发给鲍老师了，以后再也没改过。。。=如今参加工作了，想着在下班没有事的时候做些自己的事情，而且当时在大三的时候我是想要做输赢算法的实现的，但苦于当时没有想到好的解决方案，到网上搜索又没有找到现成的容易理解的解决方案。所以首先就想到了把这个输赢的算法实现了。

下面讲一下实现的过程：

首先定义了两个类：Card和CardSum，Card保存玩家手中的牌，所以就两个属性：牌色和牌大小，CardSum是用来归类用的，要统计每个牌型大小的牌个数，下面是两个类的定义：

enum Color//花色定义
    {
        A,
        S,
        D,
        B
    }

    class Card:IComparable<Card> //实现IComparable接口，用来后面的cardList排序
    {
        public Color Hua { get; set; }// 牌的花色
        public int Num { get; set; } // 牌的大小，2—14

        public int CompareTo(Card other)
        {
            return this.Num.CompareTo(other.Num);

        }
    }

Card

class CardSum : IComparable<CardSum>//实现IComparable接口，用来后面的List排序
    {
        public int Num { set; get; }
        public int Sum { set; get; }
        public int CompareTo(CardSum other)
        {
            return this.Num.CompareTo(other.Num);
        }
    }

CardSum

所以便有了函数原型：

public static double GetWeight(List<Card> cardList, out CardsType cardsType);

下面讲一下算法实现的过程：

其实根据各种牌型的特点很容易想到的，主要就是牌的花色，牌的相同的个数和牌的顺序这些，在我们知道这些之后就可以很轻松的判断出牌型，根据牌型，就可以获取到玩家手中最终有用的五张牌，根据这五张牌和牌型，进而计算玩家手牌的权重

下面的表格显示各种牌型的判断成立条件，而有效牌的查找方法相对简单，大家可以到代码里看看：

权重值大小=牌型基数+“.”+特征牌+非特征牌。

这样最终既可以获得牌型和权重大小。下面是关键算法实现代码：

public static void BubbleSort<T>(List<T> arrayList) where T : IComparable<T>
        {
            for (int i = 0; i < arrayList.Count - 1; i++)
            {
                for (int j = 0; j < arrayList.Count - i - 1; j++)
                {
                    if (arrayList[j].CompareTo(arrayList[j + 1]) > 0)
                    {
                        T temp = arrayList[j];
                        arrayList[j] = arrayList[j + 1];
                        arrayList[j + 1] = temp;
                    }
                }
            }
        }

        public static double GetWeight(List<Card> cardList, out CardsType cardsType)
        {
            string result = "";
            List<Card> countList = new List<Card>();

            cardsType = new CardsType();
            BubbleSort(cardList);

            int A_Sum = 0, B_Sum = 0,D_Sum=0,S_Sum=0;
            List<CardSum> cardSumList = new List<CardSum>();

            foreach (var item in cardList)
            {
                switch(item.Hua)
                {
                    case Color.A:
                        A_Sum++;
                        break;
                    case Color.B:
                        B_Sum++;
                        break;
                    case Color.D:
                        D_Sum++;
                        break;
                    case Color.S:
                        S_Sum++;
                        break;
                }

                bool EXIT = false;
                foreach (var carSum in cardSumList)
                {
                    if(carSum.Num==item.Num)
                    {
                        carSum.Sum++;
                        EXIT = true;
                        break;
                    }
                }
                if(!EXIT)
                {
                    cardSumList.Add(new CardSum() { Num=item.Num,Sum=1});
                }
            }

            int Four = 0, Three = 0, Two = 0,One=0;
            foreach (var item in cardSumList)
            {
                switch(item.Sum)
                {
                    case 4:
                        Four++;
                        break;
                    case 3:
                        Three++;
                        break;
                    case 2:
                        Two++;
                        break;
                    case 1:
                        One++;
                        break;
                }
            }

            BubbleSort(cardSumList);
            int[] card5=new int[5];

            bool ISSHUNZI = false;
            if (cardSumList.Count >= 5 && cardSumList[0].Num + 1 == cardSumList[1].Num && cardSumList[1].Num + 1 == cardSumList[2].Num && cardSumList[2].Num + 1 == cardSumList[3].Num && cardSumList[3].Num + 1 == cardSumList[4].Num)
            {
                ISSHUNZI = true;
                for (int i = 0; i < 6; i++)
                {
                    card5[i] = cardSumList[i].Num;
                }
            }
            else if (cardSumList.Count >= 6 && cardSumList[1].Num + 1 == cardSumList[2].Num && cardSumList[2].Num + 1 == cardSumList[3].Num && cardSumList[3].Num + 1 == cardSumList[4].Num && cardSumList[4].Num + 1 == cardSumList[5].Num)
            {
                ISSHUNZI = true;
                for (int i = 1; i < 7; i++)
                {
                    card5[i-1] = cardSumList[i].Num;
                }
            }
            else if (cardSumList.Count >= 7 && cardSumList[2].Num + 1 == cardSumList[3].Num && cardSumList[3].Num + 1 == cardSumList[4].Num && cardSumList[4].Num + 1 == cardSumList[5].Num && cardSumList[5].Num + 1 == cardSumList[6].Num)
            {
                ISSHUNZI = true;
                for (int i = 2; i < 8; i++)
                {
                    card5[i-2] = cardSumList[i].Num;
                }
            }

            if(Four==1)
            {
                cardsType = CardsType.SiTiao;
                foreach (var item in cardSumList)
                {
                    if(item.Sum==4)
                    {
                        cardSumList.Remove(item);
                        countList.Add(new Card() { Num = item.Num });
                        countList.Add(new Card() { Num = item.Num });
                        countList.Add(new Card() { Num = item.Num });
                        countList.Add(new Card() { Num = item.Num });
                        break;
                    }
                }
                CardSum lastOne=cardSumList[cardSumList.Count-1];
                countList.Add(new Card() { Num = lastOne.Num});

            }
            else if(Three==1&&Two>0)
            {
                cardsType = CardsType.ManTangHon;
                foreach (var item in cardSumList)
                {
                    if (item.Sum == 3)
                    {
                        cardSumList.Remove(item);
                        countList.Add(new Card() { Num = item.Num });
                        countList.Add(new Card() { Num = item.Num });
                        countList.Add(new Card() { Num = item.Num });
                        break;
                    }
                }
                for (int i = cardSumList.Count-1; i >=0; i--)
                {
                    if (cardSumList[i].Sum == 2)
                    {
                        countList.Add(new Card() { Num = cardSumList[i].Num });
                        countList.Add(new Card() { Num = cardSumList[i].Num });
                        cardSumList.RemoveAt(i);
                        break;
                    }
                }

            }
            else if (ISSHUNZI && (A_Sum > 4 || B_Sum > 4 || D_Sum > 4 || S_Sum > 4))
            {
                cardsType = CardsType.TongHuaShun;

                for (int i = 5; i >=0; i--)
                {
                    countList.Add(new Card() { Num=card5[i]});
                }

            }
            else if(A_Sum>4||B_Sum>4||D_Sum>4||S_Sum>4)
            {
                cardsType = CardsType.TongHua;

                if(A_Sum>4)
                {
                    for (int i = cardList.Count-1; i >=0; i--)
                    {
                        if(cardList[i].Hua==Color.A&&countList.Count<5)
                        {
                            countList.Add(new Card() { Num=cardList[i].Num});
                        }
                    }
                }
                else if (B_Sum > 4)
                {
                    for (int i = cardList.Count - 1; i >= 0; i--)
                    {
                        if (cardList[i].Hua == Color.B && countList.Count < 5)
                        {
                            countList.Add(new Card() { Num = cardList[i].Num });
                        }
                    }
                }
                else if (D_Sum > 4)
                {
                    for (int i = cardList.Count - 1; i >= 0; i--)
                    {
                        if (cardList[i].Hua == Color.D&& countList.Count < 5)
                        {
                            countList.Add(new Card() { Num = cardList[i].Num });
                        }
                    }
                }
                if (S_Sum > 4)
                {
                    for (int i = cardList.Count - 1; i >= 0; i--)
                    {
                        if (cardList[i].Hua == Color.S && countList.Count < 5)
                        {
                            countList.Add(new Card() { Num = cardList[i].Num });
                        }
                    }
                }

            }
            else if (ISSHUNZI)
            {
                cardsType = CardsType.ShunZi;
                for (int i = 5; i >= 0; i--)
                {
                    countList.Add(new Card() { Num = card5[i] });
                }
            }
            else if (Three == 1 && cardSumList.Count == 5)
            {
                cardsType = CardsType.SanTiao;

                foreach (var item in cardSumList)
                {
                    if (item.Sum == 3)
                    {
                        cardSumList.Remove(item);
                        countList.Add(new Card() { Num = item.Num });
                        countList.Add(new Card() { Num = item.Num });
                        countList.Add(new Card() { Num = item.Num });
                        break;
                    }
                }
                countList.Add(new Card() { Num=cardSumList[cardSumList.Count-1].Num});
                countList.Add(new Card() { Num = cardSumList[cardSumList.Count - 2].Num });

            }
            else if(Two>=2)
            {
                cardsType = CardsType.LiangDui;

                for(int i=cardSumList.Count-1;i>=0;i--)
                {
                    if(cardSumList[i].Sum==2&&countList.Count<4)
                    {
                        countList.Add(new Card() { Num = cardSumList[i].Num });
                        countList.Add(new Card() { Num = cardSumList[i].Num });
                        cardSumList.RemoveAt(i);
                    }
                }
                countList.Add(new Card() { Num = cardSumList[cardSumList.Count - 1].Num });
            }
            else if(Two==1&&cardSumList.Count==6)
            {
                cardsType = CardsType.YiDui;

                foreach (var item in cardSumList)
                {
                    if (item.Sum == 2)
                    {
                        cardSumList.Remove(item);
                        countList.Add(new Card() { Num = item.Num });
                        countList.Add(new Card() { Num = item.Num });
                        break;
                    }
                }
                countList.Add(new Card() { Num = cardSumList[cardSumList.Count - 1].Num });
                countList.Add(new Card() { Num = cardSumList[cardSumList.Count - 2].Num });
                countList.Add(new Card() { Num = cardSumList[cardSumList.Count - 3].Num });
            }
            else if(cardSumList.Count==7)
            {
                cardsType = CardsType.GaoPai;
                countList.Add(new Card() { Num = cardSumList[cardSumList.Count - 1].Num });
                countList.Add(new Card() { Num = cardSumList[cardSumList.Count - 2].Num });
                countList.Add(new Card() { Num = cardSumList[cardSumList.Count - 3].Num });
                countList.Add(new Card() { Num = cardSumList[cardSumList.Count - 4].Num });
                countList.Add(new Card() { Num = cardSumList[cardSumList.Count - 5].Num });
            }

            result = result + (int)cardsType+".";
            foreach (var item in countList)
            {
                if(item.Num>9)
                {
                    result = result + item.Num;
                }
                else
                {
                    result = result + "0" + item.Num;
                }
            }

            return Double.Parse(result);
        }

GetWeight

 enum CardsType
    {
        TongHuaShun=9,
        SiTiao=8,
        ManTangHon=7,
        TongHua=6,
        ShunZi=5,
        SanTiao=4,
        LiangDui=3,
        YiDui=2,
        GaoPai=1

    }

CardsType

第一次写博客，讲的有点乱。。。。

最后附上完整项目下载地址：http://files.cnblogs.com/files/LouisGuo/ConsoleApplication1.7z

时间： 2024-11-12 10:15:49

德州扑克输赢判断-C#的相关文章

一场改变你投资生涯的讨论：职业德州扑克手看交易

各位投友大家好. 校长今天花时间仔细读了一篇长文,叫做<职业德州扑克手看交易:没犯任何错误照样输个精光>,非常棒的文章. 可惜不知道作者是谁,但看得出来,文中讲到的他自己在德州扑克上的经验是真实的. 这篇文章提出了两个非常有价值的概念. 第一个叫盈亏同源.有一些亏损是你在追求盈利道路上必须要支付的成本,这是不可避免也是不应该避免的.因为你一旦避免了这些亏损,你同时也就失去了盈利的机会. 而另外一些亏损择时可以避免也是应该避免的.所谓高手就是在这个部分发挥功力. 第二个概念是把风险分成了三层:系

模拟德州扑克对战游戏

================================================================ 注意:本文参考"巧妙的Python数据结构玩法|实战德州扑克"的相关内容,并在此基础之上完成模拟扑克对战游戏. 原文网址:http://mp.weixin.qq.com/s/JQ0zJGf7Tz49Xn78x7Z40g ================================================================ 我们写了两

德州扑克 2015 华为软件精英挑战赛

概述 华为2015软件挑战赛比赛总结,跟队友当时奋斗了15天吧,最后差点进32强了,第三轮遇到的对手太厉害,止步64强了.这次官方提供 Ubuntu 纯命令行镜像和庄家 Server,选手编写德州扑克选手机器人程序互相 PK(8人一组)500轮后钱多者胜出.运行只要运行华为提供的ne">dist_check_and_run.sh 脚本 即可,里面会给自动运行每个game程序.最近快要找工作了一些项目还是要总结一下的,感觉欠缺的地方还是有很多的,下面进入正题. 梳理一下主干主要这次比赛项目主

华为软件精英挑战赛【德州扑克】心得体会

这是华为举办的一个软件竞赛,华为提供一个德州扑克台桌的server,我们要根据牌型等因素,给出出牌的策略,类似模拟牌手的程序.从知道挑战的题目到提交最终版本的程序中间只有一个月的时间,刚看到这个题目一点头绪没有,看了论文有用蒙特卡洛模拟,决策树等,各种没听过的词汇,感觉写出这个程序会很难,和我一个教研室的小伙伴们看到这个题目的时候陆续都放弃了. 思考了半天我也放弃了,因为接下来几个星期还有实习的面试和小论文等着我完成,就这样过了2个星期,期间我把小论文与实习面试都完成了,在一天早晨无意中又点开了

2015华为德州扑克入境摘要——软体project

直到6一个月2号下午12时00,华为长达一个月的德州扑克锦标赛落下帷幕也被认为是. 我们的团队一直共同拥有3民,间.一个同学(吴)负责算法设计,一个同学(宋)负责分析消息,而我负责的实现框架设计和详细的决策算法.离5报名早年1月开始,要设置环境,设计框架,任务分工,以及各个模块代码的编写.从我个人的感觉来看,整个过程能够说是一个比較艰辛的历程. 德州扑克是一种棋牌类游戏.属于一种博弈过程,起先我对这个游戏没有不论什么的了解,最多的也仅仅是在影视题材里面见过,可是详细的游戏规则并不懂.而正是在这种

2015华为德州扑克参赛总结——软件工程

直到6月2号晚上零点,为期一个月的华为德州扑克比赛也算告一段落了.我们团队总共有3人,其中,一个同学(吴晓东)负责算法的设计,一个同学(宋振兴)负责消息的解析,而我则负责整个框架的设计以及具体决策算法的实现.从5月份初报名开始,到环境的搭建,框架的设计,任务的分工,算法的设计以及各个模块代码的编写,从我个人的感觉来看,整个过程可以说是一个比较艰辛的历程. 德州扑克是一种棋牌类游戏,属于一种博弈过程,起先我对这个游戏没有任何的了解,最多的也只是在影视题材里面见过,但是具体的游戏规则并不懂.而正是在

德州扑克AI

德州扑克: 1:outs数,就是所听的牌的数量. 例子: 1:听顺子 4567 outs数就是8,能够成顺子的牌为3和8. 5689 outs数就是4,能够成顺子的牌只有7. 2:听同花     359J outs数就是9,能够成牌的是同一种花色的'A','2','4','6','7','8','10','Q','K'. 3:听同花顺 4567 outs数就是2,能够成牌的是同一种花色的'3','8'. 5689 outs数就是1,能够成牌的是同一种花色的'7'. 4:听同花或顺子 4567 o

[swustoj 1088] 德州扑克

德州扑克(1088) 问题描述 德州扑克是一款风靡全球的扑克游戏.德州扑克一共有52张牌,没有王牌.每个玩家分两张牌作为“底牌”,五张由荷官陆续朝上发出的作为公共牌.开始的时候,每个玩家会有两张面朝下的底牌.经过所有押注圈后,若仍不能分出胜负,游戏会进入“摊牌”阶段,也就是让所剩的玩家亮出各自的底牌以较高下,持大牌者获胜.因技巧性强,易学难精又被称为“扑克游戏中的凯迪拉克”. 现在有N个玩家进入摊牌阶段(编号为1到N),摊牌阶段比大小的规则是,用自己的2张底牌和5张公共牌结合在一起,选出5张牌,

德州扑克游戏

哇,好久好久没写东西啦... 这两天实现了一个简单的游戏引擎,可以发牌,可以比较两手牌的大小 由于最近都在倒腾Golang,所以用GO实现的.这阶段过后准备用这个引擎来实现一个简单的AI对战,现在先记录一下 接下来我假设你已经懂游戏规则和俗语了 首先是牌的储存,2~~A,一共13张牌,我用的是一个14位的二进制区间来储存的,比如2-A,将表示为:11111111111110,辣么第一位是干啥的呢,请继续看下面 这样的储存方式除了省空间外还有什么优势呢?我们顺子的判断为例:例如顺子10JQKA,在