suoha_algri.c

是一个手机功能的模拟程序

         {
            actionnum = Produce3Poss(Poss32[2][0],Poss32[2][1],Poss32[2][2]);
            if (c_M>(pMoney*(actionnum+1)))
               return pMoney*(actionnum+1); //return more stake!
            else
               return THREECARDSFOLL;
         }
         break;
      }
      break;
   case THREE_DUIZI:
      switch (p_CT.cardType)
      {
      case TWO_DUIZI:
         bigger = CompareTwo(c_CT.bigcard, p_CT.bigcard);
         if (c_CT.bigcard==bigger)
         {//corresponds to a composite of both card types
            if (turnwho==COMPUTER)
            {
               actionnum = Produce3Poss(Poss32[3][0],Poss32[3][1],Poss32[3][2]);
               return ClassifyStake(3,actionnum);
            } else
            {
               actionnum = Produce3Poss(Poss32[3][0],Poss32[3][1],Poss32[3][2]);
               if (c_M>(pMoney*(actionnum+1)))
                  return pMoney*(actionnum+1); //return more stake!
               else
                  return THREECARDSFOLL;               
            }
         } else
         {//corresponds to a composite of both card types
            if (turnwho==COMPUTER)
            {
               actionnum = Produce3Poss(Poss32[4][0],Poss32[4][1],Poss32[4][2]);
               return ClassifyStake(3,actionnum);
            } else
            {
               actionnum = Produce2Poss(Poss32[4][3],Poss32[4][4]);
               return ClassifyFollorQuit(3,actionnum);
            }
         }
         break;
      case TWO_SHANPAI:
         bigger = CompareTwo(c_CT.bigcard, p_CT.bigcard);
         if (c_CT.bigcard==bigger)
         {//corresponds to a composite of both card types
            if (turnwho==COMPUTER)
            {
               actionnum = Produce3Poss(Poss32[5][0],Poss32[5][1],Poss32[5][2]);
               return ClassifyStake(3,actionnum);
            } else
            {
               actionnum = Produce3Poss(Poss32[5][0],Poss32[5][1],Poss32[5][2]);
               if (c_M>(pMoney*(actionnum+1)))
                  return pMoney*(actionnum+1); //return more stake!
               else
                  return THREECARDSFOLL;               
            }
         } else
         {//corresponds to a composite of both card types
            if (turnwho==COMPUTER)
            {
               actionnum = Produce3Poss(Poss32[6][0],Poss32[6][1],Poss32[6][2]);
               return ClassifyStake(3,actionnum);
            } else
            {
               return THREECARDSFOLL; //zhangzg 08/22/2002
//					actionnum = Produce2Poss(Poss32[6][3],Poss32[6][4]);
//					return ClassifyFollorQuit(3,actionnum);
            }
         }
         break;
      }
      break;
   case THREE_SHANPAI:
      switch (p_CT.cardType)
      {
      case TWO_DUIZI:
         bigger = CompareTwo(c_CT.bigcard, p_CT.bigcard);
         if (c_CT.bigcard==bigger)
         {//corresponds to a composite of both card types
            if (turnwho==COMPUTER)
            {
               actionnum = Produce3Poss(Poss32[7][0],Poss32[7][1],Poss32[7][2]);
               return ClassifyStake(3,actionnum);
            } else
            {
               actionnum = Produce2Poss(Poss32[7][3],Poss32[7][4]);
               return ClassifyFollorQuit(3,actionnum);
            }
         } else
         {//corresponds to a composite of both card types
            if (turnwho==COMPUTER)
            {
               actionnum = Produce3Poss(Poss32[8][0],Poss32[8][1],Poss32[8][2]);
               return ClassifyStake(3,actionnum);
            } else
            {
               actionnum = Produce2Poss(Poss32[8][3],Poss32[8][4]);
               return ClassifyFollorQuit(3,actionnum);
            }
         }
         break;
      case TWO_SHANPAI:
         bigger = CompareTwo(c_CT.bigcard, p_CT.bigcard);
         if (c_CT.bigcard==bigger)
         {//corresponds to a composite of both card types
            if (turnwho==COMPUTER)
            {
               actionnum = Produce3Poss(Poss32[9][0],Poss32[9][1],Poss32[9][2]);
               return ClassifyStake(3,actionnum);
            } else
            {
               return THREECARDSFOLL;
            }
         } else
         {//corresponds to a composite of both card types
            if (turnwho==COMPUTER)
            {
               actionnum = Produce3Poss(Poss32[10][0],Poss32[10][1],Poss32[10][2]);
               return ClassifyStake(3,actionnum);
            } else
            {
               return THREECARDSFOLL;
            }
         }
         break;
      }
      break;
   }
   return 0;
}
unsigned long Four_Greater(CardType c_CT, CardType p_CT, unsigned short turnwho)
{
   int bigger=0, actionnum;
   unsigned char Poss43[25][5];
   if (focus_opp==1)
      strcpy((char *)& Poss43, (char *)& Poss43_opp1);
   else if (focus_opp==2)
      strcpy((char *)& Poss43, (char *)& Poss43_opp2);
   else
      strcpy((char *)& Poss43, (char *)& Poss43_opp3);

   switch (c_CT.cardType)
   {
   case FOUR_TIEZI:
      switch (p_CT.cardType)
      {
      case THREE_SHANTIAO:
         bigger = CompareTwo(c_CT.bigcard, p_CT.bigcard);
         if (c_CT.bigcard==bigger)
         {//corresponds to a composite of both card types
            if (turnwho==COMPUTER)
            {
               actionnum = Produce3Poss(Poss43[0][0],Poss43[0][1],Poss43[0][2]);
               return ClassifyStake(4,actionnum);
            } else
            {
               return FOURCARDSFOLL;
            }
         } else
         {//corresponds to a composite of both card types
            if (turnwho==COMPUTER)
            {
               actionnum = Produce3Poss(Poss43[1][0],Poss43[1][1],Poss43[1][2]);
               return ClassifyStake(4,actionnum);
            } else
            {
               return FOURCARDSFOLL;
            }
         }
         break;
      case THREE_DUIZI:
         if (turnwho==COMPUTER)
         {
            actionnum = Produce3Poss(Poss43[2][0],Poss43[2][1],Poss43[2][2]);
            return ClassifyStake(4, actionnum);
         } else
         {
            return FOURCARDSFOLL;
         }
         break;
      case THREE_SHANPAI:
         if (turnwho==COMPUTER)
         {
            actionnum = Produce3Poss(Poss43[3][0],Poss43[3][1],Poss43[3][2]);
            return ClassifyStake(4, actionnum);
         } else
         {
            return FOURCARDSFOLL;
         }
         break;
      }
      break;
   case FOUR_SHANTIAO:
      switch (p_CT.cardType)
      {
      case THREE_SHANTIAO:
         bigger = CompareTwo(c_CT.bigcard, p_CT.bigcard);
         if (c_CT.bigcard==bigger)
         {//corresponds to a composite of both card types
            if (turnwho==COMPUTER)
            {
               actionnum = Produce3Poss(Poss43[4][0],Poss43[4][1],Poss43[4][2]);
               return ClassifyStake(4,actionnum);
            } else
            {
               return FOURCARDSFOLL;
            }
         } else
         {//corresponds to a composite of both card types
            if (turnwho==COMPUTER)
            {
               actionnum = Produce3Poss(Poss43[5][0],Poss43[5][1],Poss43[5][2]);
               return ClassifyStake(4,actionnum);
            } else
            {
               actionnum = Produce2Poss(Poss43[5][3],Poss43[5][4]);
               return ClassifyFollorQuit(4,actionnum);
            }
         }
         break;
      case THREE_DUIZI:
         bigger = CompareTwo(c_CT.bigcard, p_CT.bigcard);
         if (c_CT.bigcard==bigger)
         {//corresponds to a composite of both card types
            if (turnwho==COMPUTER)
            {
               actionnum = Produce3Poss(Poss43[6][0],Poss43[6][1],Poss43[6][2]);
               return ClassifyStake(4,actionnum);
            } else
            {
               return FOURCARDSFOLL;
            }
         } else
         {//corresponds to a composite of both card types
            if (turnwho==COMPUTER)
            {
               actionnum = Produce3Poss(Poss43[7][0],Poss43[7][1],Poss43[7][2]);
               return ClassifyStake(4,actionnum);
            } else
            {
               return FOURCARDSFOLL;
            }
         }
         break;
      case THREE_SHANPAI:
         if (turnwho==COMPUTER)
         {
            actionnum = Produce3Poss(Poss43[8][0],Poss43[8][1],Poss43[8][2]);
            return ClassifyStake(4, actionnum);
         } else
         {
            return FOURCARDSFOLL;
         }
         break;
      }
      break;
   case FOUR_LIANGDUI:
      switch (p_CT.cardType)
      {
      case THREE_SHANTIAO:
         bigger = CompareTwo(c_CT.bigcard, p_CT.bigcard);
         if (c_CT.bigcard==bigger)
         {//corresponds to a composite of both card types
            if (turnwho==COMPUTER)
            {
               actionnum = Produce3Poss(Poss43[9][0],Poss43[9][1],Poss43[9][2]);
               return ClassifyStake(4,actionnum);
            } else
            {
               actionnum = Produce2Poss(Poss43[9][3],Poss43[9][4]);
               return ClassifyFollorQuit(4,actionnum);
            }
         } else
         {//corresponds to a composite of both card types
            if (turnwho==COMPUTER)
            {
               actionnum = Produce3Poss(Poss43[10][0],Poss43[10][1],Poss43[10][2]);
               return ClassifyStake(4,actionnum);
            } else
            {
               actionnum = Produce2Poss(Poss43[10][3],Poss43[10][4]);
               return ClassifyFollorQuit(4,actionnum);
            }
         }
         break;
      case THREE_DUIZI:
         bigger = CompareTwo(c_CT.bigcard, p_CT.bigcard);
         if (c_CT.bigcard==bigger)
         {//corresponds to a composite of both card types
            if (turnwho==COMPUTER)
            {
               actionnum = Produce3Poss(Poss43[11][0],Poss43[11][1],Poss43[11][2]);
               return ClassifyStake(4,actionnum);
            } else
            {
               return FOURCARDSFOLL;
            }
         } else
         {//corresponds to a composite of both card types
            if (turnwho==COMPUTER)
            {
               actionnum = Produce3Poss(Poss43[12][0],Poss43[12][1],Poss43[12][2]);
               return ClassifyStake(4,actionnum);
            } else
            {
               return FOURCARDSFOLL;
            }
         }
         break;
      case THREE_SHANPAI:
         if (turnwho==COMPUTER)
         {
            actionnum = Produce3Poss(Poss43[13][0],Poss43[13][1],Poss43[13][2]);
            return ClassifyStake(4, actionnum);
         } else
         {
            return FOURCARDSFOLL;
         }
         break;
      }
      break;
   case FOUR_DUIZI:
      switch (p_CT.cardType)
      {
      case THREE_SHANTIAO:
         bigger = CompareTwo(c_CT.bigcard, p_CT.bigcard);
         if (c_CT.bigcard==bigger)
         {//corresponds to a composite of both card types
            if (turnwho==COMPUTER)
            {
               actionnum = Produce3Poss(Poss43[14][0],Poss43[14][1],Poss43[14][2]);
               return ClassifyStake(4,actionnum);
            } else
            {
               actionnum = Produce2Poss(Poss43[14][3],Poss43[14][4]);
               return ClassifyFollorQuit(4,actionnum);
            }
         } else
         {//corresponds to a composite of both card types
            if (turnwho==COMPUTER)
            {
               actionnum = Produce3Poss(Poss43[15][0],Poss43[15][1],Poss43[15][2]);
               return ClassifyStake(4,actionnum);
            } else
            {
               return FOURCARDSQUIT;
            }
         }
         break;
      case THREE_DUIZI:
         bigger = CompareTwo(c_CT.bigcard, p_CT.bigcard);
         if (c_CT.bigcard==bigger)
         {//corresponds to a composite of both card types
            if (turnwho==COMPUTER)
            {
               actionnum = Produce3Poss(Poss43[16][0],Poss43[16][1],Poss43[16][2]);
               return ClassifyStake(4,actionnum);
            } else
            {
               return FOURCARDSFOLL;
            }
         } else
         {//corresponds to a composite of both card types
            if (turnwho==COMPUTER)
            {
               actionnum = Produce3Poss(Poss43[17][0],Poss43[17][1],Poss43[17][2]);
               return ClassifyStake(4,actionnum);
            } else
            {
               actionnum = Produce2Poss(Poss43[17][3],Poss43[17][4]);
               return ClassifyFollorQuit(4,actionnum);
            }
         }
         break;
      case THREE_SHANPAI:
         bigger = CompareTwo(c_CT.bigcard, p_CT.bigcard);
         if (c_CT.bigcard==bigger)
         {//corresponds to a composite of both card types
            if (turnwho==COMPUTER)
            {
               actionnum = Produce3Poss(Poss43[18][0],Poss43[18][1],Poss43[18][2]);
               return ClassifyStake(4,actionnum);
            } else
            {
               return FOURCARDSFOLL;
            }
         } else
         {//corresponds to a composite of both card types
            if (turnwho==COMPUTER)
            {
               actionnum = Produce3Poss(Poss43[19][0],Poss43[19][1],Poss43[19][2]);
               return ClassifyStake(4,actionnum);
            } else
            {
               return FOURCARDSFOLL;
            }
         }
         break;
      }
      break;
   case FOUR_SHANPAI:
      switch (p_CT.cardType)
      {
      case THREE_SHANTIAO:
         if (turnwho==COMPUTER)
         {
            actionnum = Produce3Poss(Poss43[20][0],Poss43[20][1],Poss43[20][2]);
            return ClassifyStake(4, actionnum);