combination.cpp

   1 /*
   2 OOPoker
   3
   4 Copyright (c) 2010 Lode Vandevenne
   5 All rights reserved.
   6
   7 This file is part of OOPoker.
   8
   9 OOPoker is free software: you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation, either version 3 of the License, or
  12 (at your option) any later version.
  13
  14 OOPoker is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with OOPoker.  If not, see <http://www.gnu.org/licenses/>.
  21 */
  22
  23 #include "combination.h"
  24
  25 #include "pokermath.h"
  26
  27 std::string comboTypeToName(ComboType type)
  28 {
  29   switch(type)
  30   {
  31     case C_HIGH_CARD: return "High Card";
  32     case C_PAIR: return "Pair";
  33     case C_TWO_PAIR: return "Two Pair";
  34     case C_THREE_OF_A_KIND: return "Three Of A Kind";
  35     case C_STRAIGHT: return "Straight";
  36     case C_FLUSH: return "Flush";
  37     case C_FULL_HOUSE: return "Full House";
  38     case C_FOUR_OF_A_KIND: return "Four Of A Kind";
  39     case C_STRAIGHT_FLUSH: return "Straight Flush";
  40     //case ROYAL_FLUSH: return "Royal Flush";
  41   }
  42
  43   return "Unknown";
  44 }
  45
  46 std::string Combination::getName() const
  47 {
  48   if(cards_used == 0) return "Nothing";
  49   std::string result = comboTypeToName(type);
  50   if(type == C_STRAIGHT_FLUSH && cards[0].value == 14) result = "Royal Flush";
  51   return result;
  52 }
  53
  54 std::string Combination::getNameWithAllCards() const
  55 {
  56   std::string result = getName();
  57   result += " (";
  58   for(int i = 0; i < cards_used; i++) result = result + " " + cards[i].getShortName();
  59   result += " )";
  60   return result;
  61 }
  62
  63 std::string Combination::getNameWithAllCardsPrintable() const
  64 {
  65   std::string result = getName();
  66   result += " (";
  67   for(int i = 0; i < cards_used; i++) result = result + " " + cards[i].getShortNamePrintable();
  68   result += " )";
  69   return result;
  70 }
  71
  72 ////////////////////////////////////////////////////////////////////////////////
  73 ////////////////////////////////////////////////////////////////////////////////
  74 ////////////////////////////////////////////////////////////////////////////////
  75 ////////////////////////////////////////////////////////////////////////////////
  76 ////////////////////////////////////////////////////////////////////////////////
  77 ////////////////////////////////////////////////////////////////////////////////
  78 ////////////////////////////////////////////////////////////////////////////////
  79 ////////////////////////////////////////////////////////////////////////////////
  80
  81
  82 //returns amount of pairs in cards, sorted from highest to lowest
  83 void getPairs(std::vector<int>& values, const std::vector<Card>& sorted)
  84 {
  85   std::vector<int> vals(sorted.size());
  86   for(size_t i = 0; i < sorted.size(); i++) vals[i] = sorted[i].getValue();
  87
  88   for(size_t i = 0; i < vals.size(); i++)
  89   {
  90     size_t j = i + 1;
  91     while(j < vals.size() && vals[j] == vals[i]) j++;
  92
  93     if(j == i + 2) values.push_back(vals[i]);
  94
  95     i = j - 1;
  96   }
  97 }
  98
  99 void getThreeOfKinds(std::vector<int>& values, const std::vector<Card>& cards)
 100 {
 101   std::vector<int> vals(cards.size());
 102   for(size_t i = 0; i < cards.size(); i++) vals[i] = cards[i].getValue();
 103   std::sort(vals.begin(), vals.end(), std::greater<int>());
 104
 105   for(size_t i = 0; i < vals.size(); i++)
 106   {
 107     size_t j = i + 1;
 108     while(j < vals.size() && vals[j] == vals[i]) j++;
 109
 110     if(j == i + 3) values.push_back(vals[i]);
 111
 112     i = j - 1;
 113   }
 114 }
 115
 116 void getFourOfKinds(std::vector<int>& values, const std::vector<Card>& cards)
 117 {
 118   std::vector<int> vals(cards.size());
 119   for(size_t i = 0; i < cards.size(); i++) vals[i] = cards[i].getValue();
 120   std::sort(vals.begin(), vals.end(), std::greater<int>());
 121
 122   for(size_t i = 0; i < vals.size(); i++)
 123   {
 124     size_t j = i + 1;
 125     while(j < vals.size() && vals[j] == vals[i]) j++;
 126
 127     if(j == i + 4) values.push_back(vals[i]);
 128
 129     i = j - 1;
 130   }
 131 }
 132
 133 //returns 0 if no straight, value of highest straight found if one is found. A value of "14" is ace is the highest, and the lowest possible is "5" (which represents 1-2-3-4-5)
 134 //this returns a straight if it's a straight flush also. Test straight flush seperately!
 135 int getStraight(const std::vector<Card>& cards)
 136 {
 137   if(cards.size() < 5) return 0;
 138
 139   std::vector<int> vals(cards.size());
 140   for(size_t i = 0; i < cards.size(); i++) vals[i] = cards[i].getValue();
 141   std::sort(vals.begin(), vals.end(), std::greater<int>());
 142   if(vals[0] == 14) vals.push_back(1); //this is so that a 1-to-5 straight is also detected
 143
 144   int num = 0;
 145   int last = -1;
 146
 147   for(size_t i = 0; i < vals.size(); i++)
 148   {
 149     if(last == -1) { last = vals[i]; num = 1; continue; }
 150
 151     if(vals[i] == last - 1)
 152     {
 153       num++;
 154     }
 155     else if(vals[i] < last - 1)
 156     {
 157       num = 1;
 158     }
 159     else //if vals[i] == last
 160     {
 161       //nothing to do
 162     }
 163     if(num == 5) return vals[i] + 4;
 164
 165     last = vals[i];
 166   }
 167
 168   return 0;
 169 }
 170
 171
 172 //returns highest card of the straight flush.
 173 //Also used for royal flush. If it returns an ace, it's a royal flush.
 174 Card getStraightFlush(const std::vector<Card>& cards)
 175 {
 176   //split in the 4 suits
 177   std::vector<Card> spades;
 178   std::vector<Card> diamonds;
 179   std::vector<Card> hearts;
 180   std::vector<Card> clubs;
 181
 182   splitIntoSuits(spades, diamonds, hearts, clubs, cards);
 183
 184   int straightSpades = getStraight(spades);
 185   int straightDiamonds = getStraight(diamonds);
 186   int straightHearts = getStraight(hearts);
 187   int straightClubs = getStraight(clubs);
 188
 189   if(straightSpades > straightDiamonds && straightSpades > straightHearts && straightSpades > straightClubs)
 190   {
 191     return Card(straightSpades, S_SPADES);
 192   }
 193   if(straightDiamonds > straightHearts && straightDiamonds > straightClubs)
 194   {
 195     return Card(straightDiamonds, S_DIAMONDS);
 196   }
 197   if(straightHearts > straightClubs)
 198   {
 199     return Card(straightHearts, S_HEARTS);
 200   }
 201   if(straightClubs > 0)
 202   {
 203     return Card(straightClubs, S_CLUBS);
 204   }
 205   return Card(-1, S_UNKNOWN);
 206 }
 207
 208 //returns highest card of the flush.
 209 Card getFlush(const std::vector<Card>& cards)
 210 {
 211   //split in the 4 suits
 212   std::vector<Card> spades;
 213   std::vector<Card> diamonds;
 214   std::vector<Card> hearts;
 215   std::vector<Card> clubs;
 216
 217   splitIntoSuits(spades, diamonds, hearts, clubs, cards);
 218
 219   int s = spades.size() < 5 ? 0 : spades[0].value;
 220   int d = diamonds.size() < 5 ? 0 : diamonds[0].value;
 221   int h = hearts.size() < 5 ? 0 : hearts[0].value;
 222   int c = clubs.size() < 5 ? 0 : clubs[0].value;
 223
 224   if(s > d && s > h && s > c)
 225   {
 226     return Card(s, S_SPADES);
 227   }
 228   if(d > h && d > c)
 229   {
 230     return Card(d, S_DIAMONDS);
 231   }
 232   if(h > c)
 233   {
 234     return Card(h, S_HEARTS);
 235   }
 236   if(c > 0)
 237   {
 238     return Card(c, S_CLUBS);
 239   }
 240   return Card(-1, S_UNKNOWN);
 241 }
 242
 243 ////////////////////////////////////////////////////////////////////////////////
 244 ////////////////////////////////////////////////////////////////////////////////
 245 ////////////////////////////////////////////////////////////////////////////////
 246 ////////////////////////////////////////////////////////////////////////////////
 247 ////////////////////////////////////////////////////////////////////////////////
 248 ////////////////////////////////////////////////////////////////////////////////
 249 ////////////////////////////////////////////////////////////////////////////////
 250 ////////////////////////////////////////////////////////////////////////////////
 251
 252 //only call after having checked all combinations
 253 bool checkHighCard(Card result[5], const std::vector<Card>& sorted)
 254 {
 255   if(sorted.size() < 1) return false;
 256
 257   for(size_t i = 0; i < sorted.size() && i < 5; i++)
 258   {
 259     result[i] = sorted[i];
 260   }
 261
 262   return true;
 263 }
 264
 265
 266 //only call after already having checked for better combinations (including two pairs, three of a kind, or other things that already contain a pair in them too)
 267 bool checkPair(Card result[5], const std::vector<Card>& sorted)
 268 {
 269   if(sorted.size() < 2) return false;
 270
 271   std::vector<int> values;
 272   getPairs(values, sorted);
 273
 274   if(values.empty()) return false;
 275
 276   //values.size is 1 because higher combinations were already checked earlier
 277   for(size_t i = 0; i + 1 < sorted.size(); i++)
 278   {
 279     if(sorted[i].value == values[0])
 280     {
 281       result[0] = sorted[i];
 282       result[1] = sorted[i + 1];
 283       break;
 284     }
 285   }
 286
 287   int c = 2;
 288   for(size_t i = 0; i < sorted.size() && c < 5; i++)
 289   {
 290     if(sorted[i].value != values[0])
 291     {
 292       result[c] = sorted[i];
 293       c++;
 294     }
 295   }
 296
 297   return true;
 298 }
 299
 300 //only call after already having checked for better combinations
 301 bool checkTwoPair(Card result[5], const std::vector<Card>& sorted)
 302 {
 303   if(sorted.size() < 4) return false;
 304
 305   std::vector<int> values;
 306   getPairs(values, sorted);
 307
 308   if(values.size() < 2) return false;
 309
 310   for(size_t i = 0; i + 1 < sorted.size(); i++)
 311   {
 312     if(sorted[i].value == values[0])
 313     {
 314       result[0] = sorted[i];
 315       result[1] = sorted[i + 1];
 316       break;
 317     }
 318   }
 319
 320   for(size_t i = 0; i + 1 < sorted.size(); i++)
 321   {
 322     if(sorted[i].value == values[1])
 323     {
 324       result[2] = sorted[i];
 325       result[3] = sorted[i + 1];
 326       break;
 327     }
 328   }
 329
 330   int c = 4;
 331   for(size_t i = 0; i < sorted.size() && c < 5; i++)
 332   {
 333     if(sorted[i].value != values[0] && sorted[i].value != values[1])
 334     {
 335       result[c] = sorted[i];
 336       c++;
 337     }
 338   }
 339
 340   return true;
 341 }
 342
 343 //only call after already having checked for better combinations (including full house, four of a kind, or other things that already contain a pair in them too)
 344 bool checkThreeOfAKind(Card result[5], const std::vector<Card>& sorted)
 345 {
 346   if(sorted.size() < 3) return false;
 347
 348   std::vector<int> values;
 349   getThreeOfKinds(values, sorted);
 350
 351   if(values.empty()) return false;
 352
 353   //values.size is 1 because higher combinations were already checked earlier
 354   for(size_t i = 0; i + 2 < sorted.size(); i++)
 355   {
 356     if(sorted[i].value == values[0])
 357     {
 358       result[0] = sorted[i];
 359       result[1] = sorted[i + 1];
 360       result[2] = sorted[i + 2];
 361       break;
 362     }
 363   }
 364
 365   int c = 3;
 366   for(size_t i = 0; i < sorted.size() && c < 5; i++)
 367   {
 368     if(sorted[i].value != values[0])
 369     {
 370       result[c] = sorted[i];
 371       c++;
 372     }
 373   }
 374
 375   return true;
 376 }
 377
 378 //only call after already having checked for better combinations
 379 bool checkFullHouse(Card result[5], const std::vector<Card>& sorted)
 380 {
 381   if(sorted.size() < 5) return false;
 382
 383   std::vector<int> two;
 384   getPairs(two, sorted);
 385   std::vector<int> three;
 386   getThreeOfKinds(three, sorted);
 387
 388   if(two.empty() || three.empty()) return false;
 389
 390   for(size_t i = 0; i + 2 < sorted.size(); i++)
 391   {
 392     if(sorted[i].value == three[0])
 393     {
 394       result[0] = sorted[i];
 395       result[1] = sorted[i + 1];
 396       result[2] = sorted[i + 2];
 397       break;
 398     }
 399   }
 400
 401   for(size_t i = 0; i + 1 < sorted.size(); i++)
 402   {
 403     if(sorted[i].value == two[0])
 404     {
 405       result[3] = sorted[i];
 406       result[4] = sorted[i + 1];
 407       break;
 408     }
 409   }
 410
 411   return true;
 412 }
 413
 414 //only call after already having checked for better combinations
 415 bool checkFourOfAKind(Card result[5], const std::vector<Card>& sorted)
 416 {
 417   if(sorted.size() < 4) return false;
 418
 419   std::vector<int> values;
 420   getFourOfKinds(values, sorted);
 421
 422   if(values.empty()) return false;
 423
 424   for(size_t i = 0; i + 3 < sorted.size(); i++)
 425   {
 426     if(sorted[i].value == values[0])
 427     {
 428       result[0] = sorted[i];
 429       result[1] = sorted[i + 1];
 430       result[2] = sorted[i + 2];
 431       result[3] = sorted[i + 3];
 432       break;
 433     }
 434   }
 435
 436   int c = 4;
 437   for(size_t i = 0; i < sorted.size() && c < 5; i++)
 438   {
 439     if(sorted[i].value != values[0])
 440     {
 441       result[c] = sorted[i];
 442       c++;
 443     }
 444   }
 445
 446   return true;
 447 }
 448
 449 //only call after already having checked for better combinations
 450 bool checkStraight(Card result[5], const std::vector<Card>& sorted)
 451 {
 452   if(sorted.size() < 5) return false;
 453
 454   int s = getStraight(sorted);
 455
 456   if(s == 0) return false;
 457
 458   for(size_t i = 0; i < 5; i++) result[0] = Card(); //set to unknown cards, for checks below
 459
 460   for(size_t i = 0; i < sorted.size(); i++)
 461   {
 462     if(sorted[i].value == s - 0 && !result[0].isValid()) result[0] = sorted[i];
 463     if(sorted[i].value == s - 1 && !result[1].isValid()) result[1] = sorted[i];
 464     if(sorted[i].value == s - 2 && !result[2].isValid()) result[2] = sorted[i];
 465     if(sorted[i].value == s - 3 && !result[3].isValid()) result[3] = sorted[i];
 466     if(sorted[i].value == s - 4 && !result[4].isValid()) result[4] = sorted[i];
 467   }
 468
 469   if(s == 5) result[4] = sorted[0]; // The ace as value 1
 470
 471   return true;
 472 }
 473
 474 //only call after already having checked for better combinations
 475 bool checkStraightFlush(Card result[5], const std::vector<Card>& sorted)
 476 {
 477   if(sorted.size() < 5) return false;
 478
 479   Card c = getStraightFlush(sorted);
 480
 481   if(!c.isValid()) return false;
 482
 483   size_t j = 0;
 484   for(size_t i = 0; i < sorted.size() && j < 5; i++)
 485   {
 486     if(sorted[i].value + j == (size_t)c.value && sorted[i].suit == c.suit)
 487     {
 488       result[j] = sorted[i];
 489       j++;
 490     }
 491   }
 492
 493   if(c.getValue() == 5) result[4] = Card(14, c.getSuit()); // The ace as value 1
 494
 495   return true;
 496 }
 497
 498 //only call after already having checked for better combinations
 499 bool checkFlush(Card result[5], const std::vector<Card>& sorted)
 500 {
 501   if(sorted.size() < 5) return false;
 502
 503   Card c = getFlush(sorted);
 504
 505   if(!c.isValid()) return false;
 506
 507   size_t j = 0;
 508   for(size_t i = 0; i < sorted.size() && j < 5; i++)
 509   {
 510     if(sorted[i].suit == c.suit)
 511     {
 512       result[j] = sorted[i];
 513       j++;
 514     }
 515   }
 516
 517   return true;
 518 }
 519
 520 ////////////////////////////////////////////////////////////////////////////////
 521 ////////////////////////////////////////////////////////////////////////////////
 522 ////////////////////////////////////////////////////////////////////////////////
 523 ////////////////////////////////////////////////////////////////////////////////
 524 ////////////////////////////////////////////////////////////////////////////////
 525 ////////////////////////////////////////////////////////////////////////////////
 526 ////////////////////////////////////////////////////////////////////////////////
 527 ////////////////////////////////////////////////////////////////////////////////
 528
 529
 530 //only call after already having checked for better combinations (including two pairs, three of a kind, or other things that already contain a pair in them too)
 531 bool checkPair(const std::vector<Card>& sorted)
 532 {
 533   if(sorted.size() < 2) return false;
 534
 535   std::vector<int> values;
 536   getPairs(values, sorted);
 537
 538   if(values.empty()) return false;
 539
 540   return true;
 541 }
 542
 543 //only call after already having checked for better combinations
 544 bool checkTwoPair(const std::vector<Card>& sorted)
 545 {
 546   if(sorted.size() < 4) return false;
 547
 548   std::vector<int> values;
 549   getPairs(values, sorted);
 550
 551   if(values.size() < 2) return false;
 552
 553   return true;
 554 }
 555
 556 //only call after already having checked for better combinations (including full house, four of a kind, or other things that already contain a pair in them too)
 557 bool checkThreeOfAKind(const std::vector<Card>& sorted)
 558 {
 559   if(sorted.size() < 3) return false;
 560
 561   std::vector<int> values;
 562   getThreeOfKinds(values, sorted);
 563
 564   if(values.empty()) return false;
 565
 566   return true;
 567 }
 568
 569 //only call after already having checked for better combinations
 570 bool checkFullHouse(const std::vector<Card>& sorted)
 571 {
 572   if(sorted.size() < 5) return false;
 573
 574   std::vector<int> two;
 575   getPairs(two, sorted);
 576   std::vector<int> three;
 577   getThreeOfKinds(three, sorted);
 578
 579   if(two.empty() || three.empty()) return false;
 580
 581   return true;
 582 }
 583
 584 //only call after already having checked for better combinations
 585 bool checkFourOfAKind(const std::vector<Card>& sorted)
 586 {
 587   if(sorted.size() < 4) return false;
 588
 589   std::vector<int> values;
 590   getFourOfKinds(values, sorted);
 591
 592   if(values.empty()) return false;
 593
 594   return true;
 595 }
 596
 597 //only call after already having checked for better combinations
 598 bool checkStraight(const std::vector<Card>& sorted)
 599 {
 600   if(sorted.size() < 5) return false;
 601
 602   int s = getStraight(sorted);
 603
 604   if(s == 0) return false;
 605   return true;
 606 }
 607
 608 //only call after already having checked for better combinations
 609 bool checkStraightFlush(const std::vector<Card>& sorted)
 610 {
 611   if(sorted.size() < 5) return false;
 612
 613   Card c = getStraightFlush(sorted);
 614
 615   if(!c.isValid()) return false;
 616   return true;
 617 }
 618
 619 //only call after already having checked for better combinations
 620 bool checkFlush(const std::vector<Card>& sorted)
 621 {
 622   if(sorted.size() < 5) return false;
 623
 624   Card c = getFlush(sorted);
 625
 626   if(!c.isValid()) return false;
 627   return true;
 628 }
 629
 630 ////////////////////////////////////////////////////////////////////////////////
 631 ////////////////////////////////////////////////////////////////////////////////
 632 ////////////////////////////////////////////////////////////////////////////////
 633 ////////////////////////////////////////////////////////////////////////////////
 634 ////////////////////////////////////////////////////////////////////////////////
 635 ////////////////////////////////////////////////////////////////////////////////
 636 ////////////////////////////////////////////////////////////////////////////////
 637 ////////////////////////////////////////////////////////////////////////////////
 638
 639 void sortCardsHighToLow(std::vector<Card>& cards)
 640 {
 641   std::sort(cards.begin(), cards.end(), cardGreater);
 642 }
 643
 644 /*
 645 Returns the best combo formed by the given cards.
 646 */
 647 void getCombo(Combination& combo, const std::vector<Card>& cards)
 648 {
 649   std::vector<Card> sorted = cards;
 650   sortCardsHighToLow(sorted);
 651
 652   if(cards.size() < 5) combo.cards_used = cards.size();
 653   else combo.cards_used = 5;
 654
 655   if(checkStraightFlush(combo.cards, sorted))
 656   {
 657     combo.type = C_STRAIGHT_FLUSH;
 658     return;
 659   }
 660
 661   if(checkFourOfAKind(combo.cards, sorted))
 662   {
 663     combo.type = C_FOUR_OF_A_KIND;
 664     return;
 665   }
 666
 667   if(checkFullHouse(combo.cards, sorted))
 668   {
 669     combo.type = C_FULL_HOUSE;
 670     return;
 671   }
 672
 673   if(checkFlush(combo.cards, sorted))
 674   {
 675     combo.type = C_FLUSH;
 676     return;
 677   }
 678
 679   if(checkStraight(combo.cards, sorted))
 680   {
 681     combo.type = C_STRAIGHT;
 682     return;
 683   }
 684
 685   if(checkThreeOfAKind(combo.cards, sorted))
 686   {
 687     combo.type = C_THREE_OF_A_KIND;
 688     return;
 689   }
 690
 691   if(checkTwoPair(combo.cards, sorted))
 692   {
 693     combo.type = C_TWO_PAIR;
 694     return;
 695   }
 696
 697   if(checkPair(combo.cards, sorted))
 698   {
 699     combo.type = C_PAIR;
 700     return;
 701   }
 702
 703   if(checkHighCard(combo.cards, sorted))
 704   {
 705     combo.type = C_HIGH_CARD;
 706     return;
 707   }
 708 }
 709
 710 //2 cards given by short names
 711 void getCombo(Combination& combo
 712             , const std::string& card1
 713             , const std::string& card2)
 714 {
 715   std::vector<Card> cards;
 716   cards.push_back(Card(card1));
 717   cards.push_back(Card(card2));
 718   getCombo(combo, cards);
 719 }
 720
 721 //3 cards given by short names
 722 void getCombo(Combination& combo
 723             , const std::string& card1
 724             , const std::string& card2
 725             , const std::string& card3)
 726 {
 727   std::vector<Card> cards;
 728   cards.push_back(Card(card1));
 729   cards.push_back(Card(card2));
 730   cards.push_back(Card(card3));
 731   getCombo(combo, cards);
 732 }
 733
 734 //4 cards given by short names
 735 void getCombo(Combination& combo
 736             , const std::string& card1
 737             , const std::string& card2
 738             , const std::string& card3
 739             , const std::string& card4)
 740 {
 741   std::vector<Card> cards;
 742   cards.push_back(Card(card1));
 743   cards.push_back(Card(card2));
 744   cards.push_back(Card(card3));
 745   cards.push_back(Card(card4));
 746   getCombo(combo, cards);
 747 }
 748
 749 //5 cards given by short names
 750 void getCombo(Combination& combo
 751             , const std::string& card1
 752             , const std::string& card2
 753             , const std::string& card3
 754             , const std::string& card4
 755             , const std::string& card5)
 756 {
 757   std::vector<Card> cards;
 758   cards.push_back(Card(card1));
 759   cards.push_back(Card(card2));
 760   cards.push_back(Card(card3));
 761   cards.push_back(Card(card4));
 762   cards.push_back(Card(card5));
 763   getCombo(combo, cards);
 764 }
 765
 766 //6 cards given by short names
 767 void getCombo(Combination& combo
 768             , const std::string& card1
 769             , const std::string& card2
 770             , const std::string& card3
 771             , const std::string& card4
 772             , const std::string& card5
 773             , const std::string& card6)
 774 {
 775   std::vector<Card> cards;
 776   cards.push_back(Card(card1));
 777   cards.push_back(Card(card2));
 778   cards.push_back(Card(card3));
 779   cards.push_back(Card(card4));
 780   cards.push_back(Card(card5));
 781   cards.push_back(Card(card6));
 782   getCombo(combo, cards);
 783 }
 784
 785 //7 cards given by short names
 786 void getCombo(Combination& combo
 787             , const std::string& card1
 788             , const std::string& card2
 789             , const std::string& card3
 790             , const std::string& card4
 791             , const std::string& card5
 792             , const std::string& card6
 793             , const std::string& card7)
 794 {
 795   std::vector<Card> cards;
 796   cards.push_back(Card(card1));
 797   cards.push_back(Card(card2));
 798   cards.push_back(Card(card3));
 799   cards.push_back(Card(card4));
 800   cards.push_back(Card(card5));
 801   cards.push_back(Card(card6));
 802   cards.push_back(Card(card7));
 803   getCombo(combo, cards);
 804 }
 805
 806 void getCombo(Combination& combo, const std::string& cards)
 807 {
 808   std::vector<Card> cards2;
 809   for(size_t i = 0; i + 1 < cards.size(); i += 2)
 810   {
 811     cards2.push_back(Card(cards.substr(i, 2)));
 812   }
 813   getCombo(combo, cards2);
 814 }
 815
 816 void getCombo(Combination& combo, const Card& card1, const Card& card2, const Card& card3, const Card& card4, const Card& card5)
 817 {
 818   std::vector<Card> cards;
 819   cards.push_back(card1);
 820   cards.push_back(card2);
 821   cards.push_back(card3);
 822   cards.push_back(card4);
 823   cards.push_back(card5);
 824   getCombo(combo, cards);
 825 }
 826
 827 int compare(const Combination& a, const Combination& b)
 828 {
 829   if((int)a.type > (int)(b.type)) return +1;
 830   if((int)a.type < (int)(b.type)) return -1;
 831
 832   int num_cards = std::min(a.cards_used, b.cards_used);
 833
 834   for(int i = 0; i < num_cards; i++)
 835   {
 836     if(a.cards[i].value > b.cards[i].value) return +1;
 837     if(a.cards[i].value < b.cards[i].value) return -1;
 838   }
 839
 840   return 0;
 841 }
 842
 843 bool combinationGreater(const Combination& a, const Combination& b)
 844 {
 845   return compare(a, b) == 1;
 846 }
 847
 848