亚洲av成人无遮挡网站在线观看,少妇性bbb搡bbb爽爽爽,亚洲av日韩精品久久久久久,兔费看少妇性l交大片免费,无码少妇一区二区三区

  免費注冊 查看新帖 |

Chinaunix

  平臺 論壇 博客 文庫
最近訪問板塊 發(fā)新帖
查看: 7587 | 回復: 5
打印 上一主題 下一主題

麻將游戲開發(fā) [復制鏈接]

論壇徽章:
0
跳轉(zhuǎn)到指定樓層
1樓 [收藏(0)] [報告]
發(fā)表于 2005-09-09 14:00 |只看該作者 |倒序瀏覽
麻將游戲開發(fā)
最近要學習軟件工程，學習之余就去網(wǎng)絡上玩麻將，呵呵～～～

突發(fā)奇想要自己開發(fā)一個，邊練手，邊娛樂，何樂而不為呢

麻將游戲要用到很多模塊，慢慢補來

也望各位大大多留下意見，先謝過


麻將網(wǎng)絡游戲項目

  項目分為服務器端和客戶端兩大模塊
  服務器端功能：提供游戲玩家注冊、登錄、積分、聊天服務
                為游戲提供桌號、洗牌、算番
  客戶端：游戲界面，判斷是否吃、碰、杠、聽牌及胡牌

數(shù)據(jù)結(jié)構(gòu)：麻將的數(shù)字表示
用數(shù)字0～35表示麻將牌，其中0～8代表一萬到九萬，9～17代表一條到九條，18～26代表一筒到九筒，27代表東風，28代表南風，29代表西風，30代表北風，31代表中，32代表發(fā)，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
============================================
東風 南風 西風 北風 紅中 發(fā)財 白板  花1  花2
============================================

每個數(shù)字出現(xiàn)四次，代表四張牌，洗牌時采用隨機算法提供牌墻

牌墻數(shù)據(jù)結(jié)構(gòu)：

  圈風：
     quanfeng：（27，28，29，30）
  數(shù)組paiqiang[0..143],其中
paiqiang[0]~paiqiang[35]為東（莊）家
paiqiang[36]~paiqiang[71]為南家
paiqiang[72]~paiqiang[107]為西家
paiqiang[108]~paiqiang[143]為北家

玩家數(shù)據(jù)結(jié)構(gòu)：
玩家wanjia：{
     門風：
        menfeng：（27，28，29，30）
     杠：
        gangpai{
        pai:0～33
        mingAn:0|1
              }
       gangarr[0..3]:gangpai（最多四個杠，數(shù)字表示杠的牌，結(jié)構(gòu)體第二位的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

}
當要牌置位（非負）時，要對手牌進行胡牌判斷：
由于手牌已經(jīng)除掉了大量的碰杠吃等情況，簡化的胡牌算法：
先對pai數(shù)組加上要牌一起排序；
然后用遞歸算法判斷是否胡牌；
最后判斷是否為7對,十三么，全不靠牌型：（注，這些牌型一般不容易胡，故番數(shù)也不小哦，^_^）

  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;  //記錄數(shù)組中對牌的位置；－1為沒有對牌
  8.   dblnum＝0;//對的個數(shù)（如果超過兩個對（可能是一個刻子）則不能胡十三么，全不靠牌型）
  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. }

復制代碼

論壇徽章:
0
2樓 [報告]
發(fā)表于 2005-09-09 14:01 |只看該作者

麻將游戲開發(fā)


  2. /***************************************************************
  3. * 文件名：hu.cpp *
  4. * *
  5. * 功 能：演示一個簡潔明了的遞歸函數(shù)——判斷[麻將]的和牌。 *
  6. * *
  7. * 說 明：1. 此函數(shù)不判斷七對和十三幺，讀者不難自行判斷； *
  8. * 　　　　同時由于麻將的規(guī)則各不相同，也請讀者自己添加和修改。*
  9. * *
  10. * 　　　　2. 其他與麻將類似的游戲，如[字牌]（又稱跑胡子、 *
  11. * 　　　　二七十）等牌類游戲，也可采用類似的判斷函數(shù)。 *
  12. * *
  13. * 環(huán) 境: 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. // 把一副牌放在下面的數(shù)組里，可以任意填入數(shù)字來測試函數(shù)正確與否。
  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] 壹萬～玖萬的個數(shù)
  30. 0,
  31. 0,0,0,0,0,3,0,0,0, // PAI[11-19] 壹銅～玖銅的個數(shù)
  32. 0,
  33. 0,0,0,0,0,0,0,0,0, // PAI[21-29] 壹條～玖條的個數(shù)
  34. 0,
  35. 0,1,1,1,0,0,0 // PAI[31-37] 東南西北中發(fā)白的個數(shù)
  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. // 判斷和牌的遞歸函數(shù)，不考慮“七對” 和“十三幺”。因為如果
  51. // 把“七對” 和“十三幺”的判斷放在遞歸函數(shù)里，將得不償失。
  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]是個數(shù)

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

  62. // 4張組合(杠子)
  63. if ( PAI[i] == 4 ) // 如果當前牌數(shù)等于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; // “東南西北中發(fā)白”沒有順牌組合，不和

  91. // 順牌組合，注意是從前往后組合！
  92. if( i%10 != 8 && i%10 != 9 && // 排除數(shù)值為8和9的牌
  93. PAI[i+1] && PAI[i+2] ) // 如果后面有連續(xù)兩張牌
  94. {
  95. PAI[i]--;
  96. PAI[i+1]--;
  97. PAI[i+2]--; // 各牌數(shù)減1
  98. if( Hu(PAI) ) return 1; // 如果剩余的牌組合成功，和牌
  99. PAI[i]++;
  100. PAI[i+1]++;
  101. PAI[i+2]++; // 恢復各牌數(shù)
  102. }

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

  108. // 檢查剩余牌數(shù)
  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. }
復制代碼

論壇徽章:
0
3樓 [報告]
發(fā)表于 2005-09-13 13:05 |只看該作者

麻將游戲開發(fā)

胡牌判斷函數(shù)
  1. //----------------unt_mainwin.cpp---------------------------------------------------------

  3. /*-----------------------------------------------------------------------------------------
  4. *該函數(shù)判斷手牌有沒有胡牌，手牌的數(shù)量一定為[2，5，8，11，14]
  5. *當手牌數(shù)量為14時，判斷是否有特殊牌型的胡牌[十三么，七對，全不靠]
  6. *當不存在以上牌型時，用遞歸算法判斷是否存在一般的胡牌牌型
  7. *
  8. *作者：yutian（于恬）
  9. *E_main：yution@126.com
  10. *
  11. *作者聲明：本代碼為學習時編寫的代碼，大家可以隨意轉(zhuǎn)貼及編譯修改
  12. *但不得用于商業(yè)用途和賭博，作者保留一切權力
  13. *
  14. *鳴謝：網(wǎng)友  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++)  //以下判斷手牌中對子的數(shù)量及位置
  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.             十三么牌型必須是么九牌和字牌組成的十四張牌，按牌的數(shù)值定義
  50.              手牌數(shù)組PaiInHand中，只要沒有1～7，10～16，19～25這些值，
  51.             則可以斷定，該數(shù)組為十三么
  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.          出現(xiàn)相同的序數(shù)，如一萬，四萬，一條，四條是不能組成胡牌的。

  82.          判定的算法是：
  83.          先確定所以序數(shù)牌（不是字牌）的個數(shù)；
  84.          如果序數(shù)牌個數(shù)大于9，則返回錯誤；
  85.          如果有吃牌的序列（存在兩張牌可以吃掉另外一張牌），返回錯誤；
  86.          對于所有的序數(shù)牌，自第一個開始，分別與其后的所有牌值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.         以下代碼參考了網(wǎng)友
  155.         shyworm(怕怕蟲) E_mail：shyworm@sina.com
  156.         在csdn論壇發(fā)表的算法及源碼，在此感謝
  157.        
  158.         原來的算法中要對杠牌進行處理，但我設計的數(shù)據(jù)結(jié)構(gòu)中，不需要對他們進行判斷了，
  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]是個數(shù)
  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;  // “東南西北中發(fā)白”沒有順牌組合，不和
  186.    
  187.    
  188.    // 順牌組合，注意是從前往后組合！
  189.    if(i%9!=7&i%9!=8&arr[i+1]&arr[i+2])// 排除數(shù)值為8和9的牌且如果后面有連續(xù)兩張牌  
  190.    {
  191.      arr[i]--;
  192.      arr[i+1]--;
  193.      arr[i+2]--;   // 各牌數(shù)減1
  194.      if(HuPai(arr)) return 1;  // 如果剩余的牌組合成功，和牌
  195.      arr[i]++;
  196.      arr[i+1]++;
  197.      arr[i+2]++;  // 恢復各牌數(shù)        
  198.    }
  199.    
  200.    
  201.    // 無法全部組合，不和！
  202.    return 0;
  203. }
  204. //----------------------------------------------------------------------------
  205. // 檢查剩余牌數(shù)
  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. //東風 南風 西風 北風 紅中 發(fā)財 白板  花1  花2
  35. //============================================









  45. //---------------------------------------------------------------------------
  46. struct SChiPai  //吃牌的結(jié)構(gòu)體，吃的牌為順子，故記錄首尾兩張牌
  47. {
  48.   int MinPai;    //麻將牌值，吃牌中最小的牌
  49.   int MaxPai;   //麻將牌值，吃牌中最大的牌
  50. };
  51. //---------------------------------------------------------------------------
  52. struct SGangPai     //杠牌的結(jié)構(gòu)體
  53. {
  54.   int Pai;    //麻將牌值，取值范圍為[0..33]
  55.   int MingAn;//數(shù)值為0或1，1代表為暗杠，0代表明杠
  56. };
  57. //---------------------------------------------------------------------------
  58. class TWanJia
  59. {
  60. //__published:

  62. private:
  63.       AnsiString PlayerID;
  64.       int        FenShu;                //玩家的分數(shù)，要和數(shù)據(jù)庫保持一致

  66.       int        MenFeng;               //玩家的門風

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

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

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

  74.       int        HuaPai;                //花牌的數(shù)量，算番時要用

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

  80.       int        PaiCount;              //手牌的數(shù)量，取值為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

復制代碼


敬請斧正，謝謝

論壇徽章:
0
4樓 [報告]
發(fā)表于 2005-09-13 16:30 |只看該作者

麻將游戲開發(fā)

  1. /*-----------------------------------------------------------------------------
  2. *該函數(shù)為牌墻洗牌
  3. *先分配一個temparr[143]的數(shù)組（牌堆），依次賦值為0～35，每個數(shù)字的個數(shù)為4個；
  4. * 設置剩余牌數(shù)為144；
  5. * 當剩余牌數(shù)不為0時：
  6. *   產(chǎn)生一個隨機數(shù)n；
  7. *   將n模去剩余牌數(shù)再加一賦值給num；
  8. * 在牌堆里找到第num個牌，存進牌墻中；
  9. *
  10. *
  11. *作者：yutian（于恬）
  12. *E_main：yution@126.com
  13. *
  14. *作者聲明：本代碼為學習時編寫的代碼，大家可以隨意轉(zhuǎn)貼及編譯修改
  15. *但不得用于商業(yè)用途和賭博，作者保留一切權力
  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;   //設置剩余牌數(shù)
  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. }
復制代碼


洗牌的函數(shù)

論壇徽章:
0
5樓 [報告]
發(fā)表于 2005-09-15 17:23 |只看該作者

麻將游戲開發(fā)

只能說句佩服佩服...

不過我可以提個需求嘛? 北京的玩法是每局有個牌是混,就是可以替代任何字,可不可以把這種牌型也算進去?

論壇徽章:
0
6樓 [報告]
發(fā)表于 2005-09-16 09:02 |只看該作者

麻將游戲開發(fā)

原帖由 "yulc" 發(fā)表：
只能說句佩服佩服...

不過我可以提個需求嘛? 北京的玩法是每局有個牌是混,就是可以替代任何字,可不可以把這種牌型也算進去?


謝謝你的建議

可以是當然可以的，但要實現(xiàn)就可能要更改類的實現(xiàn)，

我是根據(jù)麻將的規(guī)則寫的，至于其他的牌型及規(guī)則，兄臺可以修改一下代碼
您需要登錄后才可以回帖 登錄 | 注冊

本版積分規(guī)則 發(fā)表回復

  

北京盛拓優(yōu)訊信息技術有限公司. 版權所有 京ICP備16024965號-6 北京市公安局海淀分局網(wǎng)監(jiān)中心備案編號：11010802020122 niuxiaotong@pcpop.com 17352615567
未成年舉報專區(qū)
中國互聯(lián)網(wǎng)協(xié)會會員  聯(lián)系我們：huangweiwei@itpub.net
感謝所有關心和支持過ChinaUnix的朋友們 轉(zhuǎn)載本站內(nèi)容請注明原作者名及出處

清除 Cookies - ChinaUnix - Archiver - WAP - TOP