免费注册 查看新帖 |

Chinaunix

  平台 论坛 博客 文库
› 论坛 › 程序设计 › 软件配置管理 › 麻将游戏开发
最近访问板块 发新帖
查看: 7492 | 回复: 5
打印 上一主题 下一主题

麻将游戏开发 [复制链接]

yutian

论坛徽章:
0
跳转到指定楼层
1楼 [收藏(0)] [报告]
发表于 2005-09-09 14:00 |只看该作者 |倒序浏览
麻将游戏开发
最近要学习软件工程，学习之余就去网络上玩麻将，呵呵～～～

突发奇想要自己开发一个，边练手，边娱乐，何乐而不为呢

麻将游戏要用到很多模块，慢慢补来

也望各位大大多留下意见，先谢过


麻将网络游戏项目

  项目分为服务器端和客户端两大模块
  服务器端功能：提供游戏玩家注册、登录、积分、聊天服务
                为游戏提供桌号、洗牌、算番
  客户端：游戏界面，判断是否吃、碰、杠、听牌及胡牌

数据结构：麻将的数字表示
用数字0～35表示麻将牌，其中0～8代表一万到九万，9～17代表一条到九条，18～26代表一筒到九筒，27代表东风，28代表南风，29代表西风，30代表北风，31代表中，32代表发，33代表白，34代表春夏秋冬，35代表梅竹兰菊

见下表

============================================
0    1     2   3    4    5    6    7    8
============================================
一万 二万 三万 四万 五万 六万 七万 八万 九万
============================================
9    10   11   12   13   14   15   16   17
============================================
一条 二条 三条 四条 五条 六条 七条 八条 九条
============================================
18    19   20   21   22   23   24   25   26
============================================
一筒 二筒 三筒 四筒 五筒 六筒 七筒 八筒 九筒
============================================
27    28   29   30   31   32   33   34   35
============================================
东风 南风 西风 北风 红中 发财 白板  花1  花2
============================================

每个数字出现四次，代表四张牌，洗牌时采用随机算法提供牌墙

牌墙数据结构：

  圈风：
     quanfeng：（27，28，29，30）
  数组paiqiang[0..143],其中
paiqiang[0]~paiqiang[35]为东（庄）家
paiqiang[36]~paiqiang[71]为南家
paiqiang[72]~paiqiang[107]为西家
paiqiang[108]~paiqiang[143]为北家

玩家数据结构：
玩家wanjia：{
     门风：
        menfeng：（27，28，29，30）
     杠：
        gangpai{
        pai:0～33
        mingAn:0|1
              }
       gangarr[0..3]:gangpai（最多四个杠，数字表示杠的牌，结构体第二位的0表示明杠，1表示暗杠）
     碰：pengpai[0..3]:0~33最多四个碰牌
     吃：
        chipai{
           chimin0~6,9~15,18~24)
           chimax2~8,11~17,20~26)
              }吃牌中只用记录顺子的收尾即可
        chiarr[0..3]：chipai（最多有三个吃牌）
      花牌：0～8（初始化为0，每摸到一个花牌加一）
      手牌：paiInHand{
               pai[0..13],
               num:1,4,7,10,13
                     }
      要牌pai[13]：除庄家外，初始化为－1，待摸牌上手（吃牌，碰牌，杠牌摸牌，任何一家打牌）后，将对应的牌值赋值给要牌，要牌为玩家需要处理牌的标志（当非负时），当玩家处理完牌后，将牌整理后，将要牌置－1

}
当要牌置位（非负）时，要对手牌进行胡牌判断：
由于手牌已经除掉了大量的碰杠吃等情况，简化的胡牌算法：
先对pai数组加上要牌一起排序；
然后用递归算法判断是否胡牌；
最后判断是否为7对,十三么，全不靠牌型：（注，这些牌型一般不容易胡，故番数也不小哦，^_^）

  2. if(num=＝13)
  3. {
  4.   if(pai[0]==pai[1]&pai[2]==pai[3]&pai[4]==pai[5]&pai[6]==pai[7]&pai[8]==pai[9]&pai[10]==pai[11]&pai[12]==pai[13])
  5.     return 1;//七对

  7.   dblpos=－1;  //记录数组中对牌的位置；－1为没有对牌
  8.   dblnum＝0;//对的个数（如果超过两个对（可能是一个刻子）则不能胡十三么，全不靠牌型）
  9.   for(i=0;i<14;i++}
  10.    {
  11.      if(pai[i]==pai[i+1])
  12.        {
  13.            dblpos=i;
  14.            dblnum++;
  15.        }
  16.       if(dblnum>;1) break;
  17.    }


  20.    if(dblnum==1) //可能为十三么
  21.     {
  22.        tirteen=1;
  23.        for(i=0;i<14;i++)
  24.        {
  25.           if(pai[i]>;0&[pai]<8)
  26.             {
  27.                 tirteen=0;
  28.                 break;
  29.             }
  30.           else if(pai[i]>;9&[pai]<17)
  31.             {
  32.                 tirteen=0;
  33.                 break;
  34.             }
  35.            else if(pai[i]>;18&[pai]<26)
  36.             {
  37.                 tirteen=0;
  38.                 break;
  39.             }//如果任何一张牌为非么九和非字牌，则不能胡十三么，
  40.            if(tirteen) return 1;//如果全部是么九和字牌，加上进入该段程序的牌只有一个对，则十三么胡牌
  41.        }
  42.     }
  43.     else//可能为全不靠
  44.     {
  45.       nowordpos=14;//记录下最后一个不是字牌的位置
  46.       for (i=13;i>;=0;i--)
  47.        {
  48.           if(pai[i]<=26)
  49.              {
  50.               nowordpos=i;
  51.               break;
  52.              }
  53.        }
  54.       if(nowordpos<=8)//如果非字牌有9个以上，肯定不能胡全不靠
  55.      {
  56.       istirteen=1;
  57.       for(i=0;i<=nowordpos;i++)
  58.         {
  59.            if(pai[i+1]-pai[i]<3&&pai[i+1]/9==pai[i]/9)//如果存在同一花色里两张可以吃别人的牌，则不能胡全不靠
  60.            {
  61.               istirteen=0;
  62.               break;
  63.             }
  64.         }
  65.       if(istirteen)
  66.       {
  67.        for(i=0;i<nowordpos;i++)
  68.       {
  69.            for(j=i+1;j<=nowordpos;j++)
  70.               if(pai[i]==pai[j] mod 9)
  71.                {
  72.                   istirteen=0;
  73.                   break;
  74.                }
  75.             if(istirteen==0) break;
  76.         }
  77.      }
  78.     }
  79.     }
  80. }

复制代码
yutian

论坛徽章:
0
2楼 [报告]
发表于 2005-09-09 14:01 |只看该作者

麻将游戏开发


  2. /***************************************************************
  3. * 文件名：hu.cpp *
  4. * *
  5. * 功 能：演示一个简洁明了的递归函数——判断[麻将]的和牌。 *
  6. * *
  7. * 说 明：1. 此函数不判断七对和十三幺，读者不难自行判断； *
  8. * 　　　　同时由于麻将的规则各不相同，也请读者自己添加和修改。*
  9. * *
  10. * 　　　　2. 其他与麻将类似的游戏，如[字牌]（又称跑胡子、 *
  11. * 　　　　二七十）等牌类游戏，也可采用类似的判断函数。 *
  12. * *
  13. * 环 境: VC 6.0, 但符合ANSI C标准，随便移植 ^_^ *
  14. * *
  15. * 作 者：shyworm(怕怕虫) *
  16. * E_Mail: shyworm@sina.com *
  17. ***************************************************************/
  18. #include <stdio.h>;

  20. int Hu(int PAI[38]);
  21. int Remain(int PAI[38]);

  23. int main()
  24. {
  25. // 把一副牌放在下面的数组里，可以任意填入数字来测试函数正确与否。
  26. // 为了方便，PAI[0],PAI[10],PAI[20],PAI[30]都弃之不用，并且必须
  27. // 置为0，千万注意！
  28. int PAI[38] = { 0,
  29. 1,1,1,0,1,1,1,0,0, // PAI[ 1- 9] 壹万～玖万的个数
  30. 0,
  31. 0,0,0,0,0,3,0,0,0, // PAI[11-19] 壹铜～玖铜的个数
  32. 0,
  33. 0,0,0,0,0,0,0,0,0, // PAI[21-29] 壹条～玖条的个数
  34. 0,
  35. 0,1,1,1,0,0,0 // PAI[31-37] 东南西北中发白的个数
  36. };

  38. // 请务必先排除“七对” 和“十三幺”，由于简单，所以不提供了
  39. // if( QIDUI(PAI) )...
  40. // if( SHISANYAO(PAI) )...

  42. if( Hu(PAI) )
  43. printf("哈！我和啦！\n");
  44. else
  45. printf("哎，和不成！\n");

  47. return 1;
  48. }

  50. // 判断和牌的递归函数，不考虑“七对” 和“十三幺”。因为如果
  51. // 把“七对” 和“十三幺”的判断放在递归函数里，将得不偿失。
  52. int Hu(int PAI[38])
  53. {
  54. static int JIANG = 0; // 将牌标志，即牌型“三三三三二”中的“二”

  56. if( !Remain(PAI) ) return 1; // 递归退出条件：如果没有剩牌，则和牌返回。

  58. for(int i=1;!PAI[i]&&i<38;i++); // 找到有牌的地方，i就是当前牌, PAI[i]是个数

  60. printf("i = %d\n",i); // 跟踪信息

  62. // 4张组合(杠子)
  63. if ( PAI[i] == 4 ) // 如果当前牌数等于4张
  64. {
  65. PAI[i] = 0; // 除开全部4张牌
  66. if( Hu(PAI) ) return 1; // 如果剩余的牌组合成功，和牌
  67. PAI[i] = 4; // 否则，取消4张组合
  68. }

  70. // 3张组合(大对)
  71. if ( PAI[i] >;= 3 ) // 如果当前牌不少于3张
  72. {
  73. PAI[i] -= 3; // 减去3张牌
  74. if( Hu(PAI) ) return 1; // 如果剩余的牌组合成功，和牌
  75. PAI[i] += 3; // 取消3张组合
  76. }

  78. // 2张组合(将牌)
  79. if ( !JIANG && PAI[i] >;= 2 ) // 如果之前没有将牌，且当前牌不少于2张
  80. {
  81. JIANG = 1; // 设置将牌标志
  82. PAI[i] -= 2; // 减去2张牌
  83. if( Hu(PAI) ) return 1; // 如果剩余的牌组合成功，和牌
  84. PAI[i] += 2; // 取消2张组合
  85. JIANG = 0; // 清除将牌标志
  86. }


  89. if ( i >; 30 ) return 0; // “东南西北中发白”没有顺牌组合，不和

  91. // 顺牌组合，注意是从前往后组合！
  92. if( i%10 != 8 && i%10 != 9 && // 排除数值为8和9的牌
  93. PAI[i+1] && PAI[i+2] ) // 如果后面有连续两张牌
  94. {
  95. PAI[i]--;
  96. PAI[i+1]--;
  97. PAI[i+2]--; // 各牌数减1
  98. if( Hu(PAI) ) return 1; // 如果剩余的牌组合成功，和牌
  99. PAI[i]++;
  100. PAI[i+1]++;
  101. PAI[i+2]++; // 恢复各牌数
  102. }

  104. // 无法全部组合，不和！
  105. return 0;
  106. }

  108. // 检查剩余牌数
  109. int Remain(int PAI[38])
  110. {
  111. int sum = 0;
  112. for(int i=1;i<38;i++)
  113. sum += PAI[i];
  114. return sum;
  115. }
复制代码
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
yutian

论坛徽章:
0
3楼 [报告]
发表于 2005-09-13 13:05 |只看该作者

麻将游戏开发

胡牌判断函数
  1. //----------------unt_mainwin.cpp---------------------------------------------------------

  3. /*-----------------------------------------------------------------------------------------
  4. *该函数判断手牌有没有胡牌，手牌的数量一定为[2，5，8，11，14]
  5. *当手牌数量为14时，判断是否有特殊牌型的胡牌[十三么，七对，全不靠]
  6. *当不存在以上牌型时，用递归算法判断是否存在一般的胡牌牌型
  7. *
  8. *作者：yutian（于恬）
  9. *E_main：yution@126.com
  10. *
  11. *作者声明：本代码为学习时编写的代码，大家可以随意转贴及编译修改
  12. *但不得用于商业用途和赌博，作者保留一切权力
  13. *
  14. *鸣谢：网友  shyworm(怕怕虫) E_mail：shyworm@sina.com
  15. *       CSDN  ChinaUnix
  16. */

  18. //-----------------------------------------------------------------------------------------------
  19. int       TWanJia::IsWin()
  20. {
  21.     int i,dblpos,dblcount;

  23.     if(this->;PaiCount==13) //先处理特殊牌型，七对、十三么及全不靠
  24.     {
  25.        if((this->;PaiInHand[0]==this->;PaiInHand[1])&(this->;PaiInHand[2]==this->;PaiInHand[3])
  26.        &(this->;PaiInHand[4]==this->;PaiInHand[5])&(this->;PaiInHand[6]==this->;PaiInHand[7])
  27.        &(this->;PaiInHand[8]==this->;PaiInHand[9])&(this->;PaiInHand[10]==this->;PaiInHand[11])
  28.        &(this->;PaiInHand[12]==this->;PaiInHand[13]))
  29.          return SevenDbl; //七对胡了   

  31.        dblcount=0;


  34.        for(i=0;i<13;i++)  //以下判断手牌中对子的数量及位置
  35.        {
  36.          if(this->;PaiInHand[i]==this->;PaiInHand[i+1])
  37.          {
  38.             dblcount++;
  39.          }

  41.          if(dblcount>;1) break; //如果手牌中含有两个对子（或一个刻子）以上，只能胡基本牌型
  42.        }



  46.        if(dblcount==1) //有一个对子的十三张手牌，可能为十三么
  47.          {
  48.            /***********************************************
  49.             十三么牌型必须是么九牌和字牌组成的十四张牌，按牌的数值定义
  50.              手牌数组PaiInHand中，只要没有1～7，10～16，19～25这些值，
  51.             则可以断定，该数组为十三么
  52.            */
  53.           int IsThirteen=1;
  54.           for(i=0;i<14;i++)
  55.            {
  56.               if(this->;PaiInHand[i]>;0&&this->;PaiInHand[i]<8)
  57.                 {
  58.                     IsThirteen=0;
  59.                     break;
  60.                 }
  61.               else if(this->;PaiInHand[i]>;9&&this->;PaiInHand[i]<17)
  62.                 {
  63.                     IsThirteen=0;
  64.                     break;
  65.                 }
  66.               else if(this->;PaiInHand[i]>;18&&this->;PaiInHand[i]<26)
  67.                 {
  68.                     IsThirteen=0;
  69.                     break;
  70.                 }
  71.            }
  72.           if(IsThirteen) return ThirteenSmall;
  73.          }   //end of 十三么

  75.        if(dblcount==0)//没有对子，可能是全不靠
  76.          {
  77.          /*-------------------------------------------
  78.          十三不靠牌型为万筒条三个花色的147，258，369加上字牌的七张牌共16张
  79.          的任意十四张组成的胡牌，147，258，369的花色可以为任意花色，但不能有两副
  80.          出现相同的序数，如一万，四万，一条，四条是不能组成胡牌的。

  82.          判定的算法是：
  83.          先确定所以序数牌（不是字牌）的个数；
  84.          如果序数牌个数大于9，则返回错误；
  85.          如果有吃牌的序列（存在两张牌可以吃掉另外一张牌），返回错误；
  86.          对于所有的序数牌，自第一个开始，分别与其后的所有牌值mod9得
  87.          到的值比较，如果存在相等，返回错误。
  88.          如果上面判断都通过，则为十三不靠

  90.          */

  92.          int NoWordPos=14;

  94.          for(i=13;i>;=0;i--)
  95.            {
  96.               if(this->;PaiInHand[i]<=26)
  97.               {
  98.                  NoWordPos=i;
  99.                  break;
  100.               }
  101.            }

  103.          if(NoWordPos<=8)   //如果非字牌有9个以上，肯定不能胡全不靠
  104.            {
  105.               int IsThirteenSingle=1;

  107.               for(i=0;i<NoWordPos;i++)
  108.                 {
  109.                   if((this->;PaiInHand[i+1]<=(this->;PaiInHand[i]+2))&(this->;PaiInHand[i]%9==this->;PaiInHand[i+1]%9))
  110.                     {
  111.                        IsThirteenSingle=0;
  112.                        break;
  113.                     }
  114.                 }

  116.               if(IsThirteenSingle)
  117.                 {
  118.                   for(i=0;i<NoWordPos&IsThirteenSingle;i++)
  119.                     {
  120.                        for(int j=0;j<=NoWordPos;j++)
  121.                          {
  122.                             if(this->;PaiInHand[i]==this->;PaiInHand[j]%9)
  123.                               {
  124.                                 IsThirteenSingle=0;
  125.                                 break;
  126.                               }
  127.                          }
  128.                     }
  129.                 }

  131.                 if(IsThirteenSingle) return   ThirteenSingle;
  132.            }


  135.          } //end of 不靠
  136.     }
  137.    
  138.    
  139.     int TempPai[33];
  140.    
  141.     for(i=0;i<34;i++) TempPai=0;
  142.    
  143.     for(i=0;i<14;i++)
  144.       {
  145.         TempPai[this->;PaiInHand[i]]++;       
  146.       }      
  147.    if(HuPai(TempPai)) return GenaralWin;
  148.     return 0;
  149. }
  150. //-----------------------------------------------------------------------------------------------------------------
  151. int TWanJia::HuPai(int *arr)
  152. {
  153.         /*
  154.         以下代码参考了网友
  155.         shyworm(怕怕虫) E_mail：shyworm@sina.com
  156.         在csdn论坛发表的算法及源码，在此感谢
  157.        
  158.         原来的算法中要对杠牌进行处理，但我设计的数据结构中，不需要对他们进行判断了，
  159.         故略去了一段代码
  160.         */
  161.    static int Jiang=0;  // 将牌标志，即牌型“三三三三二”中的“二”
  162.    
  163.    if(!RemainPai(arr)) return 1;  // 递归退出条件：如果没有剩牌，则和牌返回。
  164.    
  165.    for(int i=1;!arr[i]&i<34;i++);  // 找到有牌的地方，i就是当前牌, arr[i]是个数
  166.   
  167.   // 3张组合(刻子)
  168.    if(arr[i]>;=3)  // 如果当前牌不少于3张
  169.    {
  170.       arr[i]-=3;  // 减去3张牌
  171.       if(HuPai(arr)) return 1;   // 如果剩余的牌组合成功，和牌
  172.       arr[i]+=3;  // 取消3张组合        
  173.    }
  174.    
  175.    // 2张组合(将牌)
  176.    if(!Jiang&arr[i]>;=2)  // 如果之前没有将牌，且当前牌不少于2张
  177.    {
  178.      Jiang=1;  // 设置将牌标志
  179.      arr[i]-=2;  // 减去2张牌
  180.      if(HuPai(arr)) return 1;  // 如果剩余的牌组合成功，和牌
  181.      arr[i]+=2;  // 取消2张组合
  182.      Jiang=0;        // 清除将牌标志
  183.    }
  184.    
  185.    if(i>;26) return 0;  // “东南西北中发白”没有顺牌组合，不和
  186.    
  187.    
  188.    // 顺牌组合，注意是从前往后组合！
  189.    if(i%9!=7&i%9!=8&arr[i+1]&arr[i+2])// 排除数值为8和9的牌且如果后面有连续两张牌  
  190.    {
  191.      arr[i]--;
  192.      arr[i+1]--;
  193.      arr[i+2]--;   // 各牌数减1
  194.      if(HuPai(arr)) return 1;  // 如果剩余的牌组合成功，和牌
  195.      arr[i]++;
  196.      arr[i+1]++;
  197.      arr[i+2]++;  // 恢复各牌数        
  198.    }
  199.    
  200.    
  201.    // 无法全部组合，不和！
  202.    return 0;
  203. }
  204. //----------------------------------------------------------------------------
  205. // 检查剩余牌数
  206. int TWanJia::RemainPai(int *arr)
  207. {
  208.         int sum=0;
  209.        
  210.         for(int i=0;i<34;i++)
  211.           sum+=arr[i];       
  212.          
  213.         return sum;  
  214.        
  215. }
  216. //----------------------------------------------------------------------------

复制代码


头文件



  3. //-------------------玩家类及窗体的头文件（修改中）----------------------------------------

  5. #ifndef unt_mainwinH
  6. #define unt_mainwinH
  7. //---------------------------------------------------------------------------
  8. #include <Classes.hpp>;
  9. #include <Controls.hpp>;
  10. #include <StdCtrls.hpp>;
  11. #include <Forms.hpp>;
  12. #include <Buttons.hpp>;

  14. #define   SevenDbl              7       //七对
  15. #define   ThirteenSmall         13      //十三么
  16. #define   ThirteenSingle        14      //十三不靠
  17. #define   GenaralWin            15      //一般胡牌

  19. //============================================
  20. // 0    1     2   3    4    5    6    7    8
  21. //============================================
  22. //一万 二万 三万 四万 五万 六万 七万 八万 九万
  23. //============================================
  24. // 9    10   11   12   13   14   15   16   17
  25. //============================================
  26. //一条 二条 三条 四条 五条 六条 七条 八条 九条
  27. //============================================
  28. //18    19   20   21   22   23   24   25   26
  29. //============================================
  30. //一筒 二筒 三筒 四筒 五筒 六筒 七筒 八筒 九筒
  31. //============================================
  32. //27    28   29   30   31   32   33   34   35
  33. //============================================
  34. //东风 南风 西风 北风 红中 发财 白板  花1  花2
  35. //============================================









  45. //---------------------------------------------------------------------------
  46. struct SChiPai  //吃牌的结构体，吃的牌为顺子，故记录首尾两张牌
  47. {
  48.   int MinPai;    //麻将牌值，吃牌中最小的牌
  49.   int MaxPai;   //麻将牌值，吃牌中最大的牌
  50. };
  51. //---------------------------------------------------------------------------
  52. struct SGangPai     //杠牌的结构体
  53. {
  54.   int Pai;    //麻将牌值，取值范围为[0..33]
  55.   int MingAn;//数值为0或1，1代表为暗杠，0代表明杠
  56. };
  57. //---------------------------------------------------------------------------
  58. class TWanJia
  59. {
  60. //__published:

  62. private:
  63.       AnsiString PlayerID;
  64.       int        FenShu;                //玩家的分数，要和数据库保持一致

  66.       int        MenFeng;               //玩家的门风

  68.       SGangPai   Gangpai[3];            //玩家手中杠的牌

  70.       SChiPai    ChiPai[3];             //玩家手中吃的牌

  72.       int        PengPai[3];            //玩家手中的碰牌

  74.       int        HuaPai;                //花牌的数量，算番时要用

  76.       int        PaiInHand[13];         //玩家的手牌，除掉吃碰杠牌后手中的牌
  77.                                         //即其他玩家看不到的牌,最多为十四张
  78.                                         //其中，PaiInHand[13]在处理完成后，被赋值为-1

  80.       int        PaiCount;              //手牌的数量，取值为1，4，7，10，13

  82.       int        NewPai;                //新摸到或别人打的牌，在处理完成后，被赋值为-1
  83.                                         //如果NewPai为非负值，则必须处理掉一张牌或胡牌

  85. protected:
  86.         int HuPai(int *arr);
  87.         int RemainPai(int *arr);
  88. public:
  89.                  TWanJia(AnsiString PlayID,int fenzhi);
  90.      int       SetMenFeng(int menfeng);
  91.      int       SetFenShu(int fenshu);
  92.      int       SetGangPai(int pai,int mingan);
  93.      int       SetChiPai(int min,int max);
  94.      int       SetPengPai(int pengpai);
  95.      int       SetPaiInHand(int * paiarr);
  96.      int       SetPaiCount(int count);

  98.      int       GetMenFeng();
  99.      int       GetFenShu();
  100.      SGangPai * GetGangPai();
  101.      int      * GetPengPai();
  102.      SChiPai  * GetChiPai();
  103.      int      * GetPaiInHand();
  104.      int       GetPaiCount();

  106.      int       Buhua();
  107.      int       ChiPaiWithTwoPai(int min,int max);
  108.      int       PengPaiWithOneDbl(int pai);
  109.      int       IsWin();
  110.      int       SendThePaiToServer();
  111.      int       RequireOnePai();
  112. };
  113. //---------------------------------------------------------------------------
  114. class TMJZhuo
  115. {
  116. //__published:

  118. private:
  119.      int QuanFen,Header,Tail;
  120.      int PaiQiang[143];
  121.      TWanJia Players[3];
  122. public:

  124. };

  126. //----------------------------------------------------------------------------
  127. class Tfrm_mainwin : public TForm
  128. {
  129. __published:        // IDE-managed Components
  130.         TEdit *edt_paiInHand1;
  131.         TLabel *Label1;
  132.         TEdit *edt_GangPai1;
  133.         TLabel *Label2;
  134.         TLabel *Label3;
  135.         TLabel *Label4;
  136.         TEdit *edt_ChiPai11;
  137.         TEdit *edt_ChiPai12;
  138.         TEdit *edt_ChiPai21;
  139.         TEdit *edt_ChiPai22;
  140.         TEdit *edt_ChiPai31;
  141.         TEdit *edt_ChiPai32;
  142.         TEdit *edt_ChiPai41;
  143.         TEdit *edt_ChiPai42;
  144.         TEdit *edt_GangPai2;
  145.         TEdit *edt_GangPai3;
  146.         TEdit *edt_GangPai4;
  147.         TEdit *edt_GangPai11;
  148.         TEdit *edt_GangPai22;
  149.         TEdit *edt_GangPai33;
  150.         TEdit *edt_GangPai44;
  151.         TEdit *edt_PengPai1;
  152.         TEdit *edt_PengPai2;
  153.         TEdit *edt_PengPai3;
  154.         TEdit *edt_PengPai4;
  155.         TEdit *edt_paiInHand2;
  156.         TEdit *edt_paiInHand3;
  157.         TEdit *edt_paiInHand4;
  158.         TEdit *edt_paiInHand5;
  159.         TEdit *edt_paiInHand6;
  160.         TEdit *edt_paiInHand7;
  161.         TEdit *edt_paiInHand8;
  162.         TEdit *edt_paiInHand9;
  163.         TEdit *edt_paiInHand10;
  164.         TEdit *edt_paiInHand11;
  165.         TEdit *edt_paiInHand12;
  166.         TEdit *edt_paiInHand13;
  167.         TEdit *edt_paiInHand14;
  168.         TBitBtn *btn_IsWin;
  169.         void __fastcall FormClose(TObject *Sender, TCloseAction &Action);
  170.         void __fastcall btn_IsWinClick(TObject *Sender);
  171.         void __fastcall FormCreate(TObject *Sender);
  172. private:        // User declarations
  173.     TWanJia * Player;

  175. public:                // User declarations
  176.         void SendDataToWanJia();
  177.         void DispWanJiaData();
  178.         __fastcall Tfrm_mainwin(TComponent* Owner);
  179.         
  180. };
  181. //---------------------------------------------------------------------------
  182. extern PACKAGE Tfrm_mainwin *frm_mainwin;
  183. //---------------------------------------------------------------------------
  184. #endif

复制代码


敬请斧正，谢谢
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
yutian

论坛徽章:
0
4楼 [报告]
发表于 2005-09-13 16:30 |只看该作者

麻将游戏开发

  1. /*-----------------------------------------------------------------------------
  2. *该函数为牌墙洗牌
  3. *先分配一个temparr[143]的数组（牌堆），依次赋值为0～35，每个数字的个数为4个；
  4. * 设置剩余牌数为144；
  5. * 当剩余牌数不为0时：
  6. *   产生一个随机数n；
  7. *   将n模去剩余牌数再加一赋值给num；
  8. * 在牌堆里找到第num个牌，存进牌墙中；
  9. *
  10. *
  11. *作者：yutian（于恬）
  12. *E_main：yution@126.com
  13. *
  14. *作者声明：本代码为学习时编写的代码，大家可以随意转贴及编译修改
  15. *但不得用于商业用途和赌博，作者保留一切权力
  16. ******************************************************************************/

  18. #include <math.h>;
  19. #include <time.h>;
  20. #include <stdlib.h>;

  22. int arr[143];

  24. int initpaiqiang()
  25. {
  26.    int temparr[143];
  27.    int i,j,rempai;

  29.    j=0;
  30.    rempai=144;   //设置剩余牌数
  31.    
  32.   for(i=0;i<144;i++)
  33.    {
  34.     temparr[i]=i/4; //将牌堆初始化
  35.    }

  37.   while(rempai)
  38.   {
  39.     srand((unsigned)time(NULL));
  40.     int num=random()%rempai+1;

  42.     for(i=0;i<144;i++)
  43.       {
  44.         if(temparr[i]!=-1) num--;//找到第num张牌
  45.         
  46.         if(!num)
  47.           {
  48.             arr[j]=temparr[i];   //将这张牌放入牌墙
  49.             j++;
  50.             rempai--;
  51.             temparr[i]=-1;
  52.             break;
  53.           }
  54.       }
  55.   }
  56. }
复制代码


洗牌的函数
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
yulc

论坛徽章:
0
5楼 [报告]
发表于 2005-09-15 17:23 |只看该作者

麻将游戏开发

只能说句佩服佩服...

不过我可以提个需求嘛? 北京的玩法是每局有个牌是混,就是可以替代任何字,可不可以把这种牌型也算进去?
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
yutian

论坛徽章:
0
6楼 [报告]
发表于 2005-09-16 09:02 |只看该作者

麻将游戏开发

原帖由 "yulc" 发表：
只能说句佩服佩服...

不过我可以提个需求嘛? 北京的玩法是每局有个牌是混,就是可以替代任何字,可不可以把这种牌型也算进去?


谢谢你的建议

可以是当然可以的，但要实现就可能要更改类的实现，

我是根据麻将的规则写的，至于其他的牌型及规则，兄台可以修改一下代码
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则 发表回复

  

北京盛拓优讯信息技术有限公司. 版权所有 京ICP备16024965号-6 北京市公安局海淀分局网监中心备案编号：11010802020122 niuxiaotong@pcpop.com 17352615567
未成年举报专区
中国互联网协会会员  联系我们：huangweiwei@itpub.net
感谢所有关心和支持过ChinaUnix的朋友们 转载本站内容请注明原作者名及出处

清除 Cookies - ChinaUnix - Archiver - WAP - TOP