Poker 发牌算法

 目前游戏行业到底怎末样呢？

 从社会人群上看：目前社会主流是80、90、00 这三代人对游戏的接受度是很大的，越年轻，对游戏的认可度越高，不会像老一辈那样排斥游戏。

 从国家政策上看：国家对游戏的监管力度也越来越规范和严谨，在保护未成年方面也越做越好，有序的市场环境逐渐在形成。

 从游戏设计产品上看：游戏的产品品质越做越好，越做越具有正向的引导和教育意义，不再是为了盈利而推出一些低俗，着迷的产品。

 从游戏硬件运用上看：目前已PC端和手游端为主，特别是手游带动了游戏的快速发展，未来VR，人工智能的发展，以及5G时代的到来，将进一步加速游戏行业的升级与发展。随着AI和工业自动化  的发展，大部分劳动岗位都会被机器取代，人们整体可支配时间会越来越多，而同时随着移动设备，度可穿戴设备，VR等技术的发展，游戏这一行业势必会成为人类一种较低成本的精神生活方式。所以在未来，专无论是优秀的内容提供商如影漪视界，还是专业的游戏内的服务提供商，都会因庞大的需求而涌现出更多。

 其中游戏中的棋牌类游戏，也越来越受玩家的欢迎，比如我们常见的斗地主，麻将更是男女老少通吃。下面我就说一下扑克的发牌算法是如何实现的：

 

Step1：创建扑克类（包含扑克花色和牌面大小）

using System;
namespace DealPoker
{
    /// <summary>
    /// 用C#模拟实现扑克牌发牌，
    /// 1、52张牌，四种花色（黑桃，红心，梅花，方块）
    /// 2、没人一轮一张的方式发牌
    /// 3、最后将三个人的扑克牌大小和花色打印在控制台上
    /// 实现思路：可以将扑克牌对象存放到一个列表集合中，通过循环随机数的方式依次发牌；
    /// 每循环一次，从列表中移除发过的牌
    /// </summary>

    //定义花色
    public enum PokerColor
    {
        红心 = -1,
        黑桃 = -2,
        梅花 = -3,
        方块 = -4
    }

    //定义大小
    public enum PokerNumber
    {
        Three = 3,
        Four,
        Five,
        Six,
        Seven,
        Eight,
        Nine,
        Ten,
        J,
        Q,
        K,
        A,
        Two
    }

    public class Poker
    {
        //花色属性
        public PokerColor p_Color {
            set;
            get;
        }
        //牌面属性
        public PokerNumber p_Number {
            set;
            get;
        }
        //构造方法
        public Poker (PokerColor p_c, PokerNumber p_n)
        {
            this.p_Color = p_c;
            this.p_Number = p_n;
        }
        //打印扑克信息
        public void PrintPokerInfo ()
        {
            Console.WriteLine ("花色:" + this.p_Color + " 大小：" + p_Number);
        }
    }
}

Step2：创建扑克牌管理类（创建扑克牌对象，发牌，排序）

using System;
using System.Collections.Generic;

namespace DealPoker
{
    /// <summary>
    /// 扑克牌管理类
    /// 1、单例类
    /// 2、创建扑克牌的方法
    /// 3、依次发牌的的能力
    /// 4、打印所有玩家扑克的方法
    /// 5、打印某一个人的方法
    /// 6、按照花色对玩家扑克进行排序的方法
    /// 7、按照牌面大小进行排序的方法
    /// </summary>
    public class PokerManager
    {
        #region 单例类

        private static PokerManager _instance = null;

        private PokerManager ()
        {

        }

        public static PokerManager Instance {
            get {
                if (_instance == null) {
                    _instance = new PokerManager ();
                }
                return _instance;
            }
        }

        #endregion

        //存放所有的扑克牌
        public List<Poker> allPoker = new List<Poker> ();
        //存放每个人的扑克牌集合
        public List<Poker> player01 = new List<Poker> ();
        public List<Poker> player02 = new List<Poker> ();
        public List<Poker> player03 = new List<Poker> ();

        /// <summary>
        /// 创建扑克
        /// </summary>
        public void CreatePoker ()
        {
            //外层循环控制花色，内层循环控制牌面大小
            for (int i = -4; i < 0; i++) {
                for (int j = 3; j < 16; j++) {
                    Array colorAry = Enum.GetValues (typeof(PokerColor));
                    Array numberAry = Enum.GetValues (typeof(PokerNumber));

                    PokerColor p_color = (PokerColor)colorAry.GetValue (i + 4);
                    PokerNumber p_number = (PokerNumber)numberAry.GetValue (j - 3);

                    //实例化一张扑克牌
                    Poker poker = new Poker (p_color, p_number);
                    allPoker.Add (poker);
                }
            }
        }

        //依次发牌
        public void SendPokerToPlayer ()
        {
            //创建随机对象
            Random random = new Random ();
            //每个人拿到的牌数
            int count = allPoker.Count / 3;
            //设置发牌
            for (int i = 0; i < count; i++) {
                for (int j = 0; j < 3; j++) {
                    //随机下标
                    int index = random.Next (0, allPoker.Count);
                    //根据下标依次发牌
                    switch (j) {
                    case 0:
                        player01.Add (allPoker [index]);
                        break;
                    case 1:
                        player02.Add (allPoker [index]);
                        break;
                    case 2:
                        player03.Add (allPoker [index]);
                        break;
                    default:
                        break;
                    }
                    allPoker.RemoveAt (index);
                }
            }
        }

        //打印所有玩家的扑克
        public void PrintPokerOfAllPlayer ()
        {
            for (int i = 0; i < 3; i++) {
                Console.WriteLine ("第{0}个人的牌是：", i + 1);
                for (int j = 0; j < player01.Count; j++) {
                    switch (i) {
                    case 0:
                        player01 [j].PrintPokerInfo ();
                        break;
                    case 1:
                        player02 [j].PrintPokerInfo ();
                        break;
                    case 2:
                        player03 [j].PrintPokerInfo ();
                        break;
                    default:
                        break;
                    }
                }
            }
        }
        //打印某个人的牌
        public void PrintSomeonePoker (List<Poker> p)
        {
            for (int i = 0; i < p.Count; i++) {
                p [i].PrintPokerInfo ();
            }

        }


        //按照花色进行排序
        public void OrderPokerByColor (List<Poker> p_List)
        {
            //方法一：
            //            p_List.Sort (SuitCompare);
            //方法二：匿名委托
            //            p_List.Sort (delegate(Poker x, Poker y) {
            //                int a = GetPokerValueByColor (x);
            //                int b = GetPokerValueByColor (y);
            //                return b.CompareTo (a);
            //            });
            //            p_List.Sort (delegate(Poker A, Poker B) {
            //                return -A.p_Number.CompareTo (B.p_Number);
            //            });
            //方法三：Lambda表达式
            p_List.Sort ((Poker x, Poker y) => {
                return GetPokerValueByColor (y).CompareTo (GetPokerValueByColor (x));
            });
        }

        //
        int SuitCompare (Poker A, Poker B)
        {
            //获取扑克A和B的新的数值大小
            int a = GetPokerValueByColor (A);
            int b = GetPokerValueByColor (B);
            return b - a;
        }

        //按照花色获取某张扑克代表的数值，
        //比较两个三位数，先比较百位，其次是十位和个位
        //百位代表的是花色，十位和个位表示牌面大小
        int GetPokerValueByColor (Poker p)
        {
            //获取扑克的花色
            PokerColor c = p.p_Color;
            //记录每个花色的代表值
            int value = 0;
            switch (c) {
            case PokerColor.黑桃:
                value = 400;
                break;
            case PokerColor.红心:
                value = 300;
                break;
            case PokerColor.梅花:
                value = 200;
                break;
            case PokerColor.方块:
                value = 100;
                break;
            default:
                break;
            }

            //牌的大小
            PokerNumber num = p.p_Number;
            //记录每张牌新的大小（花色值+牌面值）
            return value + (int)num;
        }


        //按照大小进行排序
        public void OrderPokerByNumber (List<Poker> p_List)
        {
            p_List.Sort (delegate(Poker x, Poker y) {
                int a = GetPokerValueByNumber (x);
                int b = GetPokerValueByNumber (y);
                return a.CompareTo (b);
            });
        }

        int GetPokerValueByNumber (Poker p)
        {
            //获取扑克的牌面
            int value = (int)p.p_Number * 10;
            return value - (int)p.p_Color;
        }
    }
}

Step3：在主函数中调用

using System;
namespace DealPoker
{
    class MainClass
    {
        public static void Main (string[] args)
        {
            //1、创建牌
            PokerManager.Instance.CreatePoker ();
            //2、依次发牌
            PokerManager.Instance.SendPokerToPlayer ();
            //3、打印扑克信息
            PokerManager.Instance.PrintPokerOfAllPlayer ();
            //4、按照花色排序玩家1的扑克（黑、红、梅、方）
//            PokerManager.Instance.OrderPokerByColor (PokerManager.Instance.player01);
            PokerManager.Instance.OrderPokerByNumber (PokerManager.Instance.player01);
            Console.WriteLine ("玩家01按照花色排序后为：");
            PokerManager.Instance.PrintSomeonePoker (PokerManager.Instance.player01);

        }
    }
}

Poker 发牌算法—排序，

    根据对象中的某一属性对对象进行排序

方法一：
//获得数据列表
        List<BaseInfo> list = server.GetBaseInfo();
        //对列表排序
        list.Sort(delegate(BaseInfo A, BaseInfo B) {
            return A.Name.CompareTo(B.Name);
        });


//按照花色进行排序
        public void OrderPokerByColor (List<Poker> p_List)
        {
            //方法一：
            //            p_List.Sort (SuitCompare);
            //方法二：匿名委托
            //            p_List.Sort (delegate(Poker x, Poker y) {
            //                int a = GetPokerValueByColor (x);
            //                int b = GetPokerValueByColor (y);
            //                return b.CompareTo (a);
            //            });
            //            p_List.Sort (delegate(Poker A, Poker B) {
            //                return -A.p_Number.CompareTo (B.p_Number);
            //            });
            //方法三：Lambda表达式
            p_List.Sort ((Poker x, Poker y) => {
                return GetPokerValueByColor (y).CompareTo (GetPokerValueByColor (x));
            });
        }

        //
        int SuitCompare (Poker A, Poker B)
        {
            //获取扑克A和B的新的数值大小
            int a = GetPokerValueByColor (A);
            int b = GetPokerValueByColor (B);
            return b - a;
        }

        //按照花色获取某张扑克代表的数值，
        //比较两个三位数，先比较百位，其次是十位和个位
        //百位代表的是花色，十位和个位表示牌面大小
        int GetPokerValueByColor (Poker p)
        {
            //获取扑克的花色
            PokerColor c = p.p_Color;
            //记录每个花色的代表值
            int value = 0;
            switch (c) {
            case PokerColor.黑桃:
                value = 400;
                break;
            case PokerColor.红心:
                value = 300;
                break;
            case PokerColor.梅花:
                value = 200;
                break;
            case PokerColor.方块:
                value = 100;
                break;
            default:
                break;
            }

            //牌的大小
            PokerNumber num = p.p_Number;
            //记录每张牌新的大小（花色值+牌面值）
            return value + (int)num;
        }


        //按照大小进行排序
        public void OrderPokerByNumber (List<Poker> p_List)
        {
            p_List.Sort (delegate(Poker x, Poker y) {
                int a = GetPokerValueByNumber (x);
                int b = GetPokerValueByNumber (y);
                return a.CompareTo (b);
            });
        }

        //
        int GetPokerValueByNumber (Poker p)
        {
            //获取扑克的牌面
            int value = (int)p.p_Number * 10;
            return value - (int)p.p_Color;
        }