cocos2dx 制作单机麻将(四)

麻将逻辑5.模拟出牌

//
//  main.cpp
//  MajiangLogicTest
//
//  Created by TinyUlt on 14-8-16.
//  Copyright (c) 2014年 TinyUlt. All rights reserved.
//

#include <iostream>
using namespace std;

#define MAX_REPERTORY 144
typedef unsigned char BYTE;
typedef unsigned short WORD;
//数组维数
#ifndef CountArray
#define CountArray(Array) (sizeof(Array)/sizeof(Array[0]))
#endif
//逻辑掩码

#define	MASK_COLOR					0xF0								//花色掩码
#define	MASK_VALUE					0x0F								//数值掩码
#define MAX_INDEX	42	//最大索引
#define MAX_COUNT					14									//最大数目

const BYTE m_cbCardDataArray[MAX_REPERTORY]=
{
    0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,						//万子
    0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,						//万子
    0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,						//万子
    0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,						//万子
    0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,						//同子
    0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,						//同子
    0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,						//同子
    0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,						//同子
    0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,						//索子
    0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,						//索子
    0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,						//索子
    0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,						//索子

    0x31,0x32,0x33,0x34,												//风牌
    0x31,0x32,0x33,0x34,												//风牌
    0x31,0x32,0x33,0x34,												//风牌
    0x31,0x32,0x33,0x34,												//风牌
    0x41,0x42,0x43,														//箭牌
    0x41,0x42,0x43,														//箭牌
    0x41,0x42,0x43,														//箭牌
    0x41,0x42,0x43,														//箭牌

    0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,							//花牌

};
const char* m_cbCardWordArray[MAX_INDEX]=
{
    "一万","二万","三万","四万","五万","六万","七万","八万","九万",
    "一筒","二筒","三筒","四筒","五筒","六筒","七筒","八筒","九筒",
    "一索","二索","三索","四索","五索","六索","七索","八索","九索",
    "东", "南", "西", "北", "中", "发", "白",
    "春", "夏", "秋", "冬", "梅", "兰", "竹", "菊"
};
//混乱扑克
static void RandCardData(BYTE cbCardData[],BYTE cbMaxCount)
{
    //混乱准备
    BYTE cbCardDataTemp[CountArray(m_cbCardDataArray)];//为什么直接用MAX_REPERTORY? 由于这样无耦合
    memcpy(cbCardDataTemp,m_cbCardDataArray,sizeof(m_cbCardDataArray));//拷贝一份到暂时牌数组中

    //混乱扑克(关键的核心打乱代码)
    BYTE cbRandCount=0,cbPosition=0;
    do
    {
        cbPosition=rand()%(cbMaxCount-cbRandCount);
        cbCardData[cbRandCount++]=cbCardDataTemp[cbPosition];
        cbCardDataTemp[cbPosition]=cbCardDataTemp[cbMaxCount-cbRandCount];
    } while (cbRandCount<cbMaxCount);

    return;

}
//混乱扑克2
void RandAppointCardData(BYTE cbCardData[],BYTE cbMaxCount,BYTE OriginalData[]/*源牌堆数据*/)
{
    //混乱扑克
    BYTE cbRandCount=0,cbPosition=0;
    do
    {
        cbPosition=rand()%(cbMaxCount-cbRandCount);
        cbCardData[cbRandCount++]=OriginalData[cbPosition];
        OriginalData[cbPosition]=OriginalData[cbMaxCount-cbRandCount];
    } while (cbRandCount<cbMaxCount);

    return;
}
//扑克转换(索引->牌值)
BYTE SwitchToCardData(BYTE cbCardIndex)
{
    //assert(cbCardIndex<42);
    if(cbCardIndex<31)   return ((cbCardIndex/9)<<4)|(cbCardIndex%9+1);
    if(cbCardIndex>=31&&cbCardIndex<=33)  return(((cbCardIndex/7)<<4)+cbCardIndex%10 );
    if(cbCardIndex>33)   return(cbCardIndex+0x2F);
    //assert(false);
    return 0;
}
//扑克转换(牌型->索引)
BYTE SwitchToCardIndex(BYTE cbCardData)
{
  //  ASSERT(IsValidCard(cbCardData));
    if((cbCardData&MASK_COLOR)<=0x30)
        return (((cbCardData&MASK_COLOR)>>4)*9+(cbCardData&MASK_VALUE)-1);
    if((cbCardData&MASK_COLOR)==0x40)
        return (31+(cbCardData&MASK_VALUE)-1);
    if((cbCardData&MASK_COLOR)==0x50)
        return (34+(cbCardData&MASK_VALUE)-1);
    //ASSERT(false);
    return 0;
}

//扑克转换
BYTE SwitchToCardData(BYTE cbCardIndex[MAX_INDEX]/*传入统计全部牌数量的表格*/, BYTE cbCardData[MAX_COUNT]/*传出手牌数据*/)
{
    //转换扑克
    BYTE cbPosition=0;
    for (BYTE i=0;i<MAX_INDEX;i++)
    {
        if (cbCardIndex[i]!=0)
        {
            for (BYTE j=0;j<cbCardIndex[i];j++)
            {
               // ASSERT(cbPosition<MAX_COUNT);
                cbCardData[cbPosition++]=SwitchToCardData(i);
            }
        }
    }

    return cbPosition;//返回手牌数
}
//依据中文牌,得到牌索引
int getIndexByWord(const char* ch)
{
    for (int i = 0; i < MAX_INDEX; i++)
    {
        if (!strcmp(ch,m_cbCardWordArray[i]))
        {
            return i;
        }
    }
    return -1;
}
//删除扑克
bool RemoveCard(BYTE cbCardIndex[MAX_INDEX], BYTE cbRemoveCard)
{

    //效验扑克
    //ASSERT(IsValidCard(cbRemoveCard));
    BYTE cbRemoveIndex=SwitchToCardIndex(cbRemoveCard);
    //ASSERT(cbCardIndex[cbRemoveIndex]>0);

    //删除扑克
    if (cbCardIndex[cbRemoveIndex]>0)
    {
        cbCardIndex[cbRemoveIndex]--;
        return true;
    }

    //失败效验
   // ASSERT(FALSE);

    return false;
}

int main(int argc, const char * argv[])
{
    // insert code here...

    /*第一种混乱发*/
    //创建一个空牌堆
    BYTE _cardData1[MAX_REPERTORY];
    //把在该函数中创建并打乱牌堆,然后把指针传给_cardData;
    RandCardData(_cardData1, MAX_REPERTORY);
    //输出牌数据
    cout<<"混乱初始牌堆"<<endl;
    for (int i = 0 ; i < MAX_REPERTORY; i++)
    {
        cout<<hex<<"0x"<<int(_cardData1[i])<<" ";
    }
    cout<<endl;
    cout<<endl;

    /*另外一种混乱发*/
    //创建一个空牌堆
    BYTE _cardData2[MAX_REPERTORY];
    //把在该函数中创建并打乱牌堆,然后把指针传给_cardData;
    RandAppointCardData(_cardData2, MAX_REPERTORY,_cardData1);
    //输出牌数据
    cout<<"混乱指定牌堆"<<endl;
    for (int i = 0 ; i < MAX_REPERTORY; i++)
    {
        cout<<"0x"<<int(_cardData2[i])<<" ";
    }
    cout<<endl;
    cout<<endl;

    /*加入手牌*/
    //虚拟一副手牌 開始游戏时,每人13张手牌,然后庄家再摸一张牌即14张
    //我们使用上面初始化好的牌堆,进行摸牌,如果仅仅有一个玩家
    BYTE cbCardIndex[MAX_INDEX];
    for (int i = 0; i < MAX_COUNT; i++)
    {
        BYTE _cardValue = _cardData2[i];//得到牌堆中的牌
        int _index = SwitchToCardIndex(_cardValue);//得到该牌相应的索引
        cbCardIndex[_index]++;//该牌型加一
    }

    cout<<"输出全部牌型相应的数量"<<endl;
    for (int i = 0; i< MAX_INDEX; i++)
    {
        cout<<hex<<m_cbCardWordArray[i]<<"(0x"<<int(SwitchToCardData(i))<<"):"<<dec<<(int)cbCardIndex[i]<<" ";//输出手牌中全部牌型相应的数量
    }
    cout<<endl;
    cout<<endl;

    cout<<"输出手牌数据"<<endl;
    BYTE cbCardData[MAX_COUNT];
    int _handsCount = (int)SwitchToCardData(cbCardIndex,cbCardData);
    cout<<"手牌数量为:"<<_handsCount<<endl;
    for (int i = 0 ; i < MAX_COUNT; i++)
    {
        cout<<m_cbCardWordArray[SwitchToCardIndex(cbCardData[i])]<<"(0x"<<hex<<(int)cbCardData[i]<<") ";
    }

    cout<<endl;
    cout<<endl;

    /*出牌*/
    char ch[20];
    cout<<"输入要出的牌(比方 三万): ";
    cin>>ch;
    int _outCardIndex = getIndexByWord(ch);
    if (_outCardIndex == -1)
    {
        cout<<"输入错误"<<endl;
        return 0;
    }
    BYTE _outCardValue = SwitchToCardData(_outCardIndex);
    bool _b = RemoveCard(cbCardIndex, _outCardValue);
    if (_b)
    {
        cout<<"出牌成功"<<endl;
    }
    else
    {
        cout<<"该牌不存在"<<endl;
    }
    BYTE _leftCardData[MAX_COUNT];
    int _leftHandsCount = (int)SwitchToCardData(cbCardIndex,_leftCardData);
    cout<<"手牌数量为:"<<dec<<_leftHandsCount<<endl;
    cout<<"手牌数据为:"<<endl;
    for (int i = 0 ; i < _leftHandsCount; i++)
    {
        cout<<m_cbCardWordArray[SwitchToCardIndex(_leftCardData[i])]<<"(0x"<<hex<<(int)_leftCardData[i]<<") ";
    }

    cout<<endl<<endl;
    return 0;
}

输出:

混乱初始牌堆

0x25 0x13 0x1 0x3 0x21 0x43 0x54 0x14 0x9 0x12 0x13 0x8 0x31 0x24 0x13 0x31 0x6 0x4 0x28 0x31 0x34 0x18 0x7 0x27 0x15 0x18 0x51 0x11 0x42 0x12 0x28 0x2 0x57 0x25 0x16 0x4 0x33 0x15 0x18 0x21 0x42 0x33 0x29 0x41 0x25 0x3 0x23 0x55 0x14
0x41 0x27 0x22 0x34 0x21 0x2 0x9 0x29 0x19 0x43 0x23 0x22 0x22 0x19 0x34 0x16 0x15 0x32 0x58 0x6 0x28 0x17 0x21 0x18 0x8 0x43 0x28 0x33 0x32 0x6 0x33 0x2 0x25 0x14 0x11 0x29 0x19 0x26 0x13 0x4 0x24 0x53 0x52 0x16 0x15 0x27 0x3 0x27 0x31 0x9 0x1 0x26 0x22 0x3
0x32 0x17 0x26 0x26 0x7 0x12 0x42 0x41 0x32 0x17 0x8 0x7 0x9 0x34 0x8 0x7 0x16 0x17 0x41 0x19 0x5 0x29 0x2 0x23 0x6 0x4 0x24 0x42 0x24 0x1 0x56 0x11 0x1 0x12 0x5 0x23 0x11 0x14 0x43 0x5 0x5 

混乱指定牌堆

0x16 0x56 0x21 0x7 0x28 0x14 0x41 0x12 0x16 0x24 0x43 0x21 0x31 0x26 0x3 0x53 0x52 0x7 0x12 0x34 0x51 0x14 0x9 0x29 0x23 0x33 0x12 0x31 0x14 0x6 0x16 0x18 0x54 0x21 0x25 0x58 0x19 0x5 0x7 0x28 0x32 0x34 0x1 0x27 0x27 0x33 0x6 0x14 0x9
0x17 0x25 0x33 0x28 0x11 0x17 0x24 0x43 0x2 0x22 0x6 0x23 0x3 0x11 0x42 0x2 0x18 0x3 0x4 0x42 0x4 0x18 0x55 0x25 0x42 0x22 0x32 0x4 0x15 0x8 0x29 0x24 0x13 0x6 0x26 0x19 0x9 0x41 0x25 0x7 0x8 0x1 0x13 0x11 0x15 0x41 0x43 0x57 0x16 0x33 0x18 0x32 0x27 0x1 0x8
0x12 0x31 0x4 0x5 0x27 0x22 0x26 0x23 0x31 0x2 0x5 0x17 0x26 0x13 0x19 0x43 0x17 0x21 0x42 0x5 0x3 0x19 0x23 0x15 0x28 0x15 0x8 0x24 0x9 0x29 0x13 0x32 0x34 0x2 0x34 0x41 0x11 0x29 0x22 0x1 

输出全部牌型相应的数量

一万(0x1):0
二万(0x2):0 三万(0x3):0
四万(0x4):0 五万(0x5):0
六万(0x6):0 七万(0x7):1
八万(0x8):0 九万(0x9):0
一筒(0x11):0 二筒(0x12):1
三筒(0x13):0 四筒(0x14):1
五筒(0x15):0 六筒(0x16):2
七筒(0x17):0 八筒(0x18):0
九筒(0x19):0 一索(0x21):2
二索(0x22):0 三索(0x23):0
四索(0x24):1 五索(0x25):0
六索(0x26):1 七索(0x27):0
八索(0x28):1 九索(0x29):0
东(0x31):1 南(0x32):0
西(0x33):0 北(0x34):0
中(0x41):1 发(0x42):0
白(0x43):1 春(0x51):0
夏(0x52):0 秋(0x53):0
冬(0x54):0 梅(0x55):0
兰(0x56):1 竹(0x57):0
菊(0x58):0 

输出手牌数据

手牌数量为:14

七万(0x7) 二筒(0x12)
四筒(0x14) 六筒(0x16)
六筒(0x16) 一索(0x21)
一索(0x21) 四索(0x24)
六索(0x26) 八索(0x28)
东(0x31) 中(0x41)
白(0x43) 兰(0x56) 

输入要出的牌(比方
三万): 七万

出牌成功

手牌数量为:13

手牌数据为:

二筒(0x12)
四筒(0x14) 六筒(0x16)
六筒(0x16) 一索(0x21)
一索(0x21) 四索(0x24)
六索(0x26) 八索(0x28)
东(0x31) 中(0x41)
白(0x43) 兰(0x56) 

Program ended with exit code: 0

时间： 2024-07-30 23:52:41

cocos2dx 制作单机麻将(四)的相关文章

cocos2dx 制作单机麻将(六)

当项目做到这时, 会发现项目结构不是太美. 如果接着按照这样面向结构的方式写的话, 就会非常的乱. 这章我们来讨论如何用面向对象的方式写麻将. 标准的麻将(联网的) 会分为服务器模块, 客户端模块, 逻辑模块. 服务器模块必须由逻辑模块支持, 客户端模块很少用到逻辑模块,大多是从服务器发来的判断结果,必要时还是会用到逻辑模块. 因为逻辑模块需要共用, 所以里面都是调用的接口,返回服务器和客户端需要的结果值. 举个例子 客户端触发开始发生给服务端 > 服务端开始游戏 > 通过逻辑模块得到整理好的

cocos2dx 制作单机麻将(三)

麻将逻辑4.得到手牌数据 我们已经保存了一个一维数组, 类似于一个表格,统计出所有牌对应的数量, 但我们怎样得到当前手中是什么牌呢 //扑克转换 BYTE SwitchToCardData(BYTE cbCardIndex[MAX_INDEX]/*传入统计所有牌数量的表格*/, BYTE cbCardData[MAX_COUNT]/*传出手牌数据*/) { //转换扑克 BYTE cbPosition=0; for (BYTE i=0;i<MAX_INDEX;i++) { if (cbCardI

cocos2dx 制作单机麻将(二)

麻将逻辑2. 打乱麻将顺序2 前面讲解了如何打乱初始给定的麻将牌堆, 还有一种是打乱任意给定的麻将牌堆 //混乱扑克2 void RandAppointCardData(BYTE cbCardData[],BYTE cbMaxCount,BYTE OriginalData[]/*源牌堆数据*/) { //混乱扑克 BYTE cbRandCount=0,cbPosition=0; do { cbPosition=rand()%(cbMaxCount-cbRandCount); cbCardData

cocos2dx 制作单机麻将(一)

今天開始打算解说下cocos2dx下怎样制作国标麻将 前半部分先解说麻将的逻辑部分,由于都是代码,可能会比較枯燥无聊. 这部分讲完后,你也能够用其它游戏引擎来制作麻将 后半部分,就解说余下的cocos2dx部分, 由于要把这部分留到后面讲,主要是还在考虑用3d做还是用2d做. 到最后能够扩展AI部分的机器人 和 server模块 麻将逻辑1. 打乱麻将顺序(初始化牌堆) 国标麻将共同拥有144张牌 #define MAX_REPERTORY 144 先把全部的牌放入一个常量数组中保存 每种牌都是

cocos2dx 制作单机麻将(五)

麻将逻辑6 最基础的4人麻将逻辑(轮流循环出牌, 之前学的都能用上  跑起来了!!!) 最基础的麻将逻辑 依据自己须要 设置麻将人数GAME_PLAYER 基本流程: 初始化牌堆, 推断庄家 玩家0摸13张牌 玩家1摸13张牌 玩家2摸13张牌 玩家3摸13张牌 庄家摸一张牌 庄家出牌 闲家摸牌 闲家出牌 闲家摸牌 闲家出牌 闲家摸牌 闲家出牌 庄家摸一张牌 庄家出牌 闲家摸牌 闲家出牌 ....... 牌堆数为0 结束 其它功能 比方 碰吃杠听胡等等 先不实现 代码不难,非常easy看懂 //

cocos2dx《单机斗地主》源码解剖之八 电脑玩家出牌与跟牌（结束）

上一篇文章对玩家手中的牌进行分析归类,下面就该实现电脑玩家出牌与跟牌的策略了.首先我们来看看出牌的策略,代码如下: void GameScene::update(float delta){ switch (m_iState) { case 0: SendPk(); break; case 1: schedule(schedule_selector(GameScene::Call),1); break; case 2: scheduleOnce(schedule_selector(GameScen

【cocos2d-x制作别踩白块儿】第九期：游戏计时功能(附源代码)

游戏没有计时,不是坑爹吗? 这一期,我们将来加入游戏计时功能. 1. 定义变量和函数 我们先在HelloWorldScene.h中定义几个变量和函数 long startTime; bool timeRunning; startTime用来记录開始的时间,timeRunning用来推断游戏是否在进行中. //開始计时 void startTimer(); //结束计时 void stopTimer(); virtual void update(float dt); startTimer()函数时

Cocos2dx制作2048(3.数字相加逻辑)

这次我们来完成整个2048的数字相加逻辑其实2048玩起来简单,做起来也简单,复杂就复杂在这整个游戏的逻辑. 1.分析向左滑动 第一轮相加步骤: 1. 单1+单2    单1=2  单2赋值为0         (单1为空,可以加任何数字) 2. 单1+单3    单1=4   单3赋值为0    (单1不为空,只能加和他相同的数字) 3. 单1+单4    单1=4   单4不变              (单1不为空,只能加和他相同的数字) 第二轮相加步骤: 1.   单2+单3    单2

使用cocos2d-x制作 Texture unpacker

使用cocos2d-x制作 Texture unpacker 没错,就是unpacker. 在大多数游戏包里面,可以找到很多纹理图集,他们基本上是用texture packer制作的,有plist文件和png图片组成. 如果原来的小图比较少,倒是可以自己在plist里面找名字,如果小图有几百张,那真的会找疯掉.所以今天就用cocos2d-x引擎制作了一个将纹理大图解包成一张张小图的工具. 1. 解析plist文件 cocos2d-x引擎中实现了解析plist纹理的逻辑,SpriteFrameCa