void CSymbolEngineLists::CalculateLists() { unsigned int card0, card1; if (StdDeck_RANK(p_scraper->card_player(USER_CHAIR, 0)) >= StdDeck_RANK(p_scraper->card_player(USER_CHAIR, 1))) { card0 = p_scraper->card_player(USER_CHAIR, 0); card1 = p_scraper->card_player(USER_CHAIR, 1); } else { card0 = p_scraper->card_player(USER_CHAIR, 1); card1 = p_scraper->card_player(USER_CHAIR, 0); } int number_of_lists = p_formula->formula()->mHandList.GetSize(); for (int i=0; i<number_of_lists; i++) { int listnum = atoi(p_formula->formula()->mHandList[i].list.Mid(4).GetString()); if ((StdDeck_SUIT(card0)==StdDeck_SUIT(card1) && p_formula->formula()->inlist[listnum][StdDeck_RANK(card0)][StdDeck_RANK(card1)]) || (StdDeck_SUIT(card0)!=StdDeck_SUIT(card1) && p_formula->formula()->inlist[listnum][StdDeck_RANK(card1)][StdDeck_RANK(card0)])) { SetIsList(listnum, true); // islistxx } else { SetIsList(listnum, false); } } }
int StdDeck_cardToString(int cardIndex, char *outString) { *outString++ = StdDeck_rankChars[StdDeck_RANK(cardIndex)]; *outString++ = StdDeck_suitChars[StdDeck_SUIT(cardIndex)]; *outString = '\0'; return 2; }
// Convert our member variable card (poker-eval format) to our own Card class Card Hand::ConvertPokerEvalCardToCard(int card) const { int rank, suit; // We must convert the poker-eval format (16-bit) // (rank*4)+suit // // to our hand from our format (8-bit): // | 7 6 5 4 3 2 1 0 | // | rank | suit | // rank = StdDeck_RANK(card)+2; suit = StdDeck_SUIT(card) == StdDeck_Suit_CLUBS ? Card::CLUBS : StdDeck_SUIT(card) == StdDeck_Suit_DIAMONDS ? Card::DIAMONDS : StdDeck_SUIT(card) == StdDeck_Suit_HEARTS ? Card::HEARTS : StdDeck_SUIT(card) == StdDeck_Suit_SPADES ? Card::SPADES : 0; return (Card(rank, suit)); }
void CRank169To1326Utility::Generate169(const int c1, const int c2, char* buffer) { const char* rankChars = "23456789TJQKA"; memset(buffer, '\0', 4); int rank_card1 = StdDeck_RANK(c1); int suit_card1 = StdDeck_SUIT(c1); int rank_card2 = StdDeck_RANK(c2); int suit_card2 = StdDeck_SUIT(c2); char str_rank1 = rankChars[rank_card1]; char str_rank2 = rankChars[rank_card2]; char suited = ((suit_card1 == suit_card2) ? 's' : 'o'); if(rank_card1 > rank_card2) sprintf_s(buffer, 4, "%c%c%c", str_rank1, str_rank2, suited); else sprintf_s(buffer, 4, "%c%c%c", str_rank2, str_rank1, suited); }
static void doCardMaskTable(void) { StdDeck_CardMask c; int i; MakeTable_begin("StdDeck_cardMasksTable", CM_FILENAME, "StdDeck_CardMask", StdDeck_N_CARDS); MakeTable_comment(CM_COMMENT_STRING); for (i=0; i<StdDeck_N_CARDS; i++) { int suit = StdDeck_SUIT(i); int rank = StdDeck_RANK(i); StdDeck_CardMask_RESET(c); if (suit == StdDeck_Suit_HEARTS) c.cards.hearts = (1 << rank); else if (suit == StdDeck_Suit_DIAMONDS) c.cards.diamonds = (1 << rank); else if (suit == StdDeck_Suit_CLUBS) c.cards.clubs = (1 << rank); else if (suit == StdDeck_Suit_SPADES) c.cards.spades = (1 << rank); #ifdef HAVE_INT64 MakeTable_outputUInt64(c.cards_n); #else { char buf[80]; sprintf(buf, " { { 0x%08x, 0x%08x } } ", c.cards_nn.n1, c.cards_nn.n2); MakeTable_outputString(buf); }; #endif }; MakeTable_end(); }
void CGameState::CaptureState() { bool playing = true; unsigned char card = CARD_NOCARD; // figure out if I am playing int sym_chair = p_symbol_engine_userchair->userchair(); if (!p_symbol_engine_userchair->userchair_confirmed()) { playing = false; } else if (p_scraper->card_player(sym_chair, 0) == CARD_BACK || p_scraper->card_player(sym_chair, 1) == CARD_BACK || p_scraper->card_player(sym_chair, 0) == CARD_NOCARD || p_scraper->card_player(sym_chair, 1) == CARD_NOCARD) { playing = false; } // Poker window title char title[MAX_WINDOW_TITLE]; GetWindowText(p_autoconnector->attached_hwnd(), title, MAX_WINDOW_TITLE); strncpy_s(_state[_state_index&0xff].m_title, 64, title, _TRUNCATE); _state[_state_index&0xff].m_title[63] = '\0'; // Pot information for (int i=0; i<k_max_number_of_players; i++) _state[_state_index&0xff].m_pot[i] = p_scraper->pot(i); // Common cards for (int i=0; i<k_number_of_community_cards; i++) { if (p_scraper->card_common(i) == CARD_BACK) { card = WH_CARDBACK; } else if (p_scraper->card_common(i) == CARD_NOCARD) { card = WH_NOCARD; } else { card = ((StdDeck_RANK(p_scraper->card_common(i))+2)<<4) | (StdDeck_SUIT(p_scraper->card_common(i)) == StdDeck_Suit_CLUBS ? WH_SUIT_CLUBS : StdDeck_SUIT(p_scraper->card_common(i)) == StdDeck_Suit_DIAMONDS ? WH_SUIT_DIAMONDS : StdDeck_SUIT(p_scraper->card_common(i)) == StdDeck_Suit_HEARTS ? WH_SUIT_HEARTS : StdDeck_SUIT(p_scraper->card_common(i)) == StdDeck_Suit_SPADES ? WH_SUIT_SPADES : 0) ; } _state[_state_index&0xff].m_cards[i] = card; } // playing, posting, dealerchair int sym_dealerchair = p_symbol_engine_dealerchair->dealerchair(); bool sym_isautopost = p_symbol_engine_autoplayer->isautopost(); _state[_state_index&0xff].m_is_playing = playing; _state[_state_index&0xff].m_is_posting = sym_isautopost; _state[_state_index&0xff].m_fillerbits = 0; _state[_state_index&0xff].m_fillerbyte = 0; _state[_state_index&0xff].m_dealer_chair = sym_dealerchair; // loop through all 10 player chairs for (int i=0; i<k_max_number_of_players; i++) { // player name, balance, currentbet strncpy_s(_state[_state_index&0xff].m_player[i].m_name, 16, p_scraper->player_name(i).GetString(), _TRUNCATE); _state[_state_index&0xff].m_player[i].m_balance = p_symbol_engine_chip_amounts->balance(i); _state[_state_index&0xff].m_player[i].m_currentbet = p_symbol_engine_chip_amounts->currentbet(i); // player cards for (int j=0; j<k_number_of_cards_per_player; j++) { if (p_scraper->card_player(i, j) == CARD_BACK) { card = WH_CARDBACK; } else if (p_scraper->card_player(i, j) == CARD_NOCARD) { card = WH_NOCARD; } else { card = ((StdDeck_RANK(p_scraper->card_player(i, j))+2)<<4) | (StdDeck_SUIT(p_scraper->card_player(i, j)) == StdDeck_Suit_CLUBS ? WH_SUIT_CLUBS : StdDeck_SUIT(p_scraper->card_player(i, j)) == StdDeck_Suit_DIAMONDS ? WH_SUIT_DIAMONDS : StdDeck_SUIT(p_scraper->card_player(i, j)) == StdDeck_Suit_HEARTS ? WH_SUIT_HEARTS : StdDeck_SUIT(p_scraper->card_player(i, j)) == StdDeck_Suit_SPADES ? WH_SUIT_SPADES : 0) ; } _state[_state_index&0xff].m_player[i].m_cards[j] = card; } // player name known, balance known _state[_state_index&0xff].m_player[i].m_name_known = p_scraper->name_good_scrape(i) ? 1 : 0; _state[_state_index&0xff].m_player[i].m_balance_known = p_scraper->balance_good_scrape(i) ? 1 : 0; _state[_state_index&0xff].m_player[i].m_fillerbits = 0; _state[_state_index&0xff].m_player[i].m_fillerbyte = 0; } _state_index++; }
bool CVersus::GetCounts(void) { if (_versus_fh == k_undefined) return false; int i = 0, j = 0; CardMask plCards, oppCards, deadCards, comCardsScrape, comCardsEnum, comCardsAll, usedCards; unsigned int wintemp = 0, tietemp = 0, lostemp = 0, offset = 0; unsigned int nhiwin = 0, nhitie = 0, nhilos = 0, ntiwin = 0, ntitie = 0, ntilos = 0, nlowin = 0, nlotie = 0, nlolos = 0; unsigned int nhinowwin = 0, nhinowtie = 0, nhinowlos = 0, ntinowwin = 0, ntinowtie = 0, ntinowlos = 0, nlonowwin = 0, nlonowtie = 0, nlonowlos = 0; unsigned int c0rank = 0, c1rank = 0, temprank = 0; BYTE byte[8] = {0}; long pos = 0; int listnum = 0; int card0_offset[52] = { 0, 62475, 123725, 183750, 242550, 300125, 356475, 411600, 465500, 518175, 569625, 619850, 668850, 716625, 763175, 808500, 852600, 895475, 937125, 977550, 1016750, 1054725, 1091475, 1127000, 1161300, 1194375, 1226225, 1256850, 1286250, 1314425, 1341375, 1367100, 1391600, 1414875, 1436925, 1457750, 1477350, 1495725, 1512875, 1528800, 1543500, 1556975, 1569225, 1580250, 1590050, 1598625, 1605975, 1612100, 1617000, 1620675, 1623125, 1624350 }; int betround = p_betround_calculator->betround(); int sym_userchair = (int) p_symbol_engine_userchair->userchair(); unsigned int pcard[2] = {0}; for (i=0; i<=1; i++) pcard[i] = CARD_NOCARD; unsigned int card_player[2] = {0}, card_common[5] = {0}; for (i=0; i<=1; i++) card_player[i] = p_scraper->card_player(sym_userchair, i); for (i=0; i<=4; i++) card_common[i] = p_scraper->card_common(i); // Get the lock CSLock lock(m_critsec); if (!p_symbol_engine_userchair->userchair_confirmed()) return false; if (card_player[0] == CARD_NOCARD || card_player[0] == CARD_BACK || card_player[1] == CARD_NOCARD || card_player[1] == CARD_BACK) { return false; } _nwin = _ntie = _nlos = _nhands = 0; _nhandshi = _nhandsti = _nhandslo = 0; _nhandshinow = _nhandstinow = _nhandslonow = 0; _vsprwinhi = _vsprtiehi = _vsprloshi = 0; _vsprwinti = _vsprtieti = _vsprlosti = 0; _vsprwinlo = _vsprtielo = _vsprloslo = 0; _vsprwinhinow = _vsprtiehinow = _vsprloshinow = 0; _vsprwintinow = _vsprtietinow = _vsprlostinow = 0; _vsprwinlonow = _vsprtielonow = _vsprloslonow = 0; nhiwin = nhitie = nhilos = ntiwin = ntitie = ntilos = nlowin = nlotie = nlolos = 0; // Clear counters for (listnum=0; listnum<MAX_HAND_LISTS; listnum++) _nlistwin[listnum] = _nlisttie[listnum] = _nlistlos[listnum] = 0; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // PREFLOP if (betround == k_betround_preflop) { // order cards properly if (card_player[0] < card_player[1]) { pcard[0] = card_player[0]; pcard[1] = card_player[1]; } else { pcard[0] = card_player[1]; pcard[1] = card_player[0]; } // figure out offset into file offset = 0; //for (i=1; i<pcard[0]; i++) offset += (52-i)*1225; offset += card0_offset[pcard[0]]; offset += (pcard[1]-pcard[0]-1)*1225; offset *= sizeof(byte); // seek to right position in file if ((pos = _lseek(_versus_fh, offset, SEEK_SET)) == long(k_undefined)) { return false; } wintemp = lostemp = 0; for (i=0; i<(k_number_of_cards_per_deck - 1); i++) { for (j=i+1; j<k_number_of_cards_per_deck; j++) { if (i!=pcard[0] && i!=pcard[1] && j!=pcard[0] && j!=pcard[1]) { _read(_versus_fh, &byte, sizeof(byte)); memcpy(&wintemp, &byte[0], sizeof(unsigned int)); memcpy(&lostemp, &byte[4], sizeof(unsigned int)); _nwin += wintemp; _ntie += 1712304 - wintemp - lostemp; _nlos += lostemp; _nhands = _nhands + 1; if (wintemp<lostemp) { _nhandshi = _nhandshi + 1; nhiwin += wintemp; nhitie += 1712304 - wintemp - lostemp; nhilos += lostemp; } else if (wintemp>lostemp) { _nhandslo = _nhandslo + 1; nlowin += wintemp; nlotie += 1712304 - wintemp - lostemp; nlolos += lostemp; } else { _nhandsti = _nhandsti + 1; ntiwin += wintemp; ntitie += 1712304 - wintemp - lostemp; ntilos += lostemp; } // Calculations for vs$xx$prwin, vs$xx$prtie, vs$xx$prlos c0rank = StdDeck_RANK(i); c1rank = StdDeck_RANK(j); if (c0rank < c1rank) { temprank = c0rank; c0rank = c1rank; c1rank = temprank; } for (listnum=0; listnum<MAX_HAND_LISTS; listnum++) { if ((StdDeck_SUIT(i)==StdDeck_SUIT(j) && p_formula->formula()->inlist[listnum][c0rank][c1rank]) || (StdDeck_SUIT(i)!=StdDeck_SUIT(j) && p_formula->formula()->inlist[listnum][c1rank][c0rank])) { _nlistwin[listnum] += wintemp; _nlisttie[listnum] += 1712304 - wintemp - lostemp; _nlistlos[listnum] += lostemp; } } } } } } ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // FLOP, TURN, RIVER else if (betround >= k_betround_flop) { CardMask playerEvalCardsNow, oppEvalCardsNow; HandVal player_hv_now = 0, opp_hv_now = 0; // Common cards CardMask_RESET(comCardsScrape); if (betround >= k_betround_flop) CardMask_SET(comCardsScrape, card_common[0]); if (betround >= k_betround_flop) CardMask_SET(comCardsScrape, card_common[1]); if (betround >= k_betround_flop) CardMask_SET(comCardsScrape, card_common[2]); if (betround >= k_betround_turn) CardMask_SET(comCardsScrape, card_common[3]); if (betround >= k_betround_river) CardMask_SET(comCardsScrape, card_common[4]); // player cards CardMask_RESET(plCards); CardMask_SET(plCards, card_player[0]); CardMask_SET(plCards, card_player[1]); // all used cards CardMask_OR(usedCards, comCardsScrape, plCards); // eval player hand now CardMask_OR(playerEvalCardsNow, plCards, comCardsScrape); player_hv_now = Hand_EVAL_N(playerEvalCardsNow, betround+3); // Enumerate through all possible opponent hands (excludes already used cards) for (i=0; i<=50; i++) { for (j=i+1; j<=51; j++) { if (!CardMask_CARD_IS_SET(usedCards, i) && !CardMask_CARD_IS_SET(usedCards, j)) { CardMask_RESET(oppCards); CardMask_SET(oppCards, i); CardMask_SET(oppCards, j); // Enumerate through all possible river situations (exclude player cards and opponent cards) CardMask_OR(deadCards, usedCards, oppCards); wintemp = tietemp = lostemp = 0; if (betround==k_betround_flop || betround==k_betround_turn) { ENUMERATE_N_CARDS_D(comCardsEnum, betround==k_betround_flop ? 2 : betround==k_betround_turn ? 1 : 0, deadCards, { CardMask_OR(comCardsAll, comCardsScrape, comCardsEnum); DoCalc(plCards, oppCards, comCardsAll, &wintemp, &tietemp, &lostemp); }); }
void COpenHoldemView::DrawCard(const unsigned int card, const int left, const int top, const int right, const int bottom, const bool pl_card) { CPen *pTempPen = NULL, oldpen; CBrush *pTempBrush = NULL, oldbrush; RECT rrect = {0}, srect = {0}; CFont *oldfont = NULL, cFont; CDC *pDC = GetDC(); // Set font basics _logfont.lfHeight = -24; _logfont.lfWeight = FW_BOLD; cFont.CreateFontIndirect(&_logfont); oldfont = pDC->SelectObject(&cFont); // Background color pDC->SetBkColor(COLOR_GRAY); // CARD BACK if (card == CARD_BACK) { pTempPen = (CPen*)pDC->SelectObject(&_black_pen); oldpen.FromHandle((HPEN)pTempPen); // Save old pen pTempBrush = (CBrush*)pDC->SelectObject(&_yellow_brush); oldbrush.FromHandle((HBRUSH)pTempBrush); // Save old brush pDC->SetBkMode(OPAQUE); pDC->RoundRect(left, top, right, bottom, 5, 5); // Restore original pen and brush pDC->SelectObject(oldpen); pDC->SelectObject(oldbrush); } // NO CARD else if (card == CARD_NOCARD) { pTempPen = (CPen*)pDC->SelectObject(&_white_dot_pen); oldpen.FromHandle((HPEN)pTempPen); // Save old pen pTempBrush = (CBrush*)pDC->SelectObject(&_gray_brush); oldbrush.FromHandle((HBRUSH)pTempBrush); // Save old brush pDC->SetBkMode(OPAQUE); pDC->RoundRect(left, top, right, bottom, 5, 5); // Restore original pen and brush pDC->SelectObject(oldpen); pDC->SelectObject(oldbrush); } // NORMAL CARD else { // Rect for rank and suit location rrect.left = left; rrect.top = top; rrect.right = right; rrect.bottom = top + ((bottom-top)/2); srect.left = left; srect.top = top + ((bottom-top)/2) + 1 - (pl_card ? 7 : 0); srect.right = right; srect.bottom = bottom - (pl_card ? 7 : 0); // Draw card rect and suit pTempBrush = (CBrush*)pDC->SelectObject(&_white_brush); oldbrush.FromHandle((HBRUSH)pTempBrush); // Save old brush // Set colors switch (StdDeck_SUIT(card)) { case Suit_CLUBS: pDC->SetTextColor(COLOR_GREEN); pTempPen = (CPen*)pDC->SelectObject(&_green_pen); break; case Suit_DIAMONDS: pDC->SetTextColor(COLOR_BLUE); pTempPen = (CPen*)pDC->SelectObject(&_blue_pen); break; case Suit_HEARTS: pDC->SetTextColor(COLOR_RED); pTempPen = (CPen*)pDC->SelectObject(&_red_pen); break; case Suit_SPADES: pDC->SetTextColor(COLOR_BLACK); pTempPen = (CPen*)pDC->SelectObject(&_black_pen); break; default: pTempPen = (CPen*)pDC->GetCurrentPen(); break; } oldpen.FromHandle((HPEN)pTempPen); // Save old pen // Draw card and suit pDC->SetBkMode(OPAQUE); pDC->RoundRect(left, top, right, bottom, 5, 5); pDC->SetBkMode(TRANSPARENT); switch (StdDeck_SUIT(card)) { case Suit_CLUBS: pDC->DrawText("C", -1, &srect, DT_CENTER | DT_SINGLELINE | DT_VCENTER ); break; case Suit_DIAMONDS: pDC->DrawText("D", -1, &srect, DT_CENTER | DT_SINGLELINE | DT_VCENTER ); break; case Suit_HEARTS: pDC->DrawText("H", -1, &srect, DT_CENTER | DT_SINGLELINE | DT_VCENTER ); break; case Suit_SPADES: pDC->DrawText("S", -1, &srect, DT_CENTER | DT_SINGLELINE | DT_VCENTER ); break; } // Draw card rank switch (StdDeck_RANK(card)) { case Rank_2: pDC->DrawText("2", -1, &rrect, DT_CENTER | DT_SINGLELINE | DT_VCENTER ); break; case Rank_3: pDC->DrawText("3", -1, &rrect, DT_CENTER | DT_SINGLELINE | DT_VCENTER ); break; case Rank_4: pDC->DrawText("4", -1, &rrect, DT_CENTER | DT_SINGLELINE | DT_VCENTER ); break; case Rank_5: pDC->DrawText("5", -1, &rrect, DT_CENTER | DT_SINGLELINE | DT_VCENTER ); break; case Rank_6: pDC->DrawText("6", -1, &rrect, DT_CENTER | DT_SINGLELINE | DT_VCENTER ); break; case Rank_7: pDC->DrawText("7", -1, &rrect, DT_CENTER | DT_SINGLELINE | DT_VCENTER ); break; case Rank_8: pDC->DrawText("8", -1, &rrect, DT_CENTER | DT_SINGLELINE | DT_VCENTER ); break; case Rank_9: pDC->DrawText("9", -1, &rrect, DT_CENTER | DT_SINGLELINE | DT_VCENTER ); break; case Rank_TEN: pDC->DrawText("T", -1, &rrect, DT_CENTER | DT_SINGLELINE | DT_VCENTER ); break; case Rank_JACK: pDC->DrawText("J", -1, &rrect, DT_CENTER | DT_SINGLELINE | DT_VCENTER ); break; case Rank_QUEEN: pDC->DrawText("Q", -1, &rrect, DT_CENTER | DT_SINGLELINE | DT_VCENTER ); break; case Rank_KING: pDC->DrawText("K", -1, &rrect, DT_CENTER | DT_SINGLELINE | DT_VCENTER ); break; case Rank_ACE: pDC->DrawText("A", -1, &rrect, DT_CENTER | DT_SINGLELINE | DT_VCENTER ); break; } // Restore original pen and brush pDC->SelectObject(oldpen); pDC->SelectObject(oldbrush); } pDC->SelectObject(oldfont); cFont.DeleteObject(); ReleaseDC(pDC); }
unsigned int wrap_StdDeck_SUIT(unsigned int index) { return StdDeck_SUIT(index); }
result += "</td></tr>\n"; // Version result += "<tr><td>\n"; result += "OpenHoldem "; result += VERSION_TEXT; result += "</td></tr>\n"; // Finish table result += "</table>\n"; return result; } CString CReplayFrame::GetCardHtml(unsigned int card) { CString suit, color, rank, final; suit = card == CARD_BACK ? "*" : card == CARD_NOCARD ? " " : StdDeck_SUIT(card) == Suit_CLUBS ? "♣" : StdDeck_SUIT(card) == Suit_DIAMONDS ? "♦" : StdDeck_SUIT(card) == Suit_HEARTS ? "♥" : StdDeck_SUIT(card) == Suit_SPADES ? "♠" : " "; color = card == CARD_BACK ? "black" : card == CARD_NOCARD ? "black" : StdDeck_SUIT(card) == Suit_CLUBS ? "green" : StdDeck_SUIT(card) == Suit_DIAMONDS ? "blue" : StdDeck_SUIT(card) == Suit_HEARTS ? "red" : StdDeck_SUIT(card) == Suit_SPADES ? "black" : "black"; rank = card == CARD_BACK ? "*" : card == CARD_NOCARD ? " " : StdDeck_RANK(card) == Rank_ACE ? "A" : StdDeck_RANK(card) == Rank_KING ? "K" :
void CRank169To1326Utility::FillRanges(const int hc1, const int hc2, const int index1326) { // CONTAINS RANKS // hasAces, hasKings, hasQueens, hasTens, hasNines, hasEights, hasSevens, hasSixes, hasFives, hasFours, hasThrees, hasTwos; // Aces if(StdDeck_RANK(hc1) == 12 || StdDeck_RANK(hc2) == 12) hasAces.insert(index1326); // Kings if(StdDeck_RANK(hc1) == 11 || StdDeck_RANK(hc2) == 11) hasKings.insert(index1326); // Queens if(StdDeck_RANK(hc1) == 10 || StdDeck_RANK(hc2) == 10) hasQueens.insert(index1326); // Jacks if(StdDeck_RANK(hc1) == 9 || StdDeck_RANK(hc2) == 9) hasJacks.insert(index1326); // Tens if(StdDeck_RANK(hc1) == 8 || StdDeck_RANK(hc2) == 8) hasTens.insert(index1326); // Nines if(StdDeck_RANK(hc1) == 7 || StdDeck_RANK(hc2) == 7) hasNines.insert(index1326); // Eights if(StdDeck_RANK(hc1) == 6 || StdDeck_RANK(hc2) == 6) hasEights.insert(index1326); // Sevens if(StdDeck_RANK(hc1) == 5 || StdDeck_RANK(hc2) == 5) hasSevens.insert(index1326); // Sixes if(StdDeck_RANK(hc1) == 4 || StdDeck_RANK(hc2) == 4) hasSixes.insert(index1326); // Fives if(StdDeck_RANK(hc1) == 3 || StdDeck_RANK(hc2) == 3) hasFives.insert(index1326); // Fours if(StdDeck_RANK(hc1) == 2 || StdDeck_RANK(hc2) == 2) hasFours.insert(index1326); // Threes if(StdDeck_RANK(hc1) == 1 || StdDeck_RANK(hc2) == 1) hasThrees.insert(index1326); // Twos if(StdDeck_RANK(hc1) == 0 || StdDeck_RANK(hc2) == 0) hasTwos.insert(index1326); // SUITS // hasHearts, hasDiamonds, hasClubs, hasSpades // hearts if(StdDeck_SUIT(hc1) == 0 || StdDeck_SUIT(hc2) == 0) hasHearts.insert(index1326); // diamonds if(StdDeck_SUIT(hc1) == 1|| StdDeck_SUIT(hc2) == 1) hasDiamonds.insert(index1326); // clubs if(StdDeck_SUIT(hc1) == 2 || StdDeck_SUIT(hc2) == 2) hasClubs.insert(index1326); // spades if(StdDeck_SUIT(hc1) == 3 || StdDeck_SUIT(hc2) == 3) hasSpades.insert(index1326); // PAIRS // pairAcesKings, pairQueensJacks, pairTensToSevens, pairLow; if(StdDeck_RANK(hc1) == StdDeck_RANK(hc2)) { // Aces + Kings if(StdDeck_RANK(hc1) == 12 || StdDeck_RANK(hc1) == 11) pairAcesKings.insert(index1326); // Jacks + Queens else if(StdDeck_RANK(hc1) == 10 || StdDeck_RANK(hc1) == 9) pairQueensJacks.insert(index1326); // Sevens to Tens else if(StdDeck_RANK(hc1) >= 5 || StdDeck_RANK(hc1) <= 8) pairTensToSevens.insert(index1326); // Low Pairs else pairLow.insert(index1326); } // SUITED else if(StdDeck_SUIT(hc1) == StdDeck_SUIT(hc2)) { int suited_max = -1, suited_min = -1; if(StdDeck_RANK(hc1) > StdDeck_RANK(hc2)) { suited_max = StdDeck_RANK(hc1); suited_min = StdDeck_RANK(hc2); } else { suited_max = StdDeck_RANK(hc2); suited_min = StdDeck_RANK(hc1); } // SUITED ACE // suitedAceBig, suitedAceGood, suitedAce2To9; if(suited_max == 12) { // Suited Ace Big if(suited_min == 11) suitedAceBig.insert(index1326); // Suited Ace Good else if(suited_min >= 8) suitedAceGood.insert(index1326); // Suited Ace + 2to9 else suitedAce2To9.insert(index1326); } // SUITED CONNECTORS // suitedConnectorHigh, suitedConnectorMed, suitedConnectorLow; if(suited_max - suited_min == 1) { // Suited Connector High if(suited_max >= 9) suitedConnectorHigh.insert(index1326); // Suited Connector Med else if(suited_max >= 6) suitedConnectorMed.insert(index1326); // Suited Connector Low else suitedConnectorLow.insert(index1326); } } // OFFSUIT else { int off_max = -1, off_min = -1; if(StdDeck_RANK(hc1) > StdDeck_RANK(hc2)) { off_max = StdDeck_RANK(hc1); off_min = StdDeck_RANK(hc2); } else { off_max = StdDeck_RANK(hc2); off_min = StdDeck_RANK(hc1); } // OFFSUIT CONNECTORS // OffconnectorHigh, OffconnectorMed, OffconnectorLow; if(off_max - off_min == 1) { // Off Connector High if(off_max >= 9) offConnectorHigh.insert(index1326); // Off Connector Med else if(off_max >= 6) offConnectorMed.insert(index1326); // Off Connector Low else offConnectorLow.insert(index1326); } } }