API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Apr 20th, 2019
113
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 37.35 KB | None | 0 0
raw download clone embed print report
  1. package finalProject;
  2.  
  3. import static java.util.Arrays.asList;
  4.  
  5. import java.util.List;
  6.  
  7. /***************************************************************************
  8. Copyright (c) 2000:
  9. University of Alberta,
  10. Deptartment of Computing Science
  11. Computer Poker Research Group
  12.  
  13. See "Liscence.txt"
  14. ***************************************************************************/
  15. /**
  16. * Class for identifying / comparing / ranking Hands.
  17. *
  18. * @author Aaron Davidson, Darse Billings, Denis Papp
  19. */
  20.  
  21. public class HandEvaluator {
  22.  
  23. public static void main(String args[]){
  24. Hand hand1 = new Hand("Ac Kc");
  25. Hand hand2 = new Hand("Ac Kc Qc Jc Tc Qd Ad");
  26.  
  27. HandEvaluator handEval = new HandEvaluator();
  28.  
  29. System.out.println(handEval.getBest5CardHand(hand1));
  30. System.out.println(handEval.getBest5CardHand(hand2));
  31.  
  32. System.out.println(handEval.rankHand(hand1));
  33. System.out.println(handEval.rankHand(hand2));
  34.  
  35. System.out.println(handEval.nameHand(hand1));
  36. System.out.println(handEval.nameHand(hand2));
  37.  
  38. System.out.println(handEval.compareHands(hand1, hand2));
  39.  
  40. }
  41.  
  42. /**
  43. * Get a numerical ranking of this hand.
  44. *
  45. * @param c1
  46. * first hole card
  47. * @param c2
  48. * second hole card
  49. * @param h
  50. * a 3-5 card hand
  51. * @return a unique number representing the hand strength of the best 5-card
  52. * poker hand in the given cards and board. The higher the number,
  53. * the better the hand is.
  54. */
  55. public int rankHand(Card c1, Card c2, Hand h) {
  56. h.addCard(c1);
  57. h.addCard(c2);
  58. int rank = rankHand(h);
  59. h.removeCard();
  60. h.removeCard();
  61. return rank;
  62. }
  63.  
  64. /**
  65. * Given a hand, return a string naming the hand ('Ace High Flush', etc..)
  66. */
  67. public static String nameHand(Hand h) {
  68. return name_hand(rankHand(h));
  69. }
  70.  
  71. /**
  72. * Compares two hands against each other.
  73. *
  74. * @param h1
  75. * The first hand
  76. * @param h2
  77. * The second hand
  78. * @return 1 = first hand is best, 2 = second hand is best, 0 = tie
  79. */
  80. public int compareHands(Hand h1, Hand h2) {
  81. int r1 = rankHand(h1);
  82. int r2 = rankHand(h2);
  83.  
  84. if (r1 > r2)
  85. return 1;
  86. if (r1 < r2)
  87. return 2;
  88. return 0;
  89. }
  90.  
  91. /**
  92. * Compares two 5-7 card hands against each other.
  93. *
  94. * @param rank1
  95. * The rank of the first hand
  96. * @param h2
  97. * The second hand
  98. * @return 1 = first hand is best, 2 = second hand is best, 0 = tie
  99. */
  100. public int compareHands(int rank1, Hand h2) {
  101. int r1 = rank1;
  102. int r2 = rankHand(h2);
  103.  
  104. if (r1 > r2)
  105. return 1;
  106. if (r1 < r2)
  107. return 2;
  108. return 0;
  109. }
  110.  
  111. /**
  112. * Given a board, cache all possible two card combinations of hand ranks, so
  113. * that lightenting fast hand comparisons may be done later.
  114. */
  115. public int[][] getRanks(Hand board) {
  116. Hand myhand = new Hand(board);
  117. int[][] rc = new int[52][52];
  118. int i, j, v, n1, n2;
  119. Deck d = new Deck();
  120. d.extractHand(board);
  121.  
  122. // tabulate ranks
  123. for (i = d.getTopCardIndex(); i < Deck.NUM_CARDS; i++) {
  124. myhand.addCard(d.getCard(i));
  125. n1 = d.getCard(i).getIndex();
  126. for (j = i + 1; j < Deck.NUM_CARDS; j++) {
  127. myhand.addCard(d.getCard(j));
  128. n2 = d.getCard(j).getIndex();
  129. rc[n1][n2] = rc[n2][n1] = rankHand(myhand);
  130. myhand.removeCard();
  131. }
  132. myhand.removeCard();
  133. }
  134. return rc;
  135. }
  136.  
  137. /** ******************************************************************* */
  138. // MORE HAND COMPARISON STUFF (Adapted from C code by Darse Billings)
  139. /** ******************************************************************* */
  140.  
  141. /**
  142. * Get the best 5 card poker hand from a 7 card hand
  143. *
  144. * @param h
  145. * Any 7 card poker hand
  146. * @return A Hand containing the highest ranked 5 card hand possible from the
  147. * input.
  148. */
  149. public Hand getBest5CardHand(Hand h) {
  150. int[] ch = h.getCardArray();
  151. int[] bh = new int[6];
  152. int j = Find_Hand(ch, bh);
  153. Hand nh = new Hand();
  154. for (int i = 0; i < 5; i++)
  155. nh.addCard(bh[i + 1]);
  156. return nh;
  157. }
  158.  
  159. private final static int unknown = -1;
  160. private final static int strflush = 9;
  161. private final static int quads = 8;
  162. private final static int fullhouse = 7;
  163. private final static int flush = 6;
  164. private final static int straight = 5;
  165. private final static int trips = 4;
  166. private final static int twopair = 3;
  167. private final static int pair = 2;
  168. private final static int nopair = 1;
  169. private final static int highcard = 1;
  170.  
  171. /**
  172. * Get a string from a hand type.
  173. *
  174. * @param handtype
  175. * number coding a hand type
  176. * @return name of hand type
  177. */
  178. private String drb_Name_Hand(int handtype) {
  179. switch (handtype) {
  180. case -1:
  181. return ("Hidden Hand");
  182. case 1:
  183. return ("High Card");
  184. case 2:
  185. return ("Pair");
  186. case 3:
  187. return ("Two Pair");
  188. case 4:
  189. return ("Three of a Kind");
  190. case 5:
  191. return ("Straight");
  192. case 6:
  193. return ("Flush");
  194. case 7:
  195. return ("Full House");
  196. case 8:
  197. return ("Four of a Kind");
  198. case 9:
  199. return ("Straight Flush");
  200. default:
  201. return ("Very Weird hand indeed");
  202. }
  203. }
  204.  
  205. /* drbcont: want to Find_ the _best_ flush and _best_ strflush ( >9 cards) */
  206.  
  207. private static boolean Check_StrFlush(int[] hand, int[] dist, int[] best) {
  208. int i, j, suit, strght, strtop;
  209. boolean returnvalue;
  210. int[] suitvector = new int[14];
  211. /*
  212. * _23456789TJQKA boolean vector 01234567890123 indexing
  213. */
  214.  
  215. returnvalue = false; /* default */
  216.  
  217. /* do flat distribution of whole suits (cdhs are 0123 respectively) */
  218.  
  219. for (suit = 0; suit <= 3; suit++) {
  220.  
  221. /* explicitly initialize suitvector */
  222. suitvector[0] = 13;
  223. for (i = 1; i <= suitvector[0]; i++) {
  224. suitvector[i] = 0;
  225. }
  226. for (i = 1; i <= hand[0]; i++) {
  227. if ((hand[i] != unknown) && ((hand[i] / 13) == suit)) {
  228. suitvector[(hand[i] % 13) + 1] = 1;
  229. };
  230. }
  231.  
  232. /* now look for straights */
  233. if (suitvector[13] >= 1) /* Ace low straight */
  234. {
  235. strght = 1;
  236. } else
  237. strght = 0;
  238. strtop = 0;
  239.  
  240. for (i = 1; i <= 13; i++) {
  241. if (suitvector[i] >= 1) {
  242. strght++;
  243. if (strght >= 5) {
  244. strtop = i - 1;
  245. };
  246. } else
  247. strght = 0;
  248. }
  249.  
  250. /* determine if there was a straight flush and copy it to best[] */
  251.  
  252. if (strtop > 0) { /* no 2-high straight flushes */
  253. for (j = 1; j <= 5; j++) {
  254. best[j] = ((13 * suit) + strtop + 1 - j);
  255. }
  256. /* Adjust for case of Ace low (five high) straight flush */
  257. if (strtop == 3) {
  258. best[5] = best[5] + 13;
  259. }
  260. returnvalue = true;
  261. }
  262. }
  263. return (returnvalue);
  264. }
  265.  
  266. private void Find_Quads(int[] hand, int[] dist, int[] best) {
  267. int i, j, quadrank = 0, kicker;
  268.  
  269. /* find rank of largest quads */
  270. for (i = 1; i <= 13; i++) {
  271. if (dist[i] >= 4) {
  272. quadrank = i - 1;
  273. }
  274. ;
  275. }
  276.  
  277. /* copy those quads */
  278. i = 1; /* position in hand[] */
  279. j = 1; /* position in best[] */
  280. while (j <= 4) { /* assume all four will be found before i > hand[0] */
  281. if ((hand[i] != unknown) && ((hand[i] % 13) == quadrank)) {
  282. best[j] = hand[i];
  283. j++;
  284. }
  285. ;
  286. i++;
  287. }
  288.  
  289. /* find best kicker */
  290. kicker = unknown; /* default is unknown kicker */
  291. for (i = 1; i <= 13; i++) { /* find rank of largest kicker */
  292. if ((dist[i] >= 1) && ((i - 1) != quadrank)) {
  293. kicker = i - 1;
  294. }
  295. }
  296.  
  297. /* copy kicker */
  298. if (kicker != unknown) {
  299. i = 1; /* position in hand[] */
  300. while (j <= 5) { /* assume kicker will be found before i > hand[0] */
  301. if ((hand[i] != unknown) && ((hand[i] % 13) == kicker)) {
  302. best[j] = hand[i];
  303. j++;
  304. }
  305. ;
  306. i++;
  307. }
  308. } else {
  309. best[j] = unknown;
  310. j++;
  311. }
  312. }
  313.  
  314. private void Find_FullHouse(int[] hand, int[] dist, int[] best) {
  315. int i, j, tripsrank = 0, pairrank = 0;
  316.  
  317. /* find rank of largest trips */
  318. for (i = 1; i <= 13; i++) {
  319. if (dist[i] >= 3) {
  320. tripsrank = i - 1;
  321. }
  322. ;
  323. }
  324.  
  325. /* copy those trips */
  326. i = 1; /* position in hand[] */
  327. j = 1; /* position in best[] */
  328. while (j <= 3) { /* assume all three will be found before i > hand[0] */
  329. if ((hand[i] != unknown) && ((hand[i] % 13) == tripsrank)) {
  330. best[j] = hand[i];
  331. j++;
  332. }
  333. ;
  334. i++;
  335. }
  336.  
  337. /* find best pair */
  338. i = 13;
  339. pairrank = -1;
  340. while (pairrank < 0) { /* assume kicker will be found before i = 0 */
  341. if ((dist[i] >= 2) && ((i - 1) != tripsrank)) {
  342. pairrank = i - 1;
  343. } else
  344. i--;
  345. }
  346.  
  347. /* copy best pair */
  348. i = 1; /* position in hand[] */
  349. while (j <= 5) { /* assume pair will be found before i > hand[0] */
  350. if ((hand[i] != unknown) && ((hand[i] % 13) == pairrank)) {
  351. best[j] = hand[i];
  352. j++;
  353. }
  354. ;
  355. i++;
  356. }
  357. }
  358.  
  359. private void Find_Flush(int[] hand, int[] dist, int[] best) { /*
  360. * finds only
  361. * the best
  362. * flush in
  363. * highest
  364. * suit
  365. */
  366. int i, j, flushsuit = 0;
  367. int[] suitvector = new int[14];
  368. /*
  369. * _23456789TJQKA boolean vector 01234567890123 indexing
  370. */
  371. /* find flushsuit */
  372. for (i = 14; i <= 17; i++) {
  373. if (dist[i] >= 5) {
  374. flushsuit = i - 14;
  375. }
  376. ;
  377. }
  378.  
  379. /* explicitly initialize suitvector */
  380. suitvector[0] = 13;
  381. for (i = 1; i <= suitvector[0]; i++) {
  382. suitvector[i] = 0;
  383. }
  384.  
  385. /* do flat distribution of whole flushsuit */
  386. for (i = 1; i <= hand[0]; i++) {
  387. if ((hand[i] != unknown) && ((hand[i] / 13) == flushsuit)) {
  388. suitvector[(hand[i] % 13) + 1] = 1;
  389. }
  390. ;
  391. }
  392.  
  393. /* determine best five cards in flushsuit */
  394. i = 13;
  395. j = 1;
  396. while (j <= 5) { /* assume all five flushcards will be found before i < 1 */
  397. if (suitvector[i] >= 1) {
  398. best[j] = (13 * flushsuit) + i - 1;
  399. j++;
  400. }
  401. ;
  402. i--;
  403. }
  404. }
  405.  
  406. private void Find_Straight(int[] hand, int[] dist, int[] best) {
  407. int i, j, strght, strtop;
  408.  
  409. /* look for highest straight */
  410. if (dist[13] >= 1) /* Ace low straight */
  411. {
  412. strght = 1;
  413. } else
  414. strght = 0;
  415. strtop = 0;
  416.  
  417. for (i = 1; i <= 13; i++) {
  418. if (dist[i] >= 1) {
  419. strght++;
  420. if (strght >= 5) {
  421. strtop = i - 1;
  422. }
  423. ;
  424. } else
  425. strght = 0;
  426. }
  427.  
  428. /* copy the highest straight */
  429. if (strtop > 3) { /* note: different extraction from others */
  430. for (j = 1; j <= 5; j++) {
  431. for (i = 1; i <= hand[0]; i++) {
  432. if ((hand[i] != unknown) && (hand[i] % 13 == (strtop + 1 - j))) {
  433. best[j] = hand[i];
  434. }
  435. ;
  436. }
  437. }
  438. } else if (strtop == 3) {
  439. for (j = 1; j <= 4; j++) {
  440. for (i = 1; i <= hand[0]; i++) {
  441. if ((hand[i] != unknown) && (hand[i] % 13 == (strtop + 1 - j))) {
  442. best[j] = hand[i];
  443. }
  444. ;
  445. }
  446. }
  447. for (i = 1; i <= hand[0]; i++) { /* the Ace in a low straight */
  448. if ((hand[i] != unknown) && (hand[i] % 13 == 12)) {
  449. best[5] = hand[i];
  450. }
  451. ;
  452. }
  453. }
  454. }
  455.  
  456. private void Find_Trips(int[] hand, int[] dist, int[] best) {
  457. int i, j, tripsrank = 0, kicker1, kicker2;
  458.  
  459. /* find rank of largest trips */
  460. for (i = 1; i <= 13; i++) {
  461. if (dist[i] >= 3) {
  462. tripsrank = i - 1;
  463. }
  464. ;
  465. }
  466.  
  467. /* copy those trips */
  468. i = 1; /* position in hand[] */
  469. j = 1; /* position in best[] */
  470. while (j <= 3) { /* assume all three will be found before i > hand[0] */
  471. if ((hand[i] != unknown) && ((hand[i] % 13) == tripsrank)) {
  472. best[j] = hand[i];
  473. j++;
  474. }
  475. ;
  476. i++;
  477. }
  478.  
  479. /* find best kickers */
  480. kicker1 = unknown; /* default is unknown kicker */
  481. for (i = 1; i <= 13; i++) { /* find rank of largest kicker */
  482. if ((dist[i] >= 1) && ((i - 1) != tripsrank)) {
  483. kicker1 = i - 1;
  484. }
  485. ;
  486. }
  487.  
  488. kicker2 = unknown;
  489. for (i = 1; i <= kicker1; i++) { /* find rank of second kicker */
  490. if ((dist[i] >= 1) && ((i - 1) != tripsrank)) {
  491. kicker2 = i - 1;
  492. }
  493. ;
  494. }
  495.  
  496. /* copy kickers */
  497. if (kicker1 != unknown) {
  498. i = 1; /* position in hand[] */
  499. while (j <= 4) { /* assume kicker1 will be found before i > hand[0] */
  500. if ((hand[i] != unknown) && ((hand[i] % 13) == kicker1)) {
  501. best[j] = hand[i];
  502. j++;
  503. }
  504. ;
  505. i++;
  506. }
  507. } else {
  508. best[j] = unknown;
  509. j++;
  510. }
  511.  
  512. if (kicker2 != unknown) {
  513. i = 1; /* position in hand[] */
  514. while (j <= 5) { /* assume kicker2 will be found before i > hand[0] */
  515. if ((hand[i] != unknown) && ((hand[i] % 13) == kicker2)) {
  516. best[j] = hand[i];
  517. j++;
  518. }
  519. ;
  520. i++;
  521. }
  522. } else {
  523. best[j] = unknown;
  524. j++;
  525. }
  526. }
  527.  
  528. private void Find_TwoPair(int[] hand, int[] dist, int[] best) {
  529. int i, j, pairrank1 = 0, pairrank2 = 0, kicker;
  530.  
  531. /* find rank of largest pair */
  532. for (i = 1; i <= 13; i++) {
  533. if (dist[i] >= 2) {
  534. pairrank1 = i - 1;
  535. }
  536. ;
  537. }
  538. /* find rank of second largest pair */
  539. for (i = 1; i <= 13; i++) {
  540. if ((dist[i] >= 2) && ((i - 1) != pairrank1)) {
  541. pairrank2 = i - 1;
  542. }
  543. ;
  544. }
  545.  
  546. /* copy those pairs */
  547. i = 1; /* position in hand[] */
  548. j = 1; /* position in best[] */
  549. while (j <= 2) { /* assume both will be found before i > hand[0] */
  550. if ((hand[i] != unknown) && ((hand[i] % 13) == pairrank1)) {
  551. best[j] = hand[i];
  552. j++;
  553. }
  554. ;
  555. i++;
  556. }
  557. i = 1; /* position in hand[] */
  558. while (j <= 4) { /* assume both will be found before i > hand[0] */
  559. if ((hand[i] != unknown) && ((hand[i] % 13) == pairrank2)) {
  560. best[j] = hand[i];
  561. j++;
  562. }
  563. ;
  564. i++;
  565. }
  566.  
  567. /* find best kicker */
  568. kicker = unknown; /* default is unknown kicker */
  569. for (i = 1; i <= 13; i++) { /* find rank of largest kicker */
  570. if ((dist[i] >= 1) && ((i - 1) != pairrank1) && ((i - 1) != pairrank2)) {
  571. kicker = i - 1;
  572. }
  573. }
  574.  
  575. /* copy kicker */
  576. if (kicker != unknown) {
  577. i = 1; /* position in hand[] */
  578. while (j <= 5) { /* assume kicker will be found before i > hand[0] */
  579. if ((hand[i] != unknown) && ((hand[i] % 13) == kicker)) {
  580. best[j] = hand[i];
  581. j++;
  582. }
  583. ;
  584. i++;
  585. }
  586. } else {
  587. best[j] = unknown;
  588. j++;
  589. }
  590. }
  591.  
  592. private void Find_Pair(int[] hand, int[] dist, int[] best) {
  593. int i, j, pairrank = 0, kicker1, kicker2, kicker3;
  594.  
  595. /* find rank of largest pair */
  596. for (i = 1; i <= 13; i++) {
  597. if (dist[i] >= 2) {
  598. pairrank = i - 1;
  599. }
  600. ;
  601. }
  602.  
  603. /* copy that pair */
  604. i = 1; /* position in hand[] */
  605. j = 1; /* position in best[] */
  606. while (j <= 2) { /* assume both will be found before i > hand[0] */
  607. if ((hand[i] != unknown) && ((hand[i] % 13) == pairrank)) {
  608. best[j] = hand[i];
  609. j++;
  610. }
  611. ;
  612. i++;
  613. }
  614.  
  615. /* find best kickers */
  616. kicker1 = unknown; /* default is unknown kicker */
  617. for (i = 1; i <= 13; i++) { /* find rank of largest kicker */
  618. if ((dist[i] >= 1) && ((i - 1) != pairrank)) {
  619. kicker1 = i - 1;
  620. }
  621. ;
  622. }
  623. kicker2 = unknown;
  624. for (i = 1; i <= kicker1; i++) { /* find rank of second kicker */
  625. if ((dist[i] >= 1) && ((i - 1) != pairrank)) {
  626. kicker2 = i - 1;
  627. }
  628. ;
  629. }
  630. kicker3 = unknown;
  631. for (i = 1; i <= kicker2; i++) { /* find rank of third kicker */
  632. if ((dist[i] >= 1) && ((i - 1) != pairrank)) {
  633. kicker3 = i - 1;
  634. }
  635. }
  636.  
  637. /* copy kickers */
  638. if (kicker1 != unknown) {
  639. i = 1; /* position in hand[] */
  640. while (j <= 3) { /* assume kicker1 will be found before i > hand[0] */
  641. if ((hand[i] != unknown) && ((hand[i] % 13) == kicker1)) {
  642. best[j] = hand[i];
  643. j++;
  644. }
  645. ;
  646. i++;
  647. }
  648. } else {
  649. best[j] = unknown;
  650. j++;
  651. }
  652.  
  653. if (kicker2 != unknown) {
  654. i = 1; /* position in hand[] */
  655. while (j <= 4) { /* assume kicker2 will be found before i > hand[0] */
  656. if ((hand[i] != unknown) && ((hand[i] % 13) == kicker2)) {
  657. best[j] = hand[i];
  658. j++;
  659. }
  660. ;
  661. i++;
  662. }
  663. } else {
  664. best[j] = unknown;
  665. j++;
  666. }
  667.  
  668. if (kicker3 != unknown) {
  669. i = 1; /* position in hand[] */
  670. while (j <= 5) { /* assume kicker3 will be found before i > hand[0] */
  671. if ((hand[i] != unknown) && ((hand[i] % 13) == kicker3)) {
  672. best[j] = hand[i];
  673. j++;
  674. }
  675. ;
  676. i++;
  677. }
  678. } else {
  679. best[j] = unknown;
  680. j++;
  681. }
  682. }
  683.  
  684. private void Find_NoPair(int[] hand, int[] dist, int[] best) {
  685. int i, j, kicker1, kicker2, kicker3, kicker4, kicker5;
  686.  
  687. /* find best kickers */
  688. kicker1 = unknown; /* default is unknown kicker */
  689. for (i = 1; i <= 13; i++) { /* find rank of largest kicker */
  690. if (dist[i] >= 1) {
  691. kicker1 = i - 1;
  692. }
  693. ;
  694. }
  695. kicker2 = unknown;
  696. for (i = 1; i <= kicker1; i++) { /* find rank of second kicker */
  697. if (dist[i] >= 1) {
  698. kicker2 = i - 1;
  699. }
  700. ;
  701. }
  702. kicker3 = unknown;
  703. for (i = 1; i <= kicker2; i++) { /* find rank of third kicker */
  704. if (dist[i] >= 1) {
  705. kicker3 = i - 1;
  706. }
  707. ;
  708. }
  709. kicker4 = unknown;
  710. for (i = 1; i <= kicker3; i++) { /* find rank of fourth kicker */
  711. if (dist[i] >= 1) {
  712. kicker4 = i - 1;
  713. }
  714. ;
  715. }
  716. kicker5 = unknown;
  717. for (i = 1; i <= kicker4; i++) { /* find rank of fifth kicker */
  718. if (dist[i] >= 1) {
  719. kicker5 = i - 1;
  720. }
  721. ;
  722. }
  723.  
  724. /* copy kickers */
  725. j = 1; /* position in best[] */
  726.  
  727. if (kicker1 != unknown) {
  728. i = 1; /* position in hand[] */
  729. while (j <= 1) { /* assume kicker1 will be found before i > hand[0] */
  730. if ((hand[i] != unknown) && ((hand[i] % 13) == kicker1)) {
  731. best[j] = hand[i];
  732. j++;
  733. }
  734. ;
  735. i++;
  736. }
  737. } else {
  738. best[j] = unknown;
  739. j++;
  740. }
  741.  
  742. if (kicker2 != unknown) {
  743. i = 1; /* position in hand[] */
  744. while (j <= 2) { /* assume kicker2 will be found before i > hand[0] */
  745. if ((hand[i] != unknown) && ((hand[i] % 13) == kicker2)) {
  746. best[j] = hand[i];
  747. j++;
  748. }
  749. ;
  750. i++;
  751. }
  752. } else {
  753. best[j] = unknown;
  754. j++;
  755. }
  756.  
  757. if (kicker3 != unknown) {
  758. i = 1; /* position in hand[] */
  759. while (j <= 3) { /* assume kicker3 will be found before i > hand[0] */
  760. if ((hand[i] != unknown) && ((hand[i] % 13) == kicker3)) {
  761. best[j] = hand[i];
  762. j++;
  763. }
  764. ;
  765. i++;
  766. }
  767. } else {
  768. best[j] = unknown;
  769. j++;
  770. }
  771.  
  772. if (kicker4 != unknown) {
  773. i = 1; /* position in hand[] */
  774. while (j <= 4) { /* assume kicker4 will be found before i > hand[0] */
  775. if ((hand[i] != unknown) && ((hand[i] % 13) == kicker4)) {
  776. best[j] = hand[i];
  777. j++;
  778. }
  779. ;
  780. i++;
  781. }
  782. } else {
  783. best[j] = unknown;
  784. j++;
  785. }
  786.  
  787. if (kicker5 != unknown) {
  788. i = 1; /* position in hand[] */
  789. while (j <= 5) { /* assume kicker5 will be found before i > hand[0] */
  790. if ((hand[i] != unknown) && ((hand[i] % 13) == kicker5)) {
  791. best[j] = hand[i];
  792. j++;
  793. }
  794. ;
  795. i++;
  796. }
  797. } else {
  798. best[j] = unknown;
  799. j++;
  800. }
  801. }
  802.  
  803. private int Best_Hand(int[] hand1, int[] hand2) { /*
  804. * sorted 5-card hands,
  805. * both same type
  806. */
  807. /* could check for proper hand types... */
  808.  
  809. /* check value of top cards, then on down */
  810. if ((hand1[1] % 13) > (hand2[1] % 13))
  811. return (1);
  812. else if ((hand1[1] % 13) < (hand2[1] % 13))
  813. return (2);
  814.  
  815. /* same top, check second */
  816. else if ((hand1[2] % 13) > (hand2[2] % 13))
  817. return (1);
  818. else if ((hand1[2] % 13) < (hand2[2] % 13))
  819. return (2);
  820.  
  821. /* same second, check third */
  822. else if ((hand1[3] % 13) > (hand2[3] % 13))
  823. return (1);
  824. else if ((hand1[3] % 13) < (hand2[3] % 13))
  825. return (2);
  826.  
  827. /* same third, check fourth */
  828. else if ((hand1[4] % 13) > (hand2[4] % 13))
  829. return (1);
  830. else if ((hand1[4] % 13) < (hand2[4] % 13))
  831. return (2);
  832.  
  833. /* same fourth, check fifth */
  834. else if ((hand1[5] % 13) > (hand2[5] % 13))
  835. return (1);
  836. else if ((hand1[5] % 13) < (hand2[5] % 13))
  837. return (2);
  838.  
  839. else
  840. /* same hands */
  841. return (0);
  842. }
  843.  
  844. private int Find_Hand(int[] hand, int[] best) { /* -1 means unknown card */
  845. int i, card, rank, suit, hand_type, rankmax1, rankmax2, flushmax, strght, strmax;
  846. int[] dist = new int[18];
  847. /*
  848. * _23456789TJQKAcdhs distribution vector 012345678901234567 indexing
  849. */
  850.  
  851. /* explicitly initialize distribution vector */
  852. dist[0] = 17;
  853. for (i = 1; i <= dist[0]; i++) {
  854. dist[i] = 0;
  855. }
  856.  
  857. for (i = 1; i <= hand[0]; i++) {
  858. if (hand[i] != unknown) {
  859. card = hand[i];
  860. rank = card % 13;
  861. suit = card / 13;
  862.  
  863. if (!((rank < 0) || (rank > 12))) {
  864. dist[rank + 1]++;
  865. }
  866.  
  867. if (!((suit < 0) || (suit > 3))) {
  868. dist[suit + 14]++;
  869. }
  870. }
  871. }
  872.  
  873. /* scan the distribution array for maximums */
  874. rankmax1 = 0;
  875. rankmax2 = 0;
  876. flushmax = 0;
  877. strmax = 0;
  878.  
  879. if (dist[13] >= 1) {
  880. strght = 1;
  881. } else
  882. strght = 0; /* Ace low straight */
  883.  
  884. for (i = 1; i <= 13; i++) {
  885. if (dist[i] > rankmax1) {
  886. rankmax2 = rankmax1;
  887. rankmax1 = dist[i];
  888. } else if (dist[i] > rankmax2) {
  889. rankmax2 = dist[i];
  890. }
  891. ;
  892.  
  893. if (dist[i] >= 1) {
  894. strght++;
  895. if (strght > strmax) {
  896. strmax = strght;
  897. }
  898. } else
  899. strght = 0;
  900. }
  901.  
  902. for (i = 14; i <= 17; i++) {
  903. if (dist[i] > flushmax) {
  904. flushmax = dist[i];
  905. }
  906. }
  907.  
  908. hand_type = unknown;
  909.  
  910. if ((flushmax >= 5) && (strmax >= 5)) {
  911. if (Check_StrFlush(hand, dist, best)) {
  912. hand_type = strflush;
  913. } else {
  914. hand_type = flush;
  915. Find_Flush(hand, dist, best);
  916. }
  917. ;
  918. } else if (rankmax1 >= 4) {
  919. hand_type = quads;
  920. Find_Quads(hand, dist, best);
  921. } else if ((rankmax1 >= 3) && (rankmax2 >= 2)) {
  922. hand_type = fullhouse;
  923. Find_FullHouse(hand, dist, best);
  924. } else if (flushmax >= 5) {
  925. hand_type = flush;
  926. Find_Flush(hand, dist, best);
  927. } else if (strmax >= 5) {
  928. hand_type = straight;
  929. Find_Straight(hand, dist, best);
  930. } else if (rankmax1 >= 3) {
  931. hand_type = trips;
  932. Find_Trips(hand, dist, best);
  933. } else if ((rankmax1 >= 2) && (rankmax2 >= 2)) {
  934. hand_type = twopair;
  935. Find_TwoPair(hand, dist, best);
  936. } else if (rankmax1 >= 2) {
  937. hand_type = pair;
  938. Find_Pair(hand, dist, best);
  939. } else {
  940. hand_type = nopair;
  941. Find_NoPair(hand, dist, best);
  942. }
  943. ;
  944.  
  945. return (hand_type);
  946. }
  947.  
  948. /** ******************************************************************* */
  949. // DENIS PAPP'S HAND RANK IDENTIFIER CODE:
  950. /** ******************************************************************* */
  951.  
  952. private static final int POKER_HAND = 5;
  953.  
  954. public static final int HIGH = 0;
  955. public static final int PAIR = 1;
  956. public static final int TWOPAIR = 2;
  957. public static final int THREEKIND = 3;
  958. public static final int STRAIGHT = 4;
  959. public static final int FLUSH = 5;
  960. public static final int FULLHOUSE = 6;
  961. public static final int FOURKIND = 7;
  962. public static final int STRAIGHTFLUSH = 8;
  963. public static final int FIVEKIND = 9;
  964. public static final int NUM_HANDS = 10;
  965.  
  966. private static final int NUM_RANKS = 13;
  967.  
  968. private static final int ID_GROUP_SIZE = (Card.NUM_RANKS * Card.NUM_RANKS
  969. * Card.NUM_RANKS * Card.NUM_RANKS * Card.NUM_RANKS);
  970.  
  971. private final static byte ID_ExistsStraightFlush(Hand h, byte major_suit) {
  972. boolean[] present = new boolean[Card.NUM_RANKS];
  973. // for (i=0;i<Card.NUM_RANKS;i++) present[i]=false;
  974.  
  975. for (int i = 0; i < h.size(); i++) {
  976. int cind = h.getCardIndex(i + 1);
  977. if (Card.getSuit(cind) == major_suit) {
  978. present[Card.getRank(cind)] = true;
  979. }
  980. }
  981. int straight = present[Card.ACE] ? 1 : 0;
  982. byte high = 0;
  983. for (int i = 0; i < Card.NUM_RANKS; i++) {
  984. if (present[i]) {
  985. if ((++straight) >= POKER_HAND) {
  986. high = (byte) i;
  987. }
  988. } else {
  989. straight = 0;
  990. }
  991. }
  992. return high;
  993. }
  994.  
  995. // suit: Card.NUM_SUITS means any
  996. // not_allowed: Card.NUM_RANKS means any
  997. // returns ident value
  998. private final static int ID_KickerValue(byte[] paired, int kickers,
  999. byte[] not_allowed) {
  1000. int i = Card.ACE;
  1001. int value = 0;
  1002. while (kickers != 0) {
  1003. while (paired[i] == 0 || i == not_allowed[0] || i == not_allowed[1])
  1004. i--;
  1005. kickers--;
  1006. value += pow(Card.NUM_RANKS, kickers) * i;
  1007. i--;
  1008. }
  1009. return value;
  1010. }
  1011.  
  1012. private final static int ID_KickerValueSuited(Hand h, int kickers, byte suit) {
  1013. int i;
  1014. int value = 0;
  1015.  
  1016. boolean[] present = new boolean[Card.NUM_RANKS];
  1017. // for (i=0;i<Card.NUM_RANKS;i++) present[i] = false;
  1018.  
  1019. for (i = 0; i < h.size(); i++)
  1020. if (h.getCard(i + 1).getSuit() == suit)
  1021. present[h.getCard(i + 1).getRank()] = true;
  1022.  
  1023. i = Card.ACE;
  1024. while (kickers != 0) {
  1025. while (present[i] == false)
  1026. i--;
  1027. kickers--;
  1028. value += pow(Card.NUM_RANKS, kickers) * i;
  1029. i--;
  1030. }
  1031. return value;
  1032. }
  1033.  
  1034. /**
  1035. * Get a numerical ranking of this hand. Uses java based code, so may be
  1036. * slower than using the native methods, but is more compatible this way.
  1037. *
  1038. * Based on Denis Papp's Loki Hand ID code (id.cpp) Given a 1-9 card hand,
  1039. * will return a unique rank such that any two hands will be ranked with the
  1040. * better hand having a higher rank.
  1041. *
  1042. * @param h a 1-9 card hand
  1043. * @return a unique number representing the hand strength of the best 5-card
  1044. * poker hand in the given 7 cards. The higher the number, the better
  1045. * the hand is.
  1046. */
  1047. public final static int rankHand(Hand h) {
  1048. boolean straight = false;
  1049. boolean flush = false;
  1050. byte max_hand = (byte) (h.size() >= POKER_HAND ? POKER_HAND : h.size());
  1051. int r, c;
  1052. byte rank, suit;
  1053.  
  1054. // pair data
  1055. byte[] group_size = new byte[POKER_HAND + 1]; // array to track the groups or cards in your hand
  1056. byte[] paired = new byte[Card.NUM_RANKS]; // array to track paired carsd
  1057. byte[][] pair_rank = new byte[POKER_HAND + 1][2]; // array to track the rank of our pairs
  1058. // straight
  1059. byte straight_high = 0; // track the high card (rank) of our straight
  1060. byte straight_size;
  1061. // flush
  1062. byte[] suit_size = new byte[Card.NUM_SUITS];
  1063. byte major_suit = 0;
  1064.  
  1065. // determine pairs, dereference order data, check flush
  1066. // for (r=0;r<Card.NUM_RANKS;r++) paired[r] = 0;
  1067. // for (r=0;r<Card.NUM_SUITS;r++) suit_size[r] = 0;
  1068. // for (r=0;r<=POKER_HAND;r++) group_size[r] = 0;
  1069. for (r = 0; r < h.size(); r++) {
  1070. int cind = h.getCardIndex(r + 1);
  1071.  
  1072. rank = (byte) Card.getRank(cind);
  1073. suit = (byte) Card.getSuit(cind);
  1074.  
  1075. paired[rank]++; // Add rank of card to paired array to track the pairs we have.
  1076. group_size[paired[rank]]++; // keep track of the groups in our hand (1-pair, 2-pair, 1-trips, 1-trips 1-pair)
  1077. if (paired[rank] != 0) // To prevent looking at group_size[-1], which would be bad.
  1078. group_size[paired[rank] - 1]--; // Decrese the previous group by one. group_size[0] should end up at -5.
  1079. if ((++suit_size[suit]) >= POKER_HAND) { // Add suit to suit array, then check for a flush.
  1080. flush = true;
  1081. major_suit = suit;
  1082. }
  1083. }
  1084. // Card.ACE low? Add to straight_size if so.
  1085. straight_size = (byte) (paired[Card.ACE] != 0 ? 1 : 0);
  1086.  
  1087. for (int i = 0; i < (POKER_HAND + 1); i++) {
  1088. pair_rank[i][0] = (byte) Card.NUM_RANKS;
  1089. pair_rank[i][1] = (byte) Card.NUM_RANKS;
  1090. }
  1091.  
  1092. // check for straight and pair data
  1093. // Start at the Deuce. straight_size = 1 if we have an ace.
  1094. for (r = 0; r < Card.NUM_RANKS; r++) {
  1095. // check straight
  1096. if (paired[r] != 0) {
  1097. if ((++straight_size) >= POKER_HAND) { // Do we have five cards in a row (a straight!)
  1098. straight = true; // We sure do.
  1099. straight_high = (byte) r; // Keep track of that high card
  1100. }
  1101. } else { // Missing a card for our straight. start the count over.
  1102. straight_size = 0;
  1103. }
  1104. // get pair ranks, keep two highest of each
  1105. c = paired[r];
  1106. if (c != 0) {
  1107. pair_rank[c][1] = pair_rank[c][0];
  1108. pair_rank[c][0] = (byte) r;
  1109. }
  1110. }
  1111.  
  1112. // now id type
  1113. int ident;
  1114.  
  1115. if (group_size[POKER_HAND] != 0) { // we have five cards of the same rank in our hand.
  1116. ident = FIVEKIND * ID_GROUP_SIZE; // must have five of a kind !!
  1117. ident += pair_rank[POKER_HAND][0];
  1118. return ident;
  1119. }
  1120.  
  1121. if (straight && flush) {
  1122. byte hi = ID_ExistsStraightFlush(h, major_suit);
  1123. if (hi > 0) {
  1124. ident = STRAIGHTFLUSH * ID_GROUP_SIZE;
  1125. ident += hi;
  1126. return ident;
  1127. }
  1128. }
  1129.  
  1130. if (group_size[4] != 0) {
  1131. ident = FOURKIND * ID_GROUP_SIZE;
  1132. ident += pair_rank[4][0] * Card.NUM_RANKS;
  1133. pair_rank[4][1] = (byte) Card.NUM_RANKS; // just in case 2 sets quads
  1134. ident += ID_KickerValue(paired, 1, pair_rank[4]);
  1135. } else if (group_size[3] >= 2) {
  1136. ident = FULLHOUSE * ID_GROUP_SIZE;
  1137. ident += pair_rank[3][0] * Card.NUM_RANKS;
  1138. ident += pair_rank[3][1];
  1139. } else if (group_size[3] == 1 && group_size[2] != 0) {
  1140. ident = FULLHOUSE * ID_GROUP_SIZE;
  1141. ident += pair_rank[3][0] * Card.NUM_RANKS;
  1142. ident += pair_rank[2][0];
  1143. } else if (flush) {
  1144. ident = FLUSH * ID_GROUP_SIZE;
  1145. ident += ID_KickerValueSuited(h, 5, major_suit);
  1146. } else if (straight) {
  1147. ident = STRAIGHT * ID_GROUP_SIZE;
  1148. ident += straight_high;
  1149. } else if (group_size[3] == 1) {
  1150. ident = THREEKIND * ID_GROUP_SIZE;
  1151. ident += pair_rank[3][0] * Card.NUM_RANKS * Card.NUM_RANKS;
  1152. ident += ID_KickerValue(paired, max_hand - 3, pair_rank[3]);
  1153. } else if (group_size[2] >= 2) { // TWO PAIR
  1154. ident = TWOPAIR * ID_GROUP_SIZE;
  1155. ident += pair_rank[2][0] * Card.NUM_RANKS * Card.NUM_RANKS;
  1156. ident += pair_rank[2][1] * Card.NUM_RANKS;
  1157. ident += ID_KickerValue(paired, max_hand - 4, pair_rank[2]);
  1158. } else if (group_size[2] == 1) { // A PAIR
  1159. ident = PAIR * ID_GROUP_SIZE;
  1160. ident += pair_rank[2][0] * Card.NUM_RANKS * Card.NUM_RANKS
  1161. * Card.NUM_RANKS;
  1162. ident += ID_KickerValue(paired, max_hand - 2, pair_rank[2]);
  1163. } else { // A Low
  1164. ident = HIGH * ID_GROUP_SIZE;
  1165. ident += ID_KickerValue(paired, max_hand, pair_rank[2]);
  1166. }
  1167. return ident;
  1168. }
  1169.  
  1170. private static int pow(int n, int p) {
  1171. int res = 1;
  1172. while (p-- > 0)
  1173. res *= n;
  1174. return res;
  1175. }
  1176.  
  1177. private static final String[] hand_name = { "HIGH", "PAIR", "TWO PAIR",
  1178. "THREE KIND", "STRAIGHT", "FLUSH", "FULL HOUSE", "FOUR KIND",
  1179. "STRAIGHT FLUSH", "FIVE KIND" };
  1180.  
  1181. private static final String[] rank_name = { "Two", "Three", "Four", "Five",
  1182. "Six", "Seven", "Eight", "Nine", "Ten", "Jack", "Queen", "King", "Ace" };
  1183.  
  1184. /**
  1185. * Return a string naming the hand
  1186. *
  1187. * @param rank
  1188. * calculated by rankHand_java()
  1189. */
  1190. private static String name_hand(int rank) {
  1191.  
  1192. int type = (int) (rank / ID_GROUP_SIZE);
  1193. int ident = (int) (rank % ID_GROUP_SIZE), ident2;
  1194.  
  1195. String t = new String();
  1196.  
  1197. switch (type) {
  1198. case HIGH:
  1199. ident /= NUM_RANKS * NUM_RANKS * NUM_RANKS * NUM_RANKS;
  1200. t = rank_name[ident] + " High";
  1201. break;
  1202. case FLUSH:
  1203. ident /= NUM_RANKS * NUM_RANKS * NUM_RANKS * NUM_RANKS;
  1204. t = "a Flush, " + rank_name[ident] + " High";
  1205. break;
  1206. case PAIR:
  1207. ident /= NUM_RANKS * NUM_RANKS * NUM_RANKS;
  1208. t = "a Pair of " + rank_name[ident] + "s";
  1209. break;
  1210. case TWOPAIR:
  1211. ident2 = ident / (NUM_RANKS * NUM_RANKS);
  1212. ident = (ident % (NUM_RANKS * NUM_RANKS)) / NUM_RANKS;
  1213. t = "Two Pair, " + rank_name[ident2] + "s and " + rank_name[ident]
  1214. + "s";
  1215. break;
  1216. case THREEKIND:
  1217. t = "Three of a Kind, " + rank_name[ident / (NUM_RANKS * NUM_RANKS)]
  1218. + "s";
  1219. break;
  1220. case FULLHOUSE:
  1221. t = "a Full House, " + rank_name[ident / NUM_RANKS] + "s over "
  1222. + rank_name[ident % NUM_RANKS] + "s";
  1223. break;
  1224. case FOURKIND:
  1225. t = "Four of a Kind, " + rank_name[ident / NUM_RANKS] + "s";
  1226. break;
  1227. case STRAIGHT:
  1228. t = "a " + rank_name[ident] + " High Straight";
  1229. break;
  1230. case STRAIGHTFLUSH:
  1231. t = "a " + rank_name[ident] + " High Straight Flush";
  1232. break;
  1233. case FIVEKIND:
  1234. t = "Five of a Kind, " + rank_name[ident] + "s";
  1235. break;
  1236. default:
  1237. t = hand_name[type];
  1238. }
  1239.  
  1240. return t;
  1241. }
  1242.  
  1243.  
  1244.  
  1245. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!