home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / top2src.zip / GAMES.ZIP / POKERSCO.C < prev    next >
C/C++ Source or Header  |  1995-05-05  |  5KB  |  198 lines
  1. #include "top.h"
  2.  
  3. XINT poker_findwinners(XINT fwnode, unsigned XINT *fwwin,
  4.                        poker_game_typ *fwgame)
  5.     {
  6.     XINT fwd;
  7.     unsigned long handscores[POKERMAXPLAYERS], maxscore = 0;
  8.     unsigned long handrawscores[POKERMAXPLAYERS], maxrawscore = 0;
  9.     unsigned long winchk = 0;
  10.     XINT fwpl = -1;
  11.  
  12.     // Need checksum mods...
  13.  
  14.     fwpl = poker_getplayernum(POKPL_PLAYING, fwnode, fwgame);
  15.     if (fwpl == -1)
  16.         {
  17.         top_output(OUT_SCREEN, getlang("PokerCantFindPlyr"));
  18.         return 0;
  19.         }
  20.  
  21.     memset(fwgame->winners, 0, fwgame->maxpl);
  22.     *fwwin = 0;
  23.  
  24.     for (fwd = 0; fwd < fwgame->maxpl; fwd++)
  25.         {
  26.         handscores[fwd] = 0;
  27.         handrawscores[fwd] = 0;
  28.         if (fwgame->player[fwd].node > -1)
  29.             {
  30.             handscores[fwd] = poker_scorehand(fwgame,
  31.                                   fwgame->player[fwd].cards);
  32.             handrawscores[fwd] = poker_rawscorehand(fwgame,
  33.                                      fwgame->player[fwd].cards);
  34.             if (handscores[fwd] > maxscore)
  35.                 {
  36.                 maxscore = handscores[fwd];
  37.                 maxrawscore = handrawscores[fwd];
  38.                 }
  39.             if (handscores[fwd] == maxscore &&
  40.                 handrawscores[fwd] > maxrawscore)
  41.                 {
  42.                 maxrawscore = handrawscores[fwd];
  43.                 }
  44.             }
  45.         }
  46.  
  47.     for (fwd = 0; fwd < fwgame->maxpl; fwd++)
  48.         {
  49.         if (fwgame->player[fwd].node > -1)
  50.             {
  51.             if (handscores[fwd] == maxscore &&
  52.                 handrawscores[fwd] == maxrawscore)
  53.                 {
  54.                 fwgame->winners[fwd] = 1;
  55.                 (*fwwin)++;
  56.                 }
  57.             }
  58.         }
  59.  
  60.     if (fwgame->winners[fwpl])
  61.         {
  62.         *fwwin += 0x0100;
  63.         }
  64.  
  65.     return winchk;
  66.     }
  67.  
  68. #define ssuit(xss)  pokerdefcardsuits[shand[xss]]
  69. #define sval(xsv)   pokerdefcardvals[shand[xsv]]
  70.  
  71. // Delete this when 6-7 card mods are made.
  72. #pragma argsused
  73. unsigned XINT poker_scorehand(poker_game_typ *sgame, char *shand)
  74. {
  75. unsigned XINT scoreret, sd, se;
  76. char basehand[3] = { 0,0,0 }, pairvals[10], pnum;
  77.  
  78. poker_sorthand(sgame, shand);
  79.  
  80. // Major mods for 7Stud, naturally.
  81. // I'm leaving this hardcoded at 5 'til I get a plan for working with more.
  82.  
  83. // Mods for Jokers/wilds, though they will be easy.
  84.  
  85. for (sd = 0, pnum = 0; sd < 5; sd++)
  86.     {
  87.     for (se = sd + 1; se < 5; se++)
  88.         {
  89.         if (sval(sd) == sval(se))
  90.             {
  91.             basehand[0]++;
  92.             pairvals[pnum++] = sval(se);
  93.             }
  94.         }
  95.     }
  96.  
  97. scoreret = POKHAND_HIGHCARD + sval(4);
  98. if (basehand[0] == 1)
  99.     {
  100.     scoreret = POKHAND_ONEPAIR + pairvals[0];
  101.     }
  102. if (basehand[0] == 2)
  103.     {
  104.     scoreret = POKHAND_TWOPAIR + (pairvals[1] * 0x10) + pairvals[0];
  105.     }
  106. if (basehand[0] == 3)
  107.     {
  108.     scoreret = POKHAND_THREEKIND + pairvals[2];
  109.     }
  110. if ((sval(1) == sval(0) + 1) && (sval(2) == sval(0) + 2) &&
  111.     (sval(3) == sval(0) + 3) && (sval(4) == sval(0) + 4))
  112.     {
  113.     basehand[1]++;
  114.     scoreret = POKHAND_STRAIGHT + sval(4);
  115.     }
  116. if ((ssuit(0) == ssuit(1)) && (ssuit(1) == ssuit(2)) &&
  117.     (ssuit(2) == ssuit(3)) && (ssuit(3) == ssuit(4)))
  118.     {
  119.     basehand[2]++;
  120.     scoreret = POKHAND_FLUSH + sval(4);
  121.     }
  122. if (basehand[0] == 4)
  123.     {
  124.     if (sval(1) == sval(2))
  125.         {
  126.         scoreret = POKHAND_FULLHOUSE + (sval(2) * 0x10) + sval(3);
  127.         }
  128.     else
  129.         {
  130.         scoreret = POKHAND_FULLHOUSE + (sval(2) * 0x10) + sval(1);
  131.         }
  132.     }
  133. if (basehand[0] == 6)
  134.     {
  135.     scoreret = POKHAND_FOURKIND + pairvals[5];
  136.     }
  137. if (basehand[1] == 1 && basehand[2] == 1)
  138.     {
  139.     scoreret = POKHAND_STRAIGHTFLUSH + sval(4);
  140.     }
  141.  
  142. return scoreret;
  143. }
  144.  
  145. unsigned long poker_rawscorehand(poker_game_typ *sgame, char *shand)
  146. {
  147. XINT prshd;
  148. unsigned long scoreret = 0;
  149.  
  150. poker_sorthand(sgame, shand);
  151.  
  152. for (prshd = 0; prshd < sgame->numcards; prshd++)
  153.     {
  154.     scoreret += ((unsigned long) sval(prshd) <<
  155.                  ((unsigned long) prshd * 4L));
  156.     }
  157.  
  158. return scoreret;
  159. }
  160.  
  161. void poker_sorthand(poker_game_typ *sgame, char *shand)
  162. {
  163. char tmpsort[POKERMAXCARDS];
  164. char sortused[POKERMAXCARDS];
  165. unsigned XINT highcardval;
  166. XINT sort1, sort2;
  167. char highcardnum;
  168.  
  169. memset(tmpsort, -1, POKERMAXCARDS);
  170. memset(sortused, 0, POKERMAXCARDS);
  171.  
  172. for (sort1 = sgame->numcards - 1; sort1 >= 0; sort1--)
  173.     {
  174.     highcardval = 0;
  175.     highcardnum = -1;
  176.     for (sort2 = 0; sort2 < sgame->numcards; sort2++)
  177.         {
  178.         if (!sortused[sort2])
  179.             {
  180.             unsigned XINT tmpval;
  181.  
  182.             tmpval = (sval(sort2) * 0x10) + ssuit(sort2);
  183.             if (tmpval >= highcardval)
  184.                 {
  185.                 highcardval = tmpval;
  186.                 highcardnum = sort2;
  187.                 }
  188.             }
  189.         }
  190.     sortused[highcardnum] = 1;
  191.     tmpsort[sort1] = shand[highcardnum];
  192.     }
  193.  
  194. memcpy(shand, tmpsort, POKERMAXCARDS);
  195.  
  196. return;
  197. }
  198.