C++开发斗地主(QT)第五篇之牌型权重

最新推荐文章于 2024-07-09 12:40:13 发布
最新推荐文章于 2024-07-09 12:40:13 发布
阅读量1.9k 收藏 18
点赞数 5
分类专栏： 斗地主源码 斗地主AI分析 QT 文章标签： 算法 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/keepmoving0407/article/details/105774429
版权

 

牌型权重

给定一组手牌，怎么计算它的权重呢？我们可以把手牌切分成不同的牌型，一次出牌只能出一个牌型(CardNode)，手上有多少个Node就是手数。 我们可以对每种牌型，同一个牌型的每个面值，设置不同的权重。权重可以是正值，也可以是负值。

斗地主以跑牌成功为胜利，手上多一张牌，就多一分负担(。 我们可以考虑以厌恶度来衡量每张牌型的权重。如果出完手上的牌，那么手数为0，权重设为0；以此为基础，面值越小，权重越低，每多一手数就再降低一定的权重。//牌型结构体变量的定义
 

// 权重计算
#define kOneHandPower (-150) //是每多一手数，就需要降低的权重，
#define kPowerUnit (-100)//是基础厌恶值， 我们通过对不同的牌型，设置不同的bad度，最后得出牌型的权重:
#define kMinPowerValue (-1000000000.0f)//最小权重值

版型CardNode.h头文件：

#define kOneHandPower (-150) //是每多一手数，就需要降低的权重，
#define kPowerUnit (-100)//是基础厌恶值， 我们通过对不同的牌型，设置不同的bad度，最后得出牌型的权重:
#define kMinPowerValue (-1000000000.0f)//最小权重值

//合并两个vector
template <typename Ele>
void mergeTwoVectors(std::vector<Ele> & dest, const std::vector<Ele> &src) {
    dest.insert(dest.end(), src.begin(), src.end());
}

//牌型结构体
struct CardNode
{
    int32_t cardType;//牌型三种： 1 不是连续的牌，包括三条带  ，2 连续的牌 包括顺子  双顺 飞机 ， 3 火箭 也就是双王
    int32_t value ;//牌的值是指单纯类型为牌的面值，连续类型为起始牌的面值，相同牌型以此比较大小;
    int32_t mainNum; //主牌张数
    int32_t seralNum;//连续张数
    int32_t subNum;//副牌张数（三条 四条所带的牌）
    float aggregate;//权重
    std::vector<int> cards;//所有的牌
public:
    CardNode();
    CardNode(int type, int val, int mainN, int len, int sub);
    CardNode(const CardNode &other);
    //赋值
    CardNode & operator = (const CardNode &other);
    bool isValidNode() const;
    //重置为0
    void resetNode();
    //获取最大牌值
    int getTopValue() const;
    //把版型变为王炸
    void fillJokers() ;
    //合并牌型的牌
    void merge(const CardNode & other);
    //是否火箭
    bool isRocket() const;
    //是否炸弹
    bool isBomb() const;
    //比较 是否比Other牌型小
    bool isExactLessThan(const CardNode & other) const;
    //比较 是否比Other牌型小
    bool isStrictLessThan(const CardNode &other) const;
    //获取牌型的权重
    float getPower() const;
    //比较 是否小于
    bool operator < (const CardNode & other) const;
    //是否相等
    bool isEqualTo(const CardNode & other) const;
    //获取牌的花色和值字符串
    std::string description() const ;
};

 

版型CardNode.cpp文件：

 

CardNode::CardNode() {
    resetNode();
}

CardNode::CardNode(int type, int val, int mainN, int len, int sub) {
    cardType = type;
    value = val;
    mainNum = mainN;
    seralNum = len;
    subNum = sub;
    aggregate = 0.0f;
    cards.clear();
}

CardNode::CardNode(const CardNode &other) {
    cardType = other.cardType;
    mainNum = other.mainNum;
    value = other.value;
    seralNum = other.seralNum;
    subNum = other.subNum;
    aggregate = other.aggregate;
    cards = other.cards;
}

CardNode & CardNode::operator = (const CardNode &other) {
    cardType = other.cardType;
    mainNum = other.mainNum;
    value = other.value;
    seralNum = other.seralNum;
    subNum = other.subNum;
    aggregate = other.aggregate;
    cards = other.cards;
    return *this;
}
//是否是一种牌型
bool CardNode::isValidNode() const {
    return mainNum != 0;
}

void CardNode::resetNode() {
    cardType = 0;
    value = 0;
    mainNum = 0;
    seralNum = 0;
    subNum = 0;
    aggregate = 0.0f;
    cards.clear();
}
//获取最大一张牌的值
int CardNode::getTopValue() const {
    int top = value;
    //顺子 或 连对 或飞机
    if (cardType == kCardType_Serial) {
        //牌的起始值+连续长度-1
        top = value + seralNum - 1;
    }
    return top;
}

//把大小王放到牌中
void CardNode::fillJokers() {
    cards.clear();

    if (cardType == kCardType_Rocket) {
        cards.push_back(kCard_Joker1);
        cards.push_back(kCard_Joker2);
    } else {
        assert(false);
    }
}
//是否火箭
bool CardNode::isRocket() const {
    return cardType == kCardType_Rocket;
}

bool CardNode::isBomb() const {
    return (seralNum==1 && mainNum >= 4 && subNum == 0);
}


// 比较是否比同一个牌型other小
bool CardNode::isExactLessThan(const CardNode & other) const {
    if (!isValidNode()) {
        return true;
    }
    return (cardType == other.cardType && mainNum == other.mainNum
            && subNum == other.subNum && seralNum == other.seralNum
            && getTopValue() < other.getTopValue());
}

// 比较炸弹是否比other小
bool CardNode::isStrictLessThan(const CardNode &other) const {
    if (!isValidNode())
        return true;

    if (isRocket()) {//自己是火箭最大
        return false;
    }
    if (other.isRocket()) {//它是火箭，肯定比它小
        return true;
    }
    if (isBomb() && other.isBomb()) {
        return getTopValue() < other.getTopValue();
    } else if (isBomb()) {
        return false;
    } else if (other.isBomb()) {
        return true;
    }

    return isExactLessThan(other);
}

 //合并两个型中的牌
void CardNode::merge(const CardNode & other) {
    mergeTwoVectors(cards, other.cards);
}

// 计算当前牌型的权重，全部是预估的；应该用AI来估算会更准确
//会返回每个节点的权重。对于某些大牌，权重为正，剩下的牌型，越厌恶的权重越小
float CardNode::getPower() const {
    float bad  = 0.0f;
    //牌型为火箭
    if (cardType == kCardType_Rocket)
    {
        bad = -8.0f; // -1.5 * 4.2f
    }
    else
    {
        //最高值为 牌值大小*2+连续张数 再除以2
        //假如对2的最高值为（15+15+1）/2=15.5 对3的最高值为： （3+3+1）/2=3.5
        //334455这样的牌型值为：（3+3+3）/2=4.5
        float top = ( value + value + seralNum)/2.0f;
        if (mainNum == 4)//如果为炸弹
        {
            if (subNum)//四张带了牌，权重变低
            {
                bad = -1.5 * 3.0f + 0.003 * (kCard_Value2 - top) + (seralNum > 1 ? seralNum : 0) * 0.002 - subNum * 0.002;
            }
            else if (value == kCard_Value2)//四张2
            {
                bad = -1.5f * 3.1f;
            }
            else //其它的四张
            {
                bad = -1.5f * 4.0f + 0.175 * (kCard_Value2 - top) + (seralNum > 1 ? seralNum : 0) * 0.002;
            }
        }
        else if (mainNum == 3)//三张
        {
            bad = 0.433  + 0.02 * (kCard_Value2 - top) + (seralNum > 1 ? seralNum : 0)  * 0.02 - subNum * 0.01;
        }
        else if (mainNum == 2) //对子
        {
            bad = 0.437  + 0.015 * (kCard_Value2 - top) + (seralNum > 2 ? seralNum : 0) * 0.02;
        }
        else  // 单牌
        {
            bad = 0.435  + 0.0151 * (kCard_Value2 - top) + (seralNum > 4 ? seralNum : 0) * 0.02;
        }
    }
    float ret = kOneHandPower + kPowerUnit * bad;
    return ret;
}


//比较牌是否比Other小
bool CardNode::operator < (const CardNode & other) const {
    if (mainNum != other.mainNum) {
        return mainNum > other.mainNum;
    }

    if (value != other.value) {
        return value < other.value;
    }

    if (cardType != other.cardType) {
        return cardType < other.cardType;
    }

    if (seralNum != other.seralNum) {
        return seralNum < other.seralNum;
    }

    if (cards.size() != other.cards.size()) {
        return cards.size() < other.cards.size();
    }

    for (int i=0; i<cards.size(); ++i) {
        if (cards[i] != other.cards[i]) {
            return cards[i] < other.cards[i];
        }
    }
    return false;
}
//比较牌是否和Other相等
bool CardNode::isEqualTo(const CardNode & other) const {
    if (isRocket() && other.isRocket()) {
        return true;
    }
    if (mainNum == other.mainNum && value == other.value
            && seralNum == other.seralNum && subNum == other.subNum) {
        return cards == other.cards;
    } else {
        return false;
    }
}


static const char * cardSuits[] = {"♣️", "♦️", "♥️", "♠️"};
static const char * cardValues[] = {"", "1", "2", "3", "4", "5", "6", "7", "8", "9", "T", "J", "Q", "K", "A", "2"};
//获取牌的花色和值字符串
std::string CardNode::description() const {
    std::string ret = "";

    for (int i=0; i<cards.size(); ++i) {
        if (cards[i] == kCard_Flower) {
            ret += "🌹 ";
        } else if (cards[i] == kCard_Joker1) {
            ret += "jj ";
        } else if (cards[i] == kCard_Joker2) {
            ret += "JJ ";
        } else {
            ret += cardSuits[LordCards::getCardSuit(cards[i])];
            ret += cardValues[LordCards::getCardValue(cards[i])];
            ret += " ";
        }
    }

    return ret;
}

// 计算当前牌型的权重，全部是预估的；应该用AI来估算会更准确
float CardNode::getPower() const {
float bad = 0.0f;
//牌型为火箭
if (cardType == kCardType_Rocket) {
bad = -8.0f; // -1.5 * 4.2f
} else {
  //最高值为 牌值大小*2+连续张数 再除以2
  //假如对2的最高值为（15+15+1）/2=15.5 对3的最高值为： （3+3+1）/2=3.5
//334455这样的牌型值为：（3+3+3）/2=4.5
float top = ( value + value + seralNum)/2.0f;
if (mainNum == 4)//如果为炸弹
{
if (subNum) {//四张带了牌，权重变低
bad = -1.5 * 3.0f + 0.003 * (kCard_Value2 - top) + (seralNum > 1 ? seralNum : 0) * 0.002 - subNum * 0.002;
} else if (value == kCard_Value2) { //四张2
bad = -1.5f * 3.1f;
} else {//其它的四张
bad = -1.5f * 4.0f + 0.175 * (kCard_Value2 - top) + (seralNum > 1 ? seralNum : 0) * 0.002;
}
} else if (mainNum == 3) {//三张
bad = 0.433 + 0.02 * (kCard_Value2 - top) + (seralNum > 1 ? seralNum : 0) * 0.02 - subNum * 0.01;
} else if (mainNum == 2) {//对子
bad = 0.437 + 0.015 * (kCard_Value2 - top) + (seralNum > 2 ? seralNum : 0) * 0.02;
} else { // 单牌
bad = 0.435 + 0.0151 * (kCard_Value2 - top) + (seralNum > 4 ? seralNum : 0) * 0.02;
}
}
float ret = kOneHandPower + kPowerUnit * bad;
return ret;
}

CardNode.getPower() 会返回每个节点的权重。对于某些大牌，权重为正，剩下的牌型，越厌恶的权重越小。

下面通过实例让你明白什么是权重

假如抓到这样一手牌

我列出所有能出的牌型（21种）的权重,其中火箭的权重达到650，其它都是负值，值的大小是由kOneHandPower (-150)和#kPowerUnit (-100)。决定 的，可以改变它们的值来改变权重的值，这里只注重大小，不注重正负！

0 "(7,6,5,4,3,)" "牌型:2,起始牌的值:3,主牌张数:1,连续张数:5,副牌数目:0,牌的权重：-217.845"

1 "(6,)" "牌型:1,起始牌的值:6,主牌张数:1,连续张数:1,副牌数目:0,牌的权重：-206.335"

2 "(14,14,13,13,12,12,)" "牌型:2,起始牌的值:12,主牌张数:2,连续张数:3,副牌数目:0,牌的权重：-201.95"

3 "(10,10,)" "牌型:1,起始牌的值:10,主牌张数:2,连续张数:1,副牌数目:0,牌的权重：-200.45"

4 "(11,)" "牌型:1,起始牌的值:11,主牌张数:1,连续张数:1,副牌数目:0,牌的权重：-198.785"

5 "(10,)" "牌型:1,起始牌的值:10,主牌张数:1,连续张数:1,副牌数目:0,牌的权重：-200.295"

6 "(14,13,12,11,10,)" "牌型:2,起始牌的值:10,主牌张数:1,连续张数:5,副牌数目:0,牌的权重：-207.275"

7 "(12,12,)" "牌型:1,起始牌的值:12,主牌张数:2,连续张数:1,副牌数目:0,牌的权重：-197.45"

8 "(13,13,)" "牌型:1,起始牌的值:13,主牌张数:2,连续张数:1,副牌数目:0,牌的权重：-195.95"

9 "(14,14,)" "牌型:1,起始牌的值:14,主牌张数:2,连续张数:1,副牌数目:0,牌的权重：-194.45"

10 "(12,)" "牌型:1,起始牌的值:12,主牌张数:1,连续张数:1,副牌数目:0,牌的权重：-197.275"

11 "(13,)" "牌型:1,起始牌的值:13,主牌张数:1,连续张数:1,副牌数目:0,牌的权重：-195.765"

12 "(14,)" "牌型:1,起始牌的值:14,主牌张数:1,连续张数:1,副牌数目:0,牌的权重：-194.255"

13 "(3,)" "牌型:1,起始牌的值:3,主牌张数:1,连续张数:1,副牌数目:0,牌的权重：-210.865"

14 "(4,)" "牌型:1,起始牌的值:4,主牌张数:1,连续张数:1,副牌数目:0,牌的权重：-209.355"

15 "(5,)" "牌型:1,起始牌的值:5,主牌张数:1,连续张数:1,副牌数目:0,牌的权重：-207.845"

16 "(6,6,)" "牌型:1,起始牌的值:6,主牌张数:2,连续张数:1,副牌数目:0,牌的权重：-206.45"

17 "(7,)" "牌型:1,起始牌的值:7,主牌张数:1,连续张数:1,副牌数目:0,牌的权重：-204.825"

18 "(17,16,)" "牌型:3,起始牌的值:16,主牌张数:1,连续张数:1,副牌数目:0,牌的权重：650"

19 "(16,)" "牌型:1,起始牌的值:16,主牌张数:1,连续张数:1,副牌数目:0,牌的权重：-191.235"

20 "(17,)" "牌型:1,起始牌的值:17,主牌张数:1,连续张数:1,副牌数目:0,牌的权重：-189.725"

看上面的列表，可以看出排在第一是34567顺子，为什么把它排在第一，这排是按什么算法排的，下一篇介绍：怎样列出所有能出的牌型和该出哪个牌型最对整个牌布局最好，也就是出哪个牌型对整个牌的权重最高！

八爪鱼keepmoving8
关注
  • 5
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++基于QT实现的欢乐斗地主源代码
2301_76484015的博客
09-04 1232
一副牌 54 张，一人 17 张，留 3 张做底牌，在确定地主之前玩家不能看到底牌。飞机带翅膀和四带二按其中的三顺和四张部分来比，带的副牌不参与牌型大小的比较。除火箭和炸弹外，其它牌必须要牌型相同且总数量相同才能比大小。如果使用的编译套件是 MSVC，资源文件直接放到可执行程序。不同地域游戏规则可能有些许差异，游戏按照如下规则进行实现。炸弹比王炸小，比其它牌型大。都是炸弹时按牌的点数比大小。对牌，三张点数相同的牌都按点数比大小。顺子按最大的一张牌的点数来比大小。王炸最大，可以压任意其他的牌型。
C++实现的斗地主游戏
11-16
本项目实现了斗地主游戏的玩法，它包含了获取所有的牌型等功能。
C++_QT以及QT斗地主项目笔记
最新发布
m0_49013185的博客
07-09 1067
里面记录了很多学习C++和QT时遇到的困惑和解决办法，还有自己的一些思考，以及Java与C++同步学习的心得体会。文章中末尾的QT斗地主项目是看了「爱编程的大丙」老师在B站上的课程之后写的小项目，很遗憾目前还没有完成，后续有时间的话，一定会从头到尾完整复刻一遍
C++项目之斗地主
幻想无价值！
09-19 5906
这是一款纸牌休闲类型的游戏， 采用C++语言开发， 实现了纸牌(斗地主)的基本功能， 综合了音乐，动画，美术等多种艺术表达形式。 游戏的实现框架： CObject                 图片父类 CImageFile           图片类（CSprite精灵类） CGUIEdit
C++之构造函数/析构函数——斗地主
DAICONG’s Blog
11-20 174
知识点比较多，包括构造函数，析构函数相关的知识，考察的比较全面。除了类本身的定义，包括类的创建，构造函数的声明(4个不同的构造函数)，函数的定义(showinfo)，析构函数(一个就够了)，可以看到构造函数的重载，不同参数个数之间，构造函数的命名方式，域空间解析运算符的使用，析构函数的运行方式(堆和栈)，内存被回收释放的顺序，.h用来放函数声明。.cpp放函数的定义等等知识点 //main.c...
斗地主（C++实现）
02-07
斗地主是一个很流行的游戏，如何编程实现它，这里提供一个难得的有趣的学习C++的实例！
C++斗地主（建议用DEV实现）
weixin_46725895的博客
08-05 1270
#include<bits/stdc++.h> #define PLAYERCOUNT 3 #define CARDSCOUNT 54 #define CURRENTPLAYER 0 #define VALUECOUNT 17 #define ERROR -1 using namespace std; const char toFigure[]="34567890JQKA 2YZ"; enum COLOR{ //花色显示ASCII: 3~6 eHEART=3,//红桃 eD
基于 QT（C++） 开发的斗地主游戏【100010583】
01-30
详情介绍：https://www.yuque.com/sxbn/ks/100010583 双方连接完毕后，进入游戏界面，此时会有斗地主专属音乐循环响起。游戏界面主要有四大区域：己方区域、下家信息区、上家信息区、公共区域。
Qt 5.9 C++开发指南-Qt核心特点源码
09-16
**Qt 5.9 C++ 开发指南：深入理解Qt核心特点与源码解析** Qt是一个流行的开源跨平台应用程序开发框架，广泛应用于桌面、移动和嵌入式系统。Qt 5.9是其一个重要的版本，它在稳定性和性能上都有显著提升，同时也引入...
C++开发基于Qt开发的数控铣刀管理系统源码.zip
06-01
C++开发基于Qt开发的数控铣刀管理系统源码.zip 开箱即用！！！！！！C++开发基于Qt开发的数控铣刀管理系统源码.zip 开箱即用！！！！！！C++开发基于Qt开发的数控铣刀管理系统源码.zip 开箱即用！！！！！！C++开发...
Qt 5.9 C++开发指南
04-09
Qt是一套应用程序开发类库，但与MFC不同，Qt是跨平台的开发类库。Qt支持PC和服务器的平台，包括Windows、Linux、macOS等，还支持移动和嵌入式操作系统，如iOS、Embedded Linux、Android、WinRT等。跨平台意味着只需...
斗地主程序（一个用c++实现的功能不错的斗地主程序）
07-06
收集的一个关于c++的斗地主的程序，有兴趣的朋友可以下载学习交流！！！
斗地主的开发程序
05-28
斗地主的c++开发代码 ! 很详细，包括设计文档，源代码，流程图等！ 也有整个软件的需求分析！
斗地主c++游戏代码资源
05-25
斗地主c++游戏代码资源！
基于QT+C++开发的欢乐斗地主游戏+源码（毕业设计&课程设计&项目开发）
05-01
基于QT+C++开发的欢乐斗地主游戏+源码，适合毕业设计、课程设计、项目开发。项目源码已经过严格测试，可以放心参考并在此基础上延申使用~ 基于QT+C++开发的欢乐斗地主游戏+源码，适合毕业设计、课程设计、项目开发...
c++斗地主代码
2401_83004157的博客
03-19 1184
/cout<<"查找SecondFigure "<<cardGroup.type.cnt2<<"个"<<SecondFigures[0]+3<<endl;//cout<<"添加"<<cardsHolded[j]->value+3<<endl;//cout<<"查找"<<cardGroup.type.cnt1<<"个"<<firstFigure+3<<endl;if(type.typeStr=="三带一"||type.typeStr=="三带一对"||type.typeStr=="飞机"){
C++(15)--面向对象编程实践-欢乐斗地主（vector的花式输出）
sinat_40624829的博客
02-11 566
面向对象编程实践-欢乐斗地主 《老九学堂C++课程》《C++ primer》学习笔记。《老九学堂C++课程》详情请到B站搜索《老九零基础学编程C++入门》 -------------简单的事情重复做，重复的事情用心做，用心的事情坚持做(老九君)--------------- 要求：实现录入及打印地主的信息功能 实现地主的摸牌，及查看牌面的功能。 // main 文件 #include <iostream> #include "LandOwner.h" using namespace std;
C++面向对象编程练习小项目——“斗地主”
ZYunfei的博客
08-27 3518
概要 本文中的“斗地主”是简易斗地主，因为我们主要的目的是练习面向对象编程的思想，而完整的斗地主逻辑是比较复杂的，我们的重心不在那。本文斗地主规则：三个人各自为战，三个人各有若干手牌，牌面大小与斗地主一致，每次只能出一张，其他规则与斗地主近似，最终牌先出完的获胜。另外，摸牌后需自动理牌（从大到小）。 Start 创建地主类 我们在头文件H中创建LandOwner类，该类有若干变量和方法，为了后续的编程方便，我们将大部分数据写在了公有public中： #include<iostream> #inc
C++开发斗地主(QT)第二篇之牌的绘制与显示
keepmoving0407的专栏
04-25 3402
这一节为什么讲的是牌的显示？因为我觉得要学习这些，必须与实际相结合。 一.单张牌显示控件 （CardWidget） 我的QT版本是5.12.5，编译器是MinGW32，没下载的请选下载QT，下载地址：http://download.qt.io/archive/qt/ 新建一个项目名称为：Game_DDZ,点右键选AddNew，新建一个类CardWidget ，继承类为：QWidget,...
C++ Qt5开发入门与窗体实战指南
"C++ Qt5范例开发大全"是一本面向C++和Qt5初学者与进阶开发者的实用指南。本书由作者Longki编写，全面涵盖了从基础环境配置到高级功能实现的各个方面，旨在帮助读者通过实例掌握Qt5在C++环境中的应用。 第1章主要...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值