home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / top2src.zip / GAMES.ZIP / OLDPOKER.ZIP / OLDPKSCO.C < prev    next >
C/C++ Source or Header  |  1995-04-14  |  5KB  |  207 lines
  1. #include "top.h"
  2.  
  3. void poker_findwinners(char *wwho, poker_game_typ *wgame)
  4. {
  5. unsigned XINT *handscores, maxscore = 0;
  6. unsigned long *handrawscores, maxrawscore = 0;
  7. XINT fwd, winnum = 0;
  8. poker_player_typ wplyr;
  9.  
  10. handscores = farcalloc(MAXNODES, 2);
  11. if (!handscores)
  12.     {
  13.     dispatch_message(MSG_GENERIC, "^I^mNot enough memory to play Poker!^A^p",
  14.                      od_control.od_node, 0, 0);
  15.     return;
  16.     }
  17. handrawscores = farcalloc(MAXNODES, 4);
  18. if (!handrawscores)
  19.     {
  20.     dispatch_message(MSG_GENERIC, "^I^mNot enough memory to play Poker!^A^p",
  21.                      od_control.od_node, 0, 0);
  22.     dofree(handscores);
  23.     return;
  24.     }
  25.  
  26. memset(wgame->winners, -1, 10);
  27.  
  28. for (fwd = 0; fwd < MAXNODES; fwd++)
  29.     {
  30.     if (!wwho[fwd])
  31.         {
  32.         continue;
  33.         }
  34.     poker_loadplyrdata(fwd, &wplyr);
  35.     handscores[fwd] = poker_scorehand(&wplyr);
  36.     handrawscores[fwd] = poker_rawscorehand(&wplyr);
  37.     if (handscores[fwd] > maxscore)
  38.         {
  39.         maxscore = handscores[fwd];
  40.         maxrawscore = handrawscores[fwd];
  41.         memcpy(wgame->wincards, wplyr.cards, 10L);
  42.         }
  43.     if (handscores[fwd] == maxscore && handrawscores[fwd] > maxrawscore)
  44.         {
  45.         maxrawscore = handrawscores[fwd];
  46.         memcpy(wgame->wincards, wplyr.cards, 10L);
  47.         }
  48.     }
  49.  
  50. for (fwd = 0; fwd < 10; fwd++)
  51.     {
  52.     wgame->winners[fwd] = -1;
  53.     }
  54. for (fwd = 0; fwd < MAXNODES; fwd++)
  55.     {
  56.     if (handscores[fwd] == maxscore && handrawscores[fwd] == maxrawscore)
  57.         {
  58.         wgame->winners[winnum++] = fwd;
  59.         }
  60.     }
  61.  
  62. wgame->winscore = maxscore;
  63. wgame->winrawscore = maxrawscore;
  64. wgame->numwinners = winnum;
  65.  
  66. dofree(handscores); dofree(handrawscores);
  67.  
  68. return;
  69. }
  70.  
  71. #define scard       sdat->cards
  72. #define ssuit(xss)  (sdat->cards[xss] % 4)
  73. #define acemod(amv) (((sdat->cards[amv] % 13) == 0) ? (sgame.acehigh\
  74.                      ? 13 : 0) : 0)
  75. #define sval(xsv)   ((sdat->cards[xsv] % 13) + acemod(xsv))
  76.  
  77. unsigned XINT poker_scorehand(poker_player_typ *sdat)
  78. {
  79. unsigned XINT scoreret, sd, se;
  80. char basehand[3] = { 0,0,0 }, pairvals[10], pnum;
  81. poker_game_typ sgame;
  82.  
  83. poker_loadgamedata(&sgame);
  84.  
  85. poker_sorthand(sdat);
  86.  
  87. // Major mods for 7Stud, naturally.
  88. // Ditto for Jokers.
  89.  
  90. for (sd = 0, pnum = 0; sd < 5; sd++)
  91.     {
  92.     for (se = sd + 1; se < 5; se++)
  93.         {
  94.         if (sval(sd) == sval(se))
  95.             {
  96.             basehand[0]++;
  97.             pairvals[pnum++] = sval(se);
  98.             }
  99.         }
  100.     }
  101.  
  102. scoreret = POKHAND_HIGHCARD + sval(4);
  103. if (basehand[0] == 1)
  104.     {
  105.     scoreret = POKHAND_ONEPAIR + pairvals[0];
  106.     }
  107. if (basehand[0] == 2)
  108.     {
  109.     scoreret = POKHAND_TWOPAIR + (pairvals[1] * 0x10) + pairvals[0];
  110.     }
  111. if (basehand[0] == 3)
  112.     {
  113.     scoreret = POKHAND_THREEKIND + pairvals[2];
  114.     }
  115. if ((sval(1) == sval(0) + 1) && (sval(2) == sval(0) + 2) &&
  116.     (sval(3) == sval(0) + 3) && (sval(4) == sval(0) + 4))
  117.     {
  118.     basehand[1]++;
  119.     scoreret = POKHAND_STRAIGHT + sval(4);
  120.     }
  121. if ((ssuit(0) == ssuit(1)) && (ssuit(1) == ssuit(2)) &&
  122.     (ssuit(2) == ssuit(3)) && (ssuit(3) == ssuit(4)))
  123.     {
  124.     basehand[2]++;
  125.     scoreret = POKHAND_FLUSH + sval(4);
  126.     }
  127. if (basehand[0] == 4)
  128.     {
  129.     if (sval(1) == sval(2))
  130.         {
  131.         scoreret = POKHAND_FULLHOUSE + (sval(2) * 0x10) + sval(3);
  132.         }
  133.     else
  134.         {
  135.         scoreret = POKHAND_FULLHOUSE + (sval(2) * 0x10) + sval(1);
  136.         }
  137.     }
  138. if (basehand[0] == 6)
  139.     {
  140.     scoreret = POKHAND_FOURKIND + pairvals[5];
  141.     }
  142. if (basehand[1] == 1 && basehand[2] == 1)
  143.     {
  144.     scoreret = POKHAND_STRAIGHTFLUSH + sval(4);
  145.     }
  146.  
  147. return scoreret;
  148. }
  149.  
  150. unsigned long poker_rawscorehand(poker_player_typ *sdat)
  151. {
  152. XINT prshd;
  153. unsigned long scoreret = 0;
  154. poker_game_typ sgame;
  155.  
  156. poker_loadgamedata(&sgame);
  157.  
  158. for (prshd = 0; prshd < 5; prshd++)
  159.     {
  160.     scoreret += ((unsigned long) sval(prshd) +
  161.                 ((unsigned long) 0x10 * (unsigned long) prshd));
  162.     }
  163.  
  164. //scoreret <<= 8L; // Should only be done for 5 card games!
  165. //scoreret <<= 4L; (6 card games)
  166.  
  167. return scoreret;
  168. }
  169.  
  170. void poker_sorthand(poker_player_typ *sdat)
  171. {
  172. char tmpsort[10] = { 0,0,0,0,0,0,0,0,0,0 };
  173. char sortused[10] = { 0,0,0,0,0,0,0,0,0,0 };
  174. unsigned XINT highcardval;
  175. XINT sort1, sort2;
  176. char highcardnum;
  177. poker_game_typ sgame;
  178.  
  179. poker_loadgamedata(&sgame);
  180.  
  181. for (sort1 = 4; sort1 >= 0; sort1--) // 4 = numcards - 1
  182.     {
  183.     highcardval = 0;
  184.     highcardnum = -1;
  185.     for (sort2 = 0; sort2 < 5; sort2++)
  186.         {
  187.         if (!sortused[sort2])
  188.             {
  189.             unsigned XINT tmpval;
  190.  
  191.             tmpval = (sval(sort2) * 0x10) + ssuit(sort2);
  192.             if (tmpval >= highcardval)
  193.                 {
  194.                 highcardval = tmpval;
  195.                 highcardnum = sort2;
  196.                 }
  197.             }
  198.         }
  199.     sortused[highcardnum] = 1;
  200.     tmpsort[sort1] = sdat->cards[highcardnum];
  201.     }
  202.  
  203. memcpy(sdat->cards, tmpsort, 10);
  204.  
  205. return;
  206. }
  207.