C++德州扑克的核心规则算法

自己编写,适用于windows,linux平台。

#include "public.h"

int TexasCombine5(unsigned char* pCard,
         unsigned char* pCardColor, unsigned char** pCardResult, unsigned char** pColorResult)
{
  int count = 0;
  //这里为了速度,没用求组合的公式
  if (pCard[6] == 0)//6张牌
  {
    count = 6;
    *pCardResult = (unsigned char*)MyAlloc(30);
    *pColorResult = (unsigned char*)MyAlloc(30);

    *(*pCardResult + 0) = pCard[0];
    *(*pColorResult + 0) = pCardColor[0];
    *(*pCardResult + 1) = pCard[1];
    *(*pColorResult + 1) = pCardColor[1];
    *(*pCardResult + 2) = pCard[2];
    *(*pColorResult + 2) = pCardColor[2];
    *(*pCardResult + 3) = pCard[3];
    *(*pColorResult + 3) = pCardColor[3];
    *(*pCardResult + 4) = pCard[4];
    *(*pColorResult + 4) = pCardColor[4];

    *(*pCardResult + 5) = pCard[0];
    *(*pColorResult + 5) = pCardColor[0];
    *(*pCardResult + 6) = pCard[1];
    *(*pColorResult + 6) = pCardColor[1];
    *(*pCardResult + 7) = pCard[2];
    *(*pColorResult + 7) = pCardColor[2];
    *(*pCardResult + 8) = pCard[3];
    *(*pColorResult + 8) = pCardColor[3];
    *(*pCardResult + 9) = pCard[5];
    *(*pColorResult + 9) = pCardColor[5];

    *(*pCardResult + 10) = pCard[0];
    *(*pColorResult + 10) = pCardColor[0];
    *(*pCardResult + 11) = pCard[1];
    *(*pColorResult + 11) = pCardColor[1];
    *(*pCardResult + 12) = pCard[2];
    *(*pColorResult + 12) = pCardColor[2];
    *(*pCardResult + 13) = pCard[4];
    *(*pColorResult + 13) = pCardColor[4];
    *(*pCardResult + 14) = pCard[5];
    *(*pColorResult + 14) = pCardColor[5];

    *(*pCardResult + 15) = pCard[0];
    *(*pColorResult + 15) = pCardColor[0];
    *(*pCardResult + 16) = pCard[1];
    *(*pColorResult + 16) = pCardColor[1];
    *(*pCardResult + 17) = pCard[3];
    *(*pColorResult + 17) = pCardColor[3];
    *(*pCardResult + 18) = pCard[4];
    *(*pColorResult + 18) = pCardColor[4];
    *(*pCardResult + 19) = pCard[5];
    *(*pColorResult + 19) = pCardColor[5];

    *(*pCardResult + 20) = pCard[0];
    *(*pColorResult + 20) = pCardColor[0];
    *(*pCardResult + 21) = pCard[2];
    *(*pColorResult + 21) = pCardColor[2];
    *(*pCardResult + 22) = pCard[3];
    *(*pColorResult + 22) = pCardColor[3];
    *(*pCardResult + 23) = pCard[4];
    *(*pColorResult + 23) = pCardColor[4];
    *(*pCardResult + 24) = pCard[5];
    *(*pColorResult + 24) = pCardColor[5];

    *(*pCardResult + 25) = pCard[1];
    *(*pColorResult + 25) = pCardColor[1];
    *(*pCardResult + 26) = pCard[2];
    *(*pColorResult + 26) = pCardColor[2];
    *(*pCardResult + 27) = pCard[3];
    *(*pColorResult + 27) = pCardColor[3];
    *(*pCardResult + 28) = pCard[4];
    *(*pColorResult + 28) = pCardColor[4];
    *(*pCardResult + 29) = pCard[5];
    *(*pColorResult + 29) = pCardColor[5];
  }
  else
  {
    count = 21;
    *pCardResult = (unsigned char*)MyAlloc(105);
    *pColorResult = (unsigned char*)MyAlloc(105);
    //0
    *(*pCardResult + 0) = pCard[0];
    *(*pColorResult + 0) = pCardColor[0];
    *(*pCardResult + 1) = pCard[1];
    *(*pColorResult + 1) = pCardColor[1];
    *(*pCardResult + 2) = pCard[2];
    *(*pColorResult + 2) = pCardColor[2];
    *(*pCardResult + 3) = pCard[3];
    *(*pColorResult + 3) = pCardColor[3];
    *(*pCardResult + 4) = pCard[4];
    *(*pColorResult + 4) = pCardColor[4];
    //1
    *(*pCardResult + 5) = pCard[0];
    *(*pColorResult + 5) = pCardColor[0];
    *(*pCardResult + 6) = pCard[1];
    *(*pColorResult + 6) = pCardColor[1];
    *(*pCardResult + 7) = pCard[2];
    *(*pColorResult + 7) = pCardColor[2];
    *(*pCardResult + 8) = pCard[3];
    *(*pColorResult + 8) = pCardColor[3];
    *(*pCardResult + 9) = pCard[5];
    *(*pColorResult + 9) = pCardColor[5];
    //2
    *(*pCardResult + 10) = pCard[0];
    *(*pColorResult + 10) = pCardColor[0];
    *(*pCardResult + 11) = pCard[1];
    *(*pColorResult + 11) = pCardColor[1];
    *(*pCardResult + 12) = pCard[2];
    *(*pColorResult + 12) = pCardColor[2];
    *(*pCardResult + 13) = pCard[3];
    *(*pColorResult + 13) = pCardColor[3];
    *(*pCardResult + 14) = pCard[6];
    *(*pColorResult + 14) = pCardColor[6];
    //3
    *(*pCardResult + 15) = pCard[0];
    *(*pColorResult + 15) = pCardColor[0];
    *(*pCardResult + 16) = pCard[1];
    *(*pColorResult + 16) = pCardColor[1];
    *(*pCardResult + 17) = pCard[2];
    *(*pColorResult + 17) = pCardColor[2];
    *(*pCardResult + 18) = pCard[4];
    *(*pColorResult + 18) = pCardColor[4];
    *(*pCardResult + 19) = pCard[5];
    *(*pColorResult + 19) = pCardColor[5];
    //4
    *(*pCardResult + 20) = pCard[0];
    *(*pColorResult + 20) = pCardColor[0];
    *(*pCardResult + 21) = pCard[1];
    *(*pColorResult + 21) = pCardColor[1];
    *(*pCardResult + 22) = pCard[2];
    *(*pColorResult + 22) = pCardColor[2];
    *(*pCardResult + 23) = pCard[4];
    *(*pColorResult + 23) = pCardColor[4];
    *(*pCardResult + 24) = pCard[6];
    *(*pColorResult + 24) = pCardColor[6];
    //5
    *(*pCardResult + 25) = pCard[0];
    *(*pColorResult + 25) = pCardColor[0];
    *(*pCardResult + 26) = pCard[1];
    *(*pColorResult + 26) = pCardColor[1];
    *(*pCardResult + 27) = pCard[2];
    *(*pColorResult + 27) = pCardColor[2];
    *(*pCardResult + 28) = pCard[5];
    *(*pColorResult + 28) = pCardColor[5];
    *(*pCardResult + 29) = pCard[6];
    *(*pColorResult + 29) = pCardColor[6];
    //6
    *(*pCardResult + 30) = pCard[0];
    *(*pColorResult + 30) = pCardColor[0];
    *(*pCardResult + 31) = pCard[1];
    *(*pColorResult + 31) = pCardColor[1];
    *(*pCardResult + 32) = pCard[3];
    *(*pColorResult + 32) = pCardColor[3];
    *(*pCardResult + 33) = pCard[4];
    *(*pColorResult + 33) = pCardColor[4];
    *(*pCardResult + 34) = pCard[5];
    *(*pColorResult + 34) = pCardColor[5];
    //7
    *(*pCardResult + 35) = pCard[0];
    *(*pColorResult + 35) = pCardColor[0];
    *(*pCardResult + 36) = pCard[1];
    *(*pColorResult + 36) = pCardColor[1];
    *(*pCardResult + 37) = pCard[3];
    *(*pColorResult + 37) = pCardColor[3];
    *(*pCardResult + 38) = pCard[4];
    *(*pColorResult + 38) = pCardColor[4];
    *(*pCardResult + 39) = pCard[6];
    *(*pColorResult + 39) = pCardColor[6];
    //8
    *(*pCardResult + 40) = pCard[0];
    *(*pColorResult + 40) = pCardColor[0];
    *(*pCardResult + 41) = pCard[1];
    *(*pColorResult + 41) = pCardColor[1];
    *(*pCardResult + 42) = pCard[3];
    *(*pColorResult + 42) = pCardColor[3];
    *(*pCardResult + 43) = pCard[5];
    *(*pColorResult + 43) = pCardColor[5];
    *(*pCardResult + 44) = pCard[6];
    *(*pColorResult + 44) = pCardColor[6];
    //9
    *(*pCardResult + 45) = pCard[0];
    *(*pColorResult + 45) = pCardColor[0];
    *(*pCardResult + 46) = pCard[1];
    *(*pColorResult + 46) = pCardColor[1];
    *(*pCardResult + 47) = pCard[4];
    *(*pColorResult + 47) = pCardColor[4];
    *(*pCardResult + 48) = pCard[5];
    *(*pColorResult + 48) = pCardColor[5];
    *(*pCardResult + 49) = pCard[6];
    *(*pColorResult + 49) = pCardColor[6];
    //10
    *(*pCardResult + 50) = pCard[0];
    *(*pColorResult + 50) = pCardColor[0];
    *(*pCardResult + 51) = pCard[2];
    *(*pColorResult + 51) = pCardColor[2];
    *(*pCardResult + 52) = pCard[3];
    *(*pColorResult + 52) = pCardColor[3];
    *(*pCardResult + 53) = pCard[4];
    *(*pColorResult + 53) = pCardColor[4];
    *(*pCardResult + 54) = pCard[5];
    *(*pColorResult + 54) = pCardColor[5];
    //11
    *(*pCardResult + 55) = pCard[0];
    *(*pColorResult + 55) = pCardColor[0];
    *(*pCardResult + 56) = pCard[2];
    *(*pColorResult + 56) = pCardColor[2];
    *(*pCardResult + 57) = pCard[3];
    *(*pColorResult + 57) = pCardColor[3];
    *(*pCardResult + 58) = pCard[4];
    *(*pColorResult + 58) = pCardColor[4];
    *(*pCardResult + 59) = pCard[6];
    *(*pColorResult + 59) = pCardColor[6];
    //12
    *(*pCardResult + 60) = pCard[0];
    *(*pColorResult + 60) = pCardColor[0];
    *(*pCardResult + 61) = pCard[2];
    *(*pColorResult + 61) = pCardColor[2];
    *(*pCardResult + 62) = pCard[3];
    *(*pColorResult + 62) = pCardColor[3];
    *(*pCardResult + 63) = pCard[5];
    *(*pColorResult + 63) = pCardColor[5];
    *(*pCardResult + 64) = pCard[6];
    *(*pColorResult + 64) = pCardColor[6];
    //13
    *(*pCardResult + 65) = pCard[0];
    *(*pColorResult + 65) = pCardColor[0];
    *(*pCardResult + 66) = pCard[2];
    *(*pColorResult + 66) = pCardColor[2];
    *(*pCardResult + 67) = pCard[4];
    *(*pColorResult + 67) = pCardColor[4];
    *(*pCardResult + 68) = pCard[5];
    *(*pColorResult + 68) = pCardColor[5];
    *(*pCardResult + 69) = pCard[6];
    *(*pColorResult + 69) = pCardColor[6];
    //14
    *(*pCardResult + 70) = pCard[0];
    *(*pColorResult + 70) = pCardColor[0];
    *(*pCardResult + 71) = pCard[3];
    *(*pColorResult + 71) = pCardColor[3];
    *(*pCardResult + 72) = pCard[4];
    *(*pColorResult + 72) = pCardColor[4];
    *(*pCardResult + 73) = pCard[5];
    *(*pColorResult + 73) = pCardColor[5];
    *(*pCardResult + 74) = pCard[6];
    *(*pColorResult + 74) = pCardColor[6];
    //15
    *(*pCardResult + 75) = pCard[1];
    *(*pColorResult + 75) = pCardColor[1];
    *(*pCardResult + 76) = pCard[2];
    *(*pColorResult + 76) = pCardColor[2];
    *(*pCardResult + 77) = pCard[3];
    *(*pColorResult + 77) = pCardColor[3];
    *(*pCardResult + 78) = pCard[4];
    *(*pColorResult + 78) = pCardColor[4];
    *(*pCardResult + 79) = pCard[5];
    *(*pColorResult + 79) = pCardColor[5];
    //16
    *(*pCardResult + 80) = pCard[1];
    *(*pColorResult + 80) = pCardColor[1];
    *(*pCardResult + 81) = pCard[2];
    *(*pColorResult + 81) = pCardColor[2];
    *(*pCardResult + 82) = pCard[3];
    *(*pColorResult + 82) = pCardColor[3];
    *(*pCardResult + 83) = pCard[4];
    *(*pColorResult + 83) = pCardColor[4];
    *(*pCardResult + 84) = pCard[6];
    *(*pColorResult + 84) = pCardColor[6];
    //17
    *(*pCardResult + 85) = pCard[1];
    *(*pColorResult + 85) = pCardColor[1];
    *(*pCardResult + 86) = pCard[2];
    *(*pColorResult + 86) = pCardColor[2];
    *(*pCardResult + 87) = pCard[3];
    *(*pColorResult + 87) = pCardColor[3];
    *(*pCardResult + 88) = pCard[5];
    *(*pColorResult + 88) = pCardColor[5];
    *(*pCardResult + 89) = pCard[6];
    *(*pColorResult + 89) = pCardColor[6];
    //18
    *(*pCardResult + 90) = pCard[1];
    *(*pColorResult + 90) = pCardColor[1];
    *(*pCardResult + 91) = pCard[2];
    *(*pColorResult + 91) = pCardColor[2];
    *(*pCardResult + 92) = pCard[4];
    *(*pColorResult + 92) = pCardColor[4];
    *(*pCardResult + 93) = pCard[5];
    *(*pColorResult + 93) = pCardColor[5];
    *(*pCardResult + 94) = pCard[6];
    *(*pColorResult + 94) = pCardColor[6];
    //19
    *(*pCardResult + 95) = pCard[1];
    *(*pColorResult + 95) = pCardColor[1];
    *(*pCardResult + 96) = pCard[3];
    *(*pColorResult + 96) = pCardColor[3];
    *(*pCardResult + 97) = pCard[4];
    *(*pColorResult + 97) = pCardColor[4];
    *(*pCardResult + 98) = pCard[5];
    *(*pColorResult + 98) = pCardColor[5];
    *(*pCardResult + 99) = pCard[6];
    *(*pColorResult + 99) = pCardColor[6];
    //20
    *(*pCardResult + 100) = pCard[2];
    *(*pColorResult + 100) = pCardColor[2];
    *(*pCardResult + 101) = pCard[3];
    *(*pColorResult + 101) = pCardColor[3];
    *(*pCardResult + 102) = pCard[4];
    *(*pColorResult + 102) = pCardColor[4];
    *(*pCardResult + 103) = pCard[5];
    *(*pColorResult + 103) = pCardColor[5];
    *(*pCardResult + 104) = pCard[6];
    *(*pColorResult + 104) = pCardColor[6];
  }
  return count;
}

void CardSort(unsigned char* p, unsigned char* p2, int pCount)
{
  int i, j;
  unsigned char c;
  for (i = 0; i < pCount - 1; ++i)
  {
    for (j = i + 1; j < pCount; ++j)
    {
      if (p[i] < p[j])
      {
        c = p[i];
        p[i] = p[j];
        p[j] = c;
        c = p2[i];
        p2[i] = p2[j];
        p2[j] = c;
      }
    }
  }
}

//结果值:
//detail:
//对于高牌,从左起第4位,分别返回五张牌从大到小的牌点值,如:0x000DA932表示 A,J,10,4,3
//注:对于牌张不足5张的高牌,从左起第4位,分别返回从大到小的牌点值,无牌的位置填0,如:0x000DA000表示 A,J
//对于1对,在左起第4位返回牌点值,如:0x000D9870.表示A一对, 8, 7, 6
//对于2对,在左起第4,5位返回牌点值,如:0x000D9C00.表示A一对,10一对, Q
//对于3条,在左起第4位返回牌点值,如:0x0002D900,表示三条3,A,10
//对于顺子,在左起第4位返回顺子的最大牌点值,如:0x000C0000,表示K,Q,J,10,9,8
//对于同花,从左起第4位,分别返回五张牌从大到小的牌点值,如:0x000DA932表示 A,J,10,4,3
//对于葫芦,从左起第4,5位返回牌点值,如:0x000DA000表示 A,A,A,J,J
//对于金刚,在左起第4位返回牌点值,如:0x000DA000.表示A金刚,J
//对于同花顺,在左起第4位返回牌点值,如:0x00080000,表示98765的同花顺
void TexasCalcLevel(unsigned char *card, unsigned char *cardColor, LPCARD_LEVEL pResult)
{
  if (card[2] == 0)//两张牌
  {
    if (card[0] == card[1])//一对
    {
      pResult->detail = card[0] << 16;
      pResult->level = TEXAS_CARD_LEVEL_PAIR;
    }
    else//高牌
    {
      pResult->detail = (card[0] << 16) + (card[1] << 12);
      pResult->level = TEXAS_CARD_LEVEL_HIGH;
    }
  }
  else if (card[3] == 0)//三张牌
  {
    //可能是高牌,一对,三条
    if (card[0] == card[1] && card[1] == card[2])//三条
    {
      pResult->detail = card[0] << 16;
      pResult->level = TEXAS_CARD_LEVEL_ARTICLE_3;
    }
    else if (card[0] == card[1] || card[0] == card[2])//一对
    {
      pResult->detail = (card[0] << 16) + (card[2] << 12);
      pResult->level = TEXAS_CARD_LEVEL_PAIR;
    }
    else if (card[1] == card[2])//一对
    {
      pResult->detail = (card[1] << 16) + (card[2] << 12);
      pResult->level = TEXAS_CARD_LEVEL_PAIR;
    }
    else//高牌
    {
      pResult->detail = (card[0] << 16) + (card[1] << 12) + (card[2] << 8);
      pResult->level = TEXAS_CARD_LEVEL_HIGH;
    }
  }
  else if (card[4] == 0)//四张牌
  {
    //可能是金刚,高牌, 一对,两对,三条
    if (card[0] == card[1] && card[1] == card[2] && card[2] == card[3])//金刚
    {
      pResult->detail = card[0] << 16;
      pResult->level = TEXAS_CARD_LEVEL_ARTICLE_4;
    }
    else
    {
      if (card[2] == card[3] && card[1] == card[2])//三条
      {
        pResult->detail = (card[1] << 16) + (card[3] << 12);
        pResult->level = TEXAS_CARD_LEVEL_ARTICLE_3;
      }
      else if (card[0] == card[1] && card[1] == card[2])//三条
      {
        pResult->detail = (card[0] << 16) + (card[3] << 12);
        pResult->level = TEXAS_CARD_LEVEL_ARTICLE_3;
      }
      else if (card[0] == card[1] && card[2] == card[3])//两对
      {
        pResult->detail = (card[0] << 16) + (card[2] << 12);
        pResult->level = TEXAS_CARD_LEVEL_TWO_PAIR;
      }
      else if (card[0] == card[1] || card[1] == card[2])//一对
      {
        pResult->detail = (card[1] << 16) + (card[1] << 12) + (card[3] << 8);
        pResult->level = TEXAS_CARD_LEVEL_PAIR;
      }
      else if (card[2] == card[3])//一对
      {
        pResult->detail = (card[2] << 16) + (card[0] << 12) + (card[3] << 8);
        pResult->level = TEXAS_CARD_LEVEL_PAIR;
      }
      else//高牌
      {
        pResult->detail = (card[0] << 16) + (card[1] << 12) + (card[2] << 8) + (card[3] << 4);
        pResult->level = TEXAS_CARD_LEVEL_HIGH;
      }
    }
  }
  else //五张牌
  {
    if (card[0] == card[1] && card[1] == card[2] && card[2] == card[3])//金刚
    {
      pResult->detail = (card[1] << 16) + (card[4] << 12);
      pResult->level = TEXAS_CARD_LEVEL_ARTICLE_4;
    }
    else if (card[4] == card[1] && card[1] == card[2] && card[2] == card[3])//金刚
    {
      pResult->detail = (card[1] << 16) + (card[0] << 12);
      pResult->level = TEXAS_CARD_LEVEL_ARTICLE_4;
    }
    else if (card[0] == card[1] && card[1] == card[2] && card[3] == card[4])//葫芦
    {
      pResult->detail = (card[0] << 16) + (card[3] << 12);
      pResult->level = TEXAS_CARD_LEVEL_FULL_HOUSE;
    }
    else if (card[0] == card[1] && card[2] == card[3] && card[3] == card[4])//葫芦
    {
      pResult->detail = (card[2] << 16) + (card[0] << 12);
      pResult->level = TEXAS_CARD_LEVEL_FULL_HOUSE;
    }
    else if ((card[0] - card[1] == 1 || card[0] - card[4] == 12)
      && card[1] - card[2] == 1
      && card[2] - card[3] == 1
      && card[3] - card[4] == 1
      )//同花顺或者顺子
    {
      if (cardColor[0] == cardColor[1]
      && cardColor[0] == cardColor[2]
      && cardColor[0] == cardColor[3]
      && cardColor[0] == cardColor[4]
      )//同花顺
      {
        if (card[0] == 0x0D)//12345小于23456,所以12345中最大的是5
        {
          pResult->detail = card[1] << 16;
          pResult->level = TEXAS_CARD_LEVEL_STRAIGHT_FLUSH;
        }
        else
        {
          pResult->detail = card[0] << 16;
          pResult->level = TEXAS_CARD_LEVEL_STRAIGHT_FLUSH;
        }
      }
      else//顺子
      {
        pResult->level = TEXAS_CARD_LEVEL_STRAIGHT;
        if (card[0] == 0x0D)//12345小于23456,所以12345中最大的是5
        {
          pResult->detail = card[1] << 16;
        }
        else
        {
          pResult->detail = card[0] << 16;
        }
      }
    }
    else if (cardColor[0] == cardColor[1]
      && cardColor[0] == cardColor[2]
      && cardColor[0] == cardColor[3]
      && cardColor[0] == cardColor[4]
    )//同花或者同花顺
    {
      pResult->detail = 0;
      if (card[0] - card[1] == 1
        && card[1] - card[2] == 1
        && card[2] - card[3] == 1
        && card[3] - card[4] == 1
        )//同花顺
      {
        if (card[0] == 0x0D)//12345小于23456,所以12345中最大的是5
        {
          pResult->detail = card[1] << 16;
          pResult->level = TEXAS_CARD_LEVEL_STRAIGHT_FLUSH;
        }
        else
        {
          pResult->detail = card[0] << 16;
          pResult->level = TEXAS_CARD_LEVEL_STRAIGHT_FLUSH;
        }
      }
      else//同花
      {
        pResult->detail = ((card[0] << 16) + (card[1] << 12) + (card[2] << 8) + (card[3] << 4) + card[4]);
        pResult->level = TEXAS_CARD_LEVEL_FLUSH;
      }
    }
    else //三条,两队,一对,高牌
    {
      if (card[0] == card[1] && card[1] == card[2])//三条
      {
        pResult->detail = (card[2] << 16) + (card[3] << 12) + (card[4] << 8);
        pResult->level = TEXAS_CARD_LEVEL_ARTICLE_3;
      }
      else if (card[1] == card[2] && card[2] == card[3])//三条
      {
        pResult->detail = (card[2] << 16) + (card[0] << 12) + (card[4] << 8);
        pResult->level = TEXAS_CARD_LEVEL_ARTICLE_3;
      }
      else if (card[2] == card[3] && card[3] == card[4])//三条
      {
        pResult->detail = (card[2] << 16) + (card[0] << 12) + (card[1] << 8);
        pResult->level = TEXAS_CARD_LEVEL_ARTICLE_3;
      }
      else if (card[0] == card[1] && card[2] == card[3])//两对
      {
        pResult->detail = (card[0] << 16) + (card[2] << 12) + (card[4] << 8);
        pResult->level = TEXAS_CARD_LEVEL_TWO_PAIR;
      }
      else if (card[0] == card[1] && card[3] == card[4])//两对
      {
        pResult->detail = (card[0] << 16) + (card[3] << 12) + (card[2] << 8);
        pResult->level = TEXAS_CARD_LEVEL_TWO_PAIR;
      }
      else if (card[1] == card[2] && card[3] == card[4])//两对
      {
        pResult->detail = (card[1] << 16) + (card[3] << 12) + (card[0] << 8);
        pResult->level = TEXAS_CARD_LEVEL_TWO_PAIR;
      }
      else if (card[0] == card[1])//一对
      {
        pResult->detail = (card[0] << 16) + (card[2] << 12) + (card[3] << 8) + (card[4] << 4);
        pResult->level = TEXAS_CARD_LEVEL_PAIR;
      }
      else if (card[1] == card[2])//一对
      {
        pResult->detail = (card[1] << 16) + (card[0] << 12) + (card[3] << 8) + (card[4] << 4);
        pResult->level = TEXAS_CARD_LEVEL_PAIR;
      }
      else if (card[2] == card[3])//一对
      {
        pResult->detail = (card[2] << 16) + (card[0] << 12) + (card[1] << 8) + (card[4] << 4);
        pResult->level = TEXAS_CARD_LEVEL_PAIR;
      }
      else if (card[3] == card[4])//一对
      {
        pResult->detail = (card[3] << 16) + (card[0] << 12) + (card[1] << 8) + (card[2] << 4);
        pResult->level = TEXAS_CARD_LEVEL_PAIR;
      }
      else//高牌
      {
        pResult->detail = (card[0] << 16) + (card[1] << 12) + (card[2] << 8) + (card[3] << 4) + card[4];
        pResult->level = TEXAS_CARD_LEVEL_HIGH;
      }
    }
  }
}

//参数值:0表示为空牌,c1,c2是玩家手上的牌,其它是公共牌,公共牌允许为空牌,但所有空牌必须放在最后
//返回值:如果牌张数小于2,则返回0,否则返回1
int TexasCalcLevelEx(unsigned char c1, unsigned char c2,
          unsigned char c3, unsigned char c4, unsigned char c5, unsigned char c6, unsigned char c7
          , LPCARD_LEVEL pResult)
{
  unsigned char card[7];
  unsigned char cardColor[7];
  if (c1 == 0 || c2 == 0)//c1,c2原则上不能为空牌
  {
    return 0;
  }
  //得到全部的牌点
  card[0] = c1 & 0x0F;
  card[1] = c2 & 0x0F;
  card[2] = c3 & 0x0F;
  card[3] = c4 & 0x0F;
  card[4] = c5 & 0x0F;
  card[5] = c6 & 0x0F;
  card[6] = c7 & 0x0F;
  //得到全部的牌颜色
  cardColor[0] = c1 >> 4;
  cardColor[1] = c2 >> 4;
  cardColor[2] = c3 >> 4;
  cardColor[3] = c4 >> 4;
  cardColor[4] = c5 >> 4;
  cardColor[5] = c6 >> 4;
  cardColor[6] = c7 >> 4;
  CardSort(card, cardColor, 7);
  if (card[5]) //六张牌或者七张牌
  {
    unsigned char *allCardCombResult;
    unsigned char *allCardCombResultColor;
    //先获取全部的5张牌组合
    int cardCombCount = TexasCombine5(card, cardColor, &allCardCombResult, &allCardCombResultColor);
    int i;
    CARD_LEVEL cardLevel;
    pResult->detail = pResult->level = 0;
    //逐个组合计算等级,并取最大值
    for (i = 0; i < cardCombCount; ++i)
    {
      TexasCalcLevel(allCardCombResult + i * 5, allCardCombResultColor + i * 5, &cardLevel);
      ////打印中间结果
      //char buff[32];
      //allCardCombResult[i * 5] += allCardCombResultColor[i * 5] << 4;
      //allCardCombResult[i * 5+1] += allCardCombResultColor[i * 5+1] << 4;
      //allCardCombResult[i * 5+2] += allCardCombResultColor[i * 5+2] << 4;
      //allCardCombResult[i * 5+3] += allCardCombResultColor[i * 5+3] << 4;
      //allCardCombResult[i * 5+4] += allCardCombResultColor[i * 5+4] << 4;
      //GLog("%s %s,%s,%s,%s,%s\r\n", TexasGetCardLevelDesc(&cardLevel, buff)
      // ,CardGetName(allCardCombResult[i * 5])
      // ,CardGetName(allCardCombResult[i * 5+1])
      // ,CardGetName(allCardCombResult[i * 5+2])
      // ,CardGetName(allCardCombResult[i * 5+3])
      // ,CardGetName(allCardCombResult[i * 5+4])
      // );
      if (cardLevel.level > pResult->level || cardLevel.level == pResult->level && cardLevel.detail >= pResult->detail)
      {
        pResult->level = cardLevel.level;
        pResult->detail = cardLevel.detail;
      }
    }
    MyFree(allCardCombResult);
    MyFree(allCardCombResultColor);
  }
  else
  {
    TexasCalcLevel(card, cardColor, pResult);
  }
  return 1;
}

//获取牌级描述,pBuffer必须先分配好足够空间,至少24字节
char* TexasGetCardLevelDesc(LPCARD_LEVEL pCardLevel, char* pBuffer)
{
  switch (pCardLevel->level)
  {
  case TEXAS_CARD_LEVEL_HIGH:
    sprintf(pBuffer, "高牌:%s,%s,%s,%s,%s"
      , CardGetCardPointName((pCardLevel->detail >> 16) & 0xF)
      , CardGetCardPointName((pCardLevel->detail >> 12) & 0xF)
      , CardGetCardPointName((pCardLevel->detail >> 8) & 0xF)
      , CardGetCardPointName((pCardLevel->detail >> 4) & 0xF)
      , CardGetCardPointName((pCardLevel->detail >> 0) & 0xF)
      );
    break;
  case TEXAS_CARD_LEVEL_PAIR:
    sprintf(pBuffer, "一对:%s,(%s,%s,%s)"
      , CardGetCardPointName((pCardLevel->detail >> 16) & 0xF)
      , CardGetCardPointName((pCardLevel->detail >> 12) & 0xF)
      , CardGetCardPointName((pCardLevel->detail >> 8) & 0xF)
      , CardGetCardPointName((pCardLevel->detail >> 4) & 0xF)
      );
    break;
  case TEXAS_CARD_LEVEL_TWO_PAIR:
    sprintf(pBuffer, "两对:%s,%s,(%s)"
      , CardGetCardPointName((pCardLevel->detail >> 16) & 0xF)
      , CardGetCardPointName((pCardLevel->detail >> 12) & 0xF)
      , CardGetCardPointName((pCardLevel->detail >> 8) & 0xF)
      );
    break;
  case TEXAS_CARD_LEVEL_ARTICLE_3:
    sprintf(pBuffer, "三条:%s,(%s,%s)"
      , CardGetCardPointName((pCardLevel->detail >> 16) & 0xF)
      , CardGetCardPointName((pCardLevel->detail >> 12) & 0xF)
      , CardGetCardPointName((pCardLevel->detail >> 8) & 0xF)
      );
    break;
  case TEXAS_CARD_LEVEL_STRAIGHT:
    sprintf(pBuffer, "顺子:%s"
      , CardGetCardPointName((pCardLevel->detail >> 16) & 0xF)
      );
    break;
  case TEXAS_CARD_LEVEL_FLUSH:
    sprintf(pBuffer, "同花:%s,%s,%s,%s,%s"
      , CardGetCardPointName((pCardLevel->detail >> 16) & 0xF)
      , CardGetCardPointName((pCardLevel->detail >> 12) & 0xF)
      , CardGetCardPointName((pCardLevel->detail >> 8) & 0xF)
      , CardGetCardPointName((pCardLevel->detail >> 4) & 0xF)
      , CardGetCardPointName((pCardLevel->detail >> 0) & 0xF)
      );
    break;
  case TEXAS_CARD_LEVEL_FULL_HOUSE:
    sprintf(pBuffer, "葫芦:%s,%s"
      , CardGetCardPointName((pCardLevel->detail >> 16) & 0xF)
      , CardGetCardPointName((pCardLevel->detail >> 12) & 0xF)
      );
    break;
  case TEXAS_CARD_LEVEL_ARTICLE_4:
    sprintf(pBuffer, "金刚:%s,(%s)"
      , CardGetCardPointName((pCardLevel->detail >> 16) & 0xF)
      , CardGetCardPointName((pCardLevel->detail >> 12) & 0xF)
      );
    break;
  case TEXAS_CARD_LEVEL_STRAIGHT_FLUSH:
    sprintf(pBuffer, "同花顺:%s"
      , CardGetCardPointName((pCardLevel->detail >> 16) & 0xF)
      );
    break;
  default:
    strcpy(pBuffer, "未知");
    break;
  }
  GLog("TexasGetCardLevelDesc--%s\r\n", pBuffer);
  return pBuffer;
}
(0)

相关推荐

  • 二分查找算法在C/C++程序中的应用示例

    二分查找算法的思想很简单,<编程珠玑>中的描述: 在一个包含t的数组内,二分查找通过对范围的跟综来解决问题.开始时,范围就是整个数组.通过将范围中间的元素与t比较并丢弃一半范围,范围就被缩小.这个过程一直持续,直到在t被发现,或者那个能够包含t的范围已成为空.         Donald Knuth在他的<Sorting and Searching>一书中指出,尽管第一个二分查找算法早在1946年就被发表,但第一个没有bug的二分查找算法却是在12年后才被发表出来.其中常见的一个

  • C++实现八个常用的排序算法:插入排序、冒泡排序、选择排序、希尔排序等

    本文实现了八个常用的排序算法:插入排序.冒泡排序.选择排序.希尔排序 .快速排序.归并排序.堆排序和LST基数排序 首先是算法实现文件Sort.h,代码如下: /* * 实现了八个常用的排序算法:插入排序.冒泡排序.选择排序.希尔排序 * 以及快速排序.归并排序.堆排序和LST基数排序 * @author gkh178 */ #include <iostream> template<class T> void swap_value(T &a, T &b) { T t

  • C++实现自顶向下的归并排序算法

    本文实例讲述了C++实现自顶向下的归并排序算法.分享给大家供大家参考,具体如下: 一. 算法描述 自顶向下的归并排序:采用分治法进行自顶向下的程序设计方式,分治法的核心思想就是分解.求解.合并. 1. 先将长度为N的无序序列分割平均分割为两段 2. 然后分别对前半段进行归并排序.后半段进行归并排序 3. 最后再将排序好的前半段和后半段归并 过程(2)中进行递归求解,最终下图详细的分解了自顶向下的合并算法的实现过程: 二. 算法实现 /*==============================

  • 通过“回文字算法”复习C++语言

     一.什么是回文字 给定一个字符串,从前往后读和从后往前读,字符串序列不变.例如,河北省农村信用社的客服电话是"96369",无论从后往前读,还是从前后往后读,各个字符出现的位置不变. 二.功能实现 (一).给定一个字符串,判断该字符串是否是回文字. (二).给定一个任意字符串,判断是否可以转换为回文字,如果可以转换为回文字,给出具体的算法. 三.C++语言实现版本(JAVA语言版本后续实现) (一)头文件 (BackText.h) /* * BackText.h * * Create

  • C++实现自底向上的归并排序算法

    本文实例讲述了C++实现自底向上的归并排序算法.分享给大家供大家参考,具体如下: 一. 算法描述 自底向上的归并排序:归并排序主要是完成将若干个有序子序列合并成一个完整的有序子序列:自底向上的排序是归并排序的一种实现方式,将一个无序的N长数组切个成N个有序子序列,然后再两两合并,然后再将合并后的N/2(或者N/2 + 1)个子序列继续进行两两合并,以此类推得到一个完整的有序数组.下图详细的分解了自底向上的合并算法的实现过程: 二. 算法实现 /*=========================

  • C++德州扑克的核心规则算法

    自己编写,适用于windows,linux平台. #include "public.h" int TexasCombine5(unsigned char* pCard, unsigned char* pCardColor, unsigned char** pCardResult, unsigned char** pColorResult) { int count = 0; //这里为了速度,没用求组合的公式 if (pCard[6] == 0)//6张牌 { count = 6; *p

  • python实战之德州扑克第三步-比较大小

    一.前言 经过前面的两篇文章,整体工作已经完成了2/3了,剩下的1/3,将会在本片文章提及 前面两步文章链接 python实战之德州扑克第一步-发牌 python实战之德州扑克第二步-判断牌型 整体流程: 比较之前须得获取,牌型,牌值,这两部分在上一篇文章已经讲解了,不懂得小伙伴可私信我,乐意解答! 之后就是简单的遍历,通过两两比较,并排好序,就得到含有玩家按顺序从大到小拍好的数组,类似于[0,3,1,2] 然后就是翻译:玩家0>玩家3>玩家1>玩家2 说明:比较大小并排序有许多算法,小

  • 利用Python编写简易版德州扑克小游戏

    目录 德州扑克简要介绍 什么是德州扑克 游戏规则简要介绍 德州扑克游戏的python实现过程 游戏初始化 评选赢家 游戏主题函数 游戏体验与展示 模块不足与后续改进 德州扑克简要介绍 什么是德州扑克 德州扑克不知道大家是否玩过,它是起源于美国的得克萨斯州的一种博弈类卡牌游戏,英文名叫做Texas Hold’em Poker.玩法上又分为常规桌(Cash, 现金局),单桌赛(SNG)和多桌锦标赛(MTT).虽然扑克种类繁多,但基本的扑克规则通常保持一致.它是一种考验心态与谋略的游戏. 游戏规则简要

  • python实战之德州扑克第二步-判断牌型

    一.前言 现在到了,第二步,上一步我们已经做好了发牌模块,有了手牌,就需要判断牌型了,平时打扑克时,我们需要使用大脑进行判断自己手里的牌属于那种类型的,现在我们需要通过程序来进行判断! 在以下操作中,需要玩家手里的牌为五张,不然无法判断! 先给出发牌的一个效果图: 给2人发五张牌: 二.分析 通过观察可以看出每名玩家的牌是以字符串的形式存储的,每张牌的字符串长度时3(!!!) 判断牌型就需要熟悉牌型的组成了 皇家同花顺:同一花色最大的顺子 同花顺:同一花色的顺子 四条:四张相同+1个单张 葫芦:

  • python实战之德州扑克第一步-发牌

    一.前言 最近小编在做一个关于德州扑克的小游戏,当然已经做完了,才写的一系列文章来记录一下自己的开发经历 点击链接查看其他文章 python实战之德州扑克第二步-判断牌型 python实战之德州扑克第三步-比较大小 一系列文章主要包括: 1.发牌 2.判断牌型 3.比较牌的大小 4.开始游戏 5.总结 二.说明 制作的德州扑克仅供参考,提供源码,源码可运行 可满足基本操作,另外还有一些小功能,可先自行研究 和真正的德州扑克游戏相比,九牛一毛,可用来练练手 附:本源码可优化,如果有实力,有时间,可

  • React实现核心Diff算法的示例代码

    目录 Diff算法的设计思路 Demo介绍 Diff算法实现 遍历前的准备工作 遍历after 遍历后的收尾工作 总结 Diff算法的设计思路 试想,Diff算法需要考虑多少种情况呢?大体分三种,分别是: 节点属性变化,比如: // 更新前 <ul> <li key="0" className="before">0</li> <li key="1">1</li> </ul>

  • PHP实现常用排序算法的方法

    本文主要介绍了一些常用的排序算法,以及PHP的代码实现等,希望对您能有所帮助. 本文来自于awaimai.com,由火龙果软件Luca编辑推荐. 作为phper,一般接触算法的编程不多. 但基本的排序算法还是应该掌握. 毕竟算法作为程序的核心,算法的好坏决定了程序的质量. 本文将依次介绍一些常用的排序算法,以及PHP实现. 1 快速排序 快速排序是由东尼·霍尔发展的一种排序算法. 在平均状况下,排序 n 个项目要Ο(n log n)次比较. 在最坏状况下则需要Ο(n2)次比较,但这种状况并不常见

  • 详解Java实现拓扑排序算法

    目录 一.介绍 二.拓扑排序算法分析 三.拓扑排序代码实现 一.介绍 百科上这么定义的: 对一个有向无环图(Directed Acyclic Graph简称DAG)G进行拓扑排序,是将G中所有顶点排成一个线性序列,使得图中任意一对顶点u和v,若边<u,v>∈E(G),则u在线性序列中出现在v之前.通常,这样的线性序列称为满足拓扑次序(Topological Order)的序列,简称拓扑序列.简单的说,由某个集合上的一个偏序得到该集合上的一个全序,这个操作称之为拓扑排序. 为什么会有拓扑排序?拓

  • PHP四种基本排序算法示例

    许多人都说算法是程序的核心,算法的好坏决定了程序的质量.作为一个初级phper,虽然很少接触到算法方面的东西.但是对于基本的排序算法还是应该掌握的,它是程序开发的必备工具.这里介绍冒泡排序,插入排序,选择排序,快速排序四种基本算法,分析一下算法的思路. 前提:分别用冒泡排序法,快速排序法,选择排序法,插入排序法将下面数组中的值按照从小到大的顺序进行排序. $arr(1,43,54,62,21,66,32,78,36,76,39); 1. 冒泡排序 思路分析:在要排序的一组数中,对当前还未排好的序

  • PHP实现四种基础排序算法的运行时间比较(推荐)

    许多人都说算法是程序的核心,算法的好坏决定了程序的质量.作为一个初级phper,虽然很少接触到算法方面的东西.但是对于基本的排序算法还是应该掌握的,它是程序开发的必备工具.下面通过本文给大家介绍PHP实现四种基础排序算法的运行时间比较,一起看下吧. 废话不多说了,直接给大家贴代码了. 具体代码如下所示: /** * php四种基础排序算法的运行时间比较 * @authors Jesse (jesse152@163.com) * @date 2016-08-11 07:12:14 */ //冒泡排

随机推荐