unity 扎金花比大小

最新推荐文章于 2021-12-07 16:54:17 发布
最新推荐文章于 2021-12-07 16:54:17 发布
阅读量1.4k 收藏 1
点赞数
分类专栏： unity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jamesliulyc/article/details/79696544
版权

目录结构

public class Define 
{
    public const int FLOWER_SPADE = 3;// 黑桃
    public const  int FLOWER_HEART = 2;// 红桃
    public const  int FLOWER_CLUB = 1;// 梅花
    public const  int FLOWER_DIAMOND = 0;// 方片

    public const  int NUM_A = 14;
    public const  int NUM_K = 13;
    public const  int NUM_Q = 12;
    public const  int NUM_J = 11;
    public const  int NUM_10 = 10;
    public const  int NUM_9 = 9;
    public const  int NUM_8 = 8;
    public const  int NUM_7 = 7;
    public const  int NUM_6 = 6;
    public const  int NUM_5 = 5;
    public const  int NUM_4 = 4;
    public const  int NUM_3 = 3;
    public const  int NUM_2 = 2;
}
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace GameCore
{

    public class PlayerUtil 
    {
        // 将一副牌按牌面从大到小排序
        public static void SortPlayerByNumber(Player player)
        {
            for (int i = 0; i < 3; i++) 
            {
                for (int j = 0; j < 3 - i - 1; j++) 
                {
                    if (player.cards[j].number < player.cards[j + 1].number)
                    {
                        Card tempCard = player.cards[j];
                        player.cards[j] = player.cards[j + 1];
                        player.cards[j + 1] = tempCard;
                    }
                }
            }
        }

        // 将一副牌按花色从大到小排序
        public static void SortPlayerByFlower(Player player) {
            for (int i = 0; i < 3; i++)
            {
                for (int j = 0; j < 3 - i - 1; j++) 
                {
                    if (player.cards[j].flower < player.cards[j + 1].flower)
                    {
                        Card tempCard = player.cards[j];
                        player.cards[j] = player.cards[j + 1];
                        player.cards[j + 1] = tempCard;
                    }
                }
            }
        }

        // 将对子移动到一幅牌的前两位
        public static void MoveDouble2Front(Player player) 
        {
            if (player.cards[1].number == player.cards[2].number)
            {
                Card tempCard = player.cards[0];
                player.cards[0] = player.cards[2];
                player.cards[2] = tempCard;
            }
        }

        // 将对子已经处于一副牌的前两张的牌，移动对子中花色大的到最前面
        public static void ExchangeSortedDoubleFlower(Player player) 
        {
            if (player.cards[0].flower < player.cards[1].flower)
            {
                Card tempCard = player.cards[0];
                player.cards[0] = player.cards[1];
                player.cards[1] = tempCard;
            }
        }
    }

}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace GameCore
{
    public class Card
    {
        public int number { get; set; }

        public int flower { get; set; }

        public Card() { }

        public Card(int flower, int number) 
        {
            this.flower = flower;
            this.number = number;
        }

    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace GameCore
{
    public class Player 
    {
        public int index {get; set;}

        public Card[] cards = new Card[3];

        public int type { get; set; }

        public bool isSpecial { set; get; }

        public int value {  get; set; }

        public Player() 
        {
        }

        public Player(Card card0, Card card1, Card card2) 
        {
            this.cards[0] = card0;
            this.cards[1] = card1;
            this.cards[2] = card2;
        }

        public Card[] GetCards()
        {
            return cards;
        }

        public void SetCards(Card[] cards) 
        {
            this.cards = cards;
        }

    }
}


using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace GameCore
{
    /**
    *  发牌器，洗牌发牌
    */
    public interface PlayerProvider 
    {
        // 产生单副牌
        Player GetSinglePlayer();

        // 产生多副牌
        List<Player> GetPlayers(int number);

        // 发一张牌
        Card GetCard();

        // 洗牌
        void Shuffle();
    }
}



using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace GameCore
{
    /**
 *   一副牌
 */
    public class LimitedPlayerProvider : PlayerProvider
    {
        private List<Card> cards = new List<Card> ();
        private Random random = new Random();

        public LimitedPlayerProvider()
        {
            InitCards();
        }

        public void InitCards()
        {
            cards.Clear();
            for (int i = 14; i > 1; i--)
            {
                for (int j = 3; j >= 0; j--)
                {
                    Card card = new Card(j, i);
                    cards.Add(card);
                }
            }
        }

        public  Player GetSinglePlayer()
        {
            if (cards.Count < 3)
            {
                Debug.Log("牌不够......");
                return null;
            }
            Player player = new Player();
            for (int i = 0; i < 3; i++)
            {
                player.cards[i] = GetCard();
            }
            PlayerUtil.SortPlayerByNumber(player);
            return player;
        }

        public List<Player> GetPlayers(int number)
        {
            if ( number * 3 > cards.Count)
            {
                return null;
            }
            List<Player> players = new List<Player> ();
            for (int i = 0; i < number; i++)
            {
                Player player= GetSinglePlayer();
                players.Add(player);
            }
            return players;
        }

        // 发一张牌
        public Card GetCard()
        {
            if (cards.Count <= 0)
            {
                return null;
            }

            int cardIndex = Random.Range(0, cards.Count);
            Card card = cards[cardIndex];
            cards.RemoveAt(cardIndex);
            return card;
        }

        // 洗牌
        public void Shuffle()
        {
            InitCards();
        }
    }
}


using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace GameCore
{
    public class TypeValueSetter 
    {
        private ValueCalculator calculator;

        public TypeValueSetter(ValueCalculator calculator)
        {
            this.calculator = calculator;
        }

        public void RegPlayerType(Player player)
        {
            if (IsFlush(player))
            {
                if (IsStraight(player)) 
                {
                    player.type = PlayerType.STRAIGHT_FLUSH;
                    player.value = calculator.GetStraightFlushValue(player);
                } 
                else 
                {
                    player.type = PlayerType.FLUSH;
                    player.value = calculator.GetFlushValue(player);
                }
            }
            else if (IsStraight(player)) 
            {
                player.type = PlayerType.STRAIGHT;
                player.value = calculator.GetStraightValue(player);
            } 
            else if (IsDouble(player)) 
            {
                if (IsBomb(player))
                {
                    player.type = PlayerType.BOMB;
                    player.value = calculator.GetBombValue(player);
                } 
                else {
                    player.type = PlayerType.DOUBLE;
                    PlayerUtil.MoveDouble2Front(player);
                    player.value = calculator.GetDoubleValue(player);
                }
            }
            else
            {
                player.type = PlayerType.NORMAL;
                player.value = calculator.GetNormalValue(player);
                if (IsSpecial(player)) 
                {
                    player.isSpecial = true;
                }
            }
        }

        private bool IsFlush(Player player)
        {
            return player.cards[0].flower == player.cards[1].flower
                && player.cards[1].flower == player.cards[2].flower;
        }

        private bool IsStraight(Player player)
        {
            return ((player.cards[0].number == player.cards[1].number + 1)
                && player.cards[1].number == player.cards[2].number + 1);
        }

        private bool IsBomb(Player player)
        {
            return (( player.cards[0].number == player.cards[1].number )
                && (player.cards[1].number == player.cards[2].number));
        }

        private bool IsDouble(Player player)
        {
            return player.cards[0].number == player.cards[1].number
                || player.cards[1].number == player.cards[2].number;
        }

        private bool IsSpecial(Player player)
        {
            return player.cards[0].number == 5 && player.cards[1].number == 3 && player.cards[2].number == 2;
        }

    }

}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace GameCore
{
    public class PlayerComparator : IComparer<Player>
    {
        private TypeValueSetter recognizer;

        public PlayerComparator(ValueCalculator calculator)
        {
            this.recognizer = new TypeValueSetter(calculator);
        }
            
        public void SetupRegularPlayer(Player player)
        {
            recognizer.RegPlayerType(player);
        }

        public void SetupUnRegularPlayer(Player player)
        {
            PlayerUtil.SortPlayerByNumber(player);
            recognizer.RegPlayerType(player);
        }

        public void SortRegularPlayers(List<Player> playersInput)
        {
            foreach(Player player in playersInput)
            {
                recognizer.RegPlayerType(player);
            }
        }

        public int Compare(Player player1, Player player2)
        {
            return (player1.value - player2.value);
        }
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PlayerType 
{
    public const  int BOMB = 5;

    public const  int BOMB_MAX_VALUE = 7881;

    public const  int STRAIGHT_FLUSH = 4;

    public const  int STRAIGHT_FLUSH_MAX_VALUE = 7867;

    public const  int FLUSH = 3;

    public const  int FLUSH_MAX_VALUE = 7855;

    public const  int STRAIGHT = 2;

    public const  int STRAIGHT_MAX_VALUE = 4052;

    public const  int DOUBLE = 1;

    public const  int DOUBLE_MAX_VALUE = 4040;

    public const  int NORMAL = 0;

    public const  int NORMAL_MAX_VALUE = 3803;
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace GameCore
{
    public interface ValueCalculator 
    {
        int GetBombValue(Player player);

        int GetStraightFlushValue(Player player);

        int GetFlushValue(Player player);

        int GetStraightValue(Player player);

        int GetDoubleValue(Player player);

        int GetNormalValue(Player player);
    }

}


using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace GameCore
{
    public class FlowerValueCalculator : ValueCalculator
    {
        private int GetFlowerValue(Player player)
        {
            return player.cards[0].flower * 16 + player.cards[1].flower * 4 + player.cards[2].flower;
        }

        private int GetA32FlowerValue(Player player)
        {
            return player.cards[1].flower * 16 + player.cards[2].flower * 4 + player.cards[0].flower;
        }

        public int GetBombValue(Player player)
        {
            PlayerUtil.SortPlayerByFlower(player);
            return (player.cards[0].number + PlayerType.STRAIGHT_FLUSH_MAX_VALUE) * 64 + GetFlowerValue(player);
        }
            
        public int GetStraightFlushValue(Player player)
        {
            return (player.cards[2].number + PlayerType.FLUSH_MAX_VALUE) * 64 + GetFlowerValue(player);
        }

        public int GetFlushValue(Player player)
        {
            return (player.cards[0].number * 256 + player.cards[1].number * 16 + player.cards[2].number
                + PlayerType.STRAIGHT_MAX_VALUE) * 64 + GetFlowerValue(player);
        }

        public int GetStraightValue(Player player)
        {
            return (player.cards[2].number + PlayerType.DOUBLE_MAX_VALUE) * 64 + GetFlowerValue(player);
        }

        public int GetDoubleValue(Player player)
        {
            PlayerUtil.ExchangeSortedDoubleFlower(player);
            return (player.cards[1].number * 16 + player.cards[2].number + PlayerType.NORMAL_MAX_VALUE) * 64
                + GetFlowerValue(player);
        }

        public int GetNormalValue(Player player)
        {
            return (player.cards[0].number * 256 + player.cards[1].number * 16 + player.cards[2].number) * 64
                + GetFlowerValue(player);
        }
    }

}








JamesLiu
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
棋牌游戏（炸金花）——服务器篇
赵某人
11-20 1659
操作步骤 创建一个类库（不创建控制台应用） 创建一个类（服务器类）（ServerPeer） 启动服务器 绑定Ip和端口号 接收客服端的连接 处理连接请求 创建一个类（客服端类）（ClientServer） 代码实现如下： //服务器 using System; using System.Collections.Generic; using System.Linq; using System.N...
Unity自学之汉诺塔（4）——分辨大小
JasonArthrus的博客
11-10 495
s@[TOC]Unity自学之汉诺塔（4）——分辨大小 Unity自学之汉诺塔（4）——分辨大小 上一篇我们找到了Transform属性，用到了刚体（Rigidbody），让我们的盘子能够动起来了，而且添加了目标位置物体，让盘子能够移动到指定位置。现在我们看看怎么解决大盘子不能压在小盘子上以及每次只移动柱子最上方的盘子的问题。 只移动柱子最上方的盘子 每次进出都是最上方的盘子，这个情况有没有点熟悉的味道，回想一下上学时候学的数据结构，一种特殊的结构能够满足我们的需求。栈（stack）又名堆栈，它是一种运算受
unity源码，大富豪源码（完整棋牌服务端（c++）+客户端（unity）+各种编译）
07-17
淘宝买的，unity源码，大富豪源码（完整棋牌服务端（c++）+客户端（unity）+各种编译），是能用的，自己打开编译过。适合二次开发
Unity ScrollRect 动态缩放大小，自动定位
06-29
Unity组件扩展： ScrollRect 动态缩放格子大小，自动定位到中间的格子 文章链接： https://blog.csdn.net/qq_39108767/article/details/119490977
Unity 聚焦任意大小的物体
最新发布
06-27
Unity 聚焦物体 1.示例场景：Assets/ZYF/Tools/Camera/Scene/FocusGo/聚焦物体.unity 2.调用xxx.Focus()即可聚焦指定物体 效果展示：https://blog.csdn.net/qq_26318597/article/details/131415987
Unity3D展示必用的动态改变模型大小与方向2
08-08
Unity3D动态改变模型大小与方向的实现方法 Unity3D是一个功能强大的游戏引擎，可以创建各种类型的游戏和互动式应用程序。然而，在 Unity3D 中，如何动态改变模型的大小和方向是开发者经常遇到的问题。本文将详细...
Unity 重新设置Texture2D的大小
09-29
### Unity 重新设置Texture2D的大小 在Unity游戏开发中，经常需要处理各种纹理（Textures），特别是当涉及到动态创建或调整纹理大小时。本文将详细介绍如何使用Unity中的`Texture2D`类来重新设置其大小，并提供一个...
unity xlua 麻将棋牌游戏
10-22
unity xlua框架源码 ，麻将，棋牌类游戏，包含客户端服务器
java扎金花程序java
05-02
javaSE写的一个扎金花作业。该程序实现了扎金花游戏的所有功能。适合新学java的学者学习下。当然由于个人单独写的，时间也比较紧所有可能存在些小问题或者哪里实现方式不好。还望读者能够批评指出。
发布网页版Unity自适应网页大小2
08-08
在开发网页版Unity游戏或应用时，自适应网页大小是一个关键的考虑因素，因为它确保了内容在不同分辨率和屏幕尺寸的设备上都能正常显示。本文将详细讲解如何实现Unity自适应网页大小，以及与PlayerSettings设置的关系...
unity常用算法，设计模式
烧仙草奶茶的博客
10-21 3354
1.冒泡排序： 依次比较两个相邻的元素，如果前一个元素大于后一个元素，则交换，直到最后一个元素为最大值，然后重复相同的动作，直到倒数第二个元素为第二大，依次类推。 时间复杂度是O（n2）稳定性最好，但是耗时多 稳定性：保证排序前两个相等的数在序列的前后位置在排序后前后顺序还是相同的。 2.选择排序： 第一次总待排序的数据元素中选出最小的一个元素（或者最大元素），与数列起始处的元素交换位置，放在数列...
Unity3D开源棋牌游戏
热门推荐
xiangzhihong8的专栏
07-22 1万+
棋牌金币游戏 功能介绍 金币类棋牌游戏大厅！！！ 可以自由组合，开发出不同的大厅，打造自己的大厅！游戏大厅支持斗地主,3D麻将 (红中麻将,血战麻将,广东麻将等),多款捕鱼（金蟾捕鱼，悟空脑海，摇钱树，美人鱼），跑得快等各种益智棋牌游戏（请看最后一张图片）,支持多人娱乐，支持茶馆俱乐部。当然当你了解项目后，你也可以自己开发自己的游戏，打造自己完整的产品。 软件技术 开发工具：Unity3D （Unity 5.4.0f3 ） 开发语言：Java + C# 服务端框架：SmarkfoxServer2x + My
良心安利Unity3D U3D游戏源码素材网站
m0_61353765的博客
12-07 9081
最近看到很多朋友吐槽Unity3D U3D游戏源码素材不好找，有时花了大把时间却没找到合适的，而且有的时候会涉及到版权问题，付费问题等，不仅工作效率降低，还闹心郁闷，所以今天就给大家分享一下小编自己在亲身体验和搜寻网站中，收集到的免费的Unity3D U3D游戏源码素材网站，希望能够帮助到大家。 接下来就给大家介绍一下我珍藏已久的网站：爱给网，我的工作灵感都是来源它哦，里面的Unity3D U3D游戏源码资源数量多，种类丰富，并且每隔一个月都会更新一次资源，可以说是非常宝藏了！ 为大家整理了游戏源码-U
c#unity代码_发布Unity C＃源代码
culiao6493的博客
09-14 806
This Friday we published the Unity engine and editor C# source code on GitHub, under a reference-only license. 这个星期五，我们以仅供参考的许可在GitHub上发布了Unity引擎和编辑器C＃源代码。 等等...什么？ (Wait… what?) It’s always been p...
【Unity&C#】使用?:表达式比较三个数大小并对其排序
BuladeMian的博客，菜得抠脚，菜得真实
02-26 6559
使用 ? : 表达式比较三个数大小并对其排序，C#的代码怎么写 设置A,B,C三个整型数字，使用 Random.Range函数来对这3个数字赋值 如下所示：         a = Random.Range(0, 100);// a         b = Random.Range(0, 100 - a);// b         c = 100 - a - b;//c
扎金花 游戏开发细节与部分代码
qq_43680030的博客
02-25 1231
扎金花 游戏开发细节与部分代码
unity transform.position 和数字比大小
06-03
在 Unity 中，可以使用 `transform.position` 访问物体的位置信息。如果要将其与数字比较大小，需要将其转换为相应的数据类型。例如，`transform.position.x` 可以转换为 `float` 类型，然后与其他数字进行比较。...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值