int parseStandardRanksSuits(JNIEnv *env, jintArray ranks, jintArray suits, StdDeck_CardMask *mcards, int *ncards) { int i, status = 0; jsize nranks = (*env)->GetArrayLength(env, ranks); jsize nsuits = (*env)->GetArrayLength(env, suits); jint *jranks = (*env)->GetIntArrayElements(env, ranks, 0); jint *jsuits = (*env)->GetIntArrayElements(env, suits, 0); StdDeck_CardMask_RESET(*mcards); *ncards = 0; if (nranks != nsuits) { status = 1; goto release1; } for (i=0; i<nranks; i++) { int card = StdDeck_MAKE_CARD(jranks[i], jsuits[i]); if (StdDeck_CardMask_CARD_IS_SET(*mcards, card)) { status = 1; goto release1; } StdDeck_CardMask_SET(*mcards, card); (*ncards)++; } #ifdef DEBUG printf("In C: Hand %s\n", DmaskString(StdDeck, *mcards)); #endif release1: (*env)->ReleaseIntArrayElements(env, ranks, jranks, JNI_ABORT); (*env)->ReleaseIntArrayElements(env, suits, jsuits, JNI_ABORT); return status; }
int StdDeck_stringToMask(char *inString, StdDeck_CardMask *outMask) { char *p; int n=0, rank, suit, card; StdDeck_CardMask_RESET(*outMask); for (p=inString; p < inString + strlen(inString); p++) { if (*p == ' ') continue; for (rank=StdDeck_Rank_FIRST; rank <= StdDeck_Rank_LAST; rank++) if (StdDeck_rankChars[rank] == toupper(*p)) break; if (rank > StdDeck_Rank_LAST) break; ++p; for (suit=StdDeck_Suit_FIRST; suit <= StdDeck_Suit_LAST; suit++) if (StdDeck_suitChars[suit] == tolower(*p)) break; if (suit > StdDeck_Suit_LAST) break; ++p; card = StdDeck_MAKE_CARD(rank, suit); StdDeck_CardMask_SET(*outMask, card); ++n; } return n; }
int RankAndSuitToCardNumber(int rank, int suit) { // Expects OpenHoldem ranks assert(rank >= k_rank_ace_low); assert(rank <= k_rank_ace); assert(suit >= 0); assert(suit < 4); int std_deck_rank = rank - 2; assert(std_deck_rank >= 0); return StdDeck_MAKE_CARD(std_deck_rank, suit); }
int main( void ) { CardMask cards, cards1, peggedCards; HandVal handval1, handval2; EvxHandVal evxHandVal; StdDeck_CardMask_RESET(peggedCards); StdDeck_CardMask_SET(peggedCards, StdDeck_MAKE_CARD(StdDeck_Rank_ACE, StdDeck_Suit_DIAMONDS)); StdDeck_CardMask_SET(peggedCards, StdDeck_MAKE_CARD(StdDeck_Rank_ACE, StdDeck_Suit_HEARTS)); ENUMERATE_5_CARDS_D(cards, peggedCards, { StdDeck_CardMask_OR(cards1, cards, peggedCards); handval1 = Hand_EVAL_N(cards1, 7); evxHandVal = Hand_EVAL_X7(CardMask_CLUBS(cards1), CardMask_DIAMONDS(cards1), CardMask_HEARTS(cards1), CardMask_SPADES(cards1)); handval2 = EvxHandVal_toHandVal(evxHandVal); if (handval1 != handval2) { fprintf(stderr, "eval_n() and eval_x7() disagree\n"); printf("0\n"); Deck_printMask(cards); printf(": "); HandVal_print(handval1); printf(", "); HandVal_print(handval2); printf("\n"); exit(0); } printf("%d %d %d %d %d %d\n", HandVal_HANDTYPE(handval1), HandVal_TOP_CARD(handval1), HandVal_SECOND_CARD(handval1), HandVal_THIRD_CARD(handval1), HandVal_FOURTH_CARD(handval1), HandVal_FIFTH_CARD(handval1)); });
/* * Find the card with highest suit matching rank in hand * and remove it from hand. The removed card is returned. */ int findanddelete(CardMask* hand, int rank) { int suit; for(suit = StdDeck_Suit_LAST; suit >= StdDeck_Suit_FIRST; suit--) { int card = StdDeck_MAKE_CARD(rank, suit); if(CardMask_CARD_IS_SET(*hand, card)) { CardMask_UNSET(*hand, card); return card; } } return -1; }
int numCardsStandard(StdDeck_CardMask mask) { int r, s; int nbits = 0; for (r=StdDeck_Rank_FIRST; r<=StdDeck_Rank_LAST; r++) { for (s=StdDeck_Suit_FIRST; s<=StdDeck_Suit_LAST; s++) { StdDeck_CardMask card = StdDeck_MASK(StdDeck_MAKE_CARD(r, s)); if (StdDeck_CardMask_ANY_SET(mask, card)) nbits++; } } return nbits; }
int Hand::ConvertCardToPokerEvalCard(const Card& card) const { int rank, suit; // We must convert our hand from our format (8-bit): // | 7 6 5 4 3 2 1 0 | // | rank | suit | // // to the poker-eval format (16-bit) // (rank*4)+suit // rank = card.Rank()-2; suit = card.Suit() == Card::CLUBS ? StdDeck_Suit_CLUBS : card.Suit() == Card::DIAMONDS ? StdDeck_Suit_DIAMONDS : card.Suit() == Card::HEARTS ? StdDeck_Suit_HEARTS : card.Suit() == Card::SPADES ? StdDeck_Suit_SPADES : 0; return (StdDeck_MAKE_CARD(rank, suit)); }
int StdDeck_stringToCard(char *inString, int *cardIndex) { char *p; int rank, suit; p = inString; for (rank=StdDeck_Rank_FIRST; rank <= StdDeck_Rank_LAST; rank++) if (StdDeck_rankChars[rank] == toupper(*p)) break; if (rank > StdDeck_Rank_LAST) goto noMatch; ++p; for (suit=StdDeck_Suit_FIRST; suit <= StdDeck_Suit_LAST; suit++) if (StdDeck_suitChars[suit] == tolower(*p)) break; if (suit > StdDeck_Suit_LAST) goto noMatch; *cardIndex = StdDeck_MAKE_CARD(rank, suit); return 2; noMatch: /* Didn't match anything, return failure */ return 0; }
unsigned int wrap_StdDeck_MAKE_CARD(unsigned int rank, unsigned int suit) { return StdDeck_MAKE_CARD(rank, suit); }
void CKnnLogic::FillHandInfoStruct(int* hand) { bool new_hand, new_street, new_bet; hand[eDim_handId] = current_hand_id; ///////////////////////////// // NEW HAND / STREET / BET // ///////////////////////////// new_hand = new_street = new_bet = false; // New Hand if(gVars.get_dealerchair() != prev_dealer) { new_hand = true; hand[eDim_isNew] = 1; } // New street else if(gVars.get_betround() != prev_br) { new_street = true; hand[eDim_isNew] = 2; } // New bet else if(prev_ntimesacted != gVars.ntimesacted) { new_bet = true; hand[eDim_isNew] = 3; } // initialize hero_actions if(new_hand || new_street) { for(int i = 0; i < k_max_actions; i++) hero_actions[i] = eBet_Unknown; } hand[eDim_brNdx] = BR2NDX(gVars.get_betround()); assert(ePreflopIndex <= hand[eDim_brNdx] && eRiverIndex >= hand[eDim_brNdx]); hand[eDim_timesActed] = min(gVars.ntimesacted,3); // save hero_actions to hand_info struct for(int i = 0; i < k_max_actions; i++) hand[eDim_Action1+i] = hero_actions[i]; hand[eDim_HS] = 100 * (hand[eDim_InHand] > 0 && hand[eDim_InHand] < k_max_chairs ? hand[eDim_InHand] : 1) * gVars.get_prwin(); //0..1 hand[eDim_Raises] = gVars.get_nopponentsraising(); ///////////////////////////////////////////////// //Save data normalized on the interval 0..1000:// ///////////////////////////////////////////////// // save hand169 to hand_info struct if(ePreflopIndex == hand[eDim_brNdx]) { hand[eDim_PPot] = 0; hand[eDim_NPot] = 0; } else { // Calc hand potentials if(eRiverIndex != hand[eDim_brNdx]) { // Generate card masks StdDeck_CardMask hero_cards = {0}, board_cards = {0}; for(int i = 0; i < 2; i++) { int card = StdDeck_MAKE_CARD(gVars.Bot_Common_Cards[i][0]-2, ConvertSuitsForPokerEval[gVars.Bot_Common_Cards[i][1]]); StdDeck_CardMask_OR(hero_cards, hero_cards, StdDeck_MASK(card)); //gLog.WriteLog(eSeverityDebug, eCatHandPotential, "Player Card: %d\n", card); } for(int i = 0; i < (1 + gVars.get_betround()); i++) { int card = StdDeck_MAKE_CARD(gVars.Bot_Common_Cards[2+i][0]-2, ConvertSuitsForPokerEval[gVars.Bot_Common_Cards[2+i][1]]); StdDeck_CardMask_OR(board_cards, board_cards, StdDeck_MASK(card)); //gLog.WriteLog(eSeverityDebug, eCatHandPotential, "Board Card: %d\n", card); } // calculate potentials // Shouldn't this calc be moved to the server ? CHandPotential hp(hero_cards, board_cards); hp.CalcPotentials(); // save potentials to hand_info struct hand[eDim_PPot]= (int)(100*hp.Ppot); //0..1 hand[eDim_NPot] = (int)(100*hp.Npot); //0..1 } else { // no such thing as ppot/npot in the river hand[eDim_PPot] = 0; hand[eDim_NPot] = 0; } } hand[eDim_InHand] = gVars.nplayersplaying; //1..6 /4 // replace me !!! hand[eDim_Dealt] = gVars.get_nplayersdealt(); //1..6 /4 // replace me !!! hand[eDim_ToAct] = gVars.m_state.LeftToAct(gVars.userchair); //1..6 /4 // replace me !!! hand[eDim_Balance] = (int)(gVars.balance[gVars.userchair]); //0..+-400 hand[eDim_InitialBalance] = (int)(gVars.initial_balance[gVars.userchair]); //0..+-400 hand[eDim_Call] = (int)(gVars.call); //0..+-400 hand[eDim_Pot] = (int)(gVars.get_pot()); //0..+-800 }