CBotLogic::CBotLogic() : lastPrWinCalc_pot(0), lastPrwinCalc_nopponents(0), strategyCount(1), strategies(new CBaseStrategy* [strategyCount]), activeStrategy (NULL) { strategies[0] = new CStealBlinds(); StdDeck_CardMask_RESET(lastPrwinCalc_playerMask); StdDeck_CardMask_RESET(lastPrwinCalc_boardMask); }
static inline void calc(int argc, char** argv) { StdDeck_CardMask hole, board; StdDeck_CardMask card; StdDeck_CardMask_RESET(hole); StdDeck_CardMask_RESET(board); int i, cardi; for(i = 1; i < 5; ++i) { StdDeck_stringToCard(argv[i], &cardi); card = StdDeck_MASK(cardi); StdDeck_CardMask_OR(hole, hole, card); } po_probs probs; probs = get_probs(hole, board); printf("%.4f", probs.win + probs.draw); if ( argc > 7) { for(i = 5; i < 8; ++i) { StdDeck_stringToCard(argv[i], &cardi); card = StdDeck_MASK(cardi); StdDeck_CardMask_OR(board, board, card); } probs = get_probs(hole, board); printf(" %.4f", probs.win + probs.draw); } if ( argc > 8) { i = 8; StdDeck_stringToCard(argv[i], &cardi); card = StdDeck_MASK(cardi); StdDeck_CardMask_OR(board, board, card); probs = get_probs(hole, board); printf(" %.4f", probs.win + probs.draw); } if ( argc > 9) { i = 9; StdDeck_stringToCard(argv[i], &cardi); card = StdDeck_MASK(cardi); StdDeck_CardMask_OR(board, board, card); probs = get_probs(hole, board); printf(" %.4f", probs.win + probs.draw); } printf("\n"); }
int enumSample(enum_game_t game, StdDeck_CardMask pockets[], StdDeck_CardMask board, StdDeck_CardMask dead, int npockets, int nboard, int niter, int orderflag, enum_result_t *result) { int numCards; enumResultClear(result); if (npockets > ENUM_MAXPLAYERS) return 1; if (orderflag) { enum_ordering_mode_t mode; switch (game) { case game_holdem: case game_omaha: case game_7stud: case game_5draw: mode = enum_ordering_mode_hi; break; case game_razz: case game_lowball: case game_lowball27: mode = enum_ordering_mode_lo; break; case game_holdem8: case game_omaha8: case game_7stud8: case game_7studnsq: case game_5draw8: case game_5drawnsq: mode = enum_ordering_mode_hilo; break; default: return 1; } if (enumResultAlloc(result, npockets, mode)) return 1; } if (game == game_holdem) { StdDeck_CardMask sharedCards; numCards = 5 - nboard; if (numCards > 0) { DECK_MONTECARLO_N_CARDS_D(StdDeck, sharedCards, dead, numCards, niter, INNER_LOOP_HOLDEM); } else { StdDeck_CardMask_RESET(sharedCards); INNER_LOOP_HOLDEM; return 1; } } else { return 1; } result->game = game; result->nplayers = npockets; result->sampleType = ENUM_SAMPLE; return 0; }
// Helper: // Given a string such as "AcKcQcJcTc" representing a poker hand, // return an StdDeck_CardMask representing that hand. extern "C" StdDeck_CardMask TextToPokerEval(const char* strHand) { StdDeck_CardMask theHand, theCard; StdDeck_CardMask_RESET(theHand); if (strHand && strlen(strHand)) { int cardIndex = -1; char* curCard = const_cast<char*>(strHand); while (*curCard) { // Take the card text and convert it to an index (0..51) StdDeck_stringToCard(curCard, &cardIndex); // Convert the card index to a mask theCard = StdDeck_MASK(cardIndex); // Add the card (mask) to the hand StdDeck_CardMask_OR(theHand, theHand, theCard); // Advance to the next card (if any) curCard += 2; } } return theHand; }
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 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; }
static void doMaskRankTable(void) { int i; MakeTable_begin("StdDeck_maskRankTable", MR_FILENAME, "StdDeck_CardMask", StdDeck_Rank_COUNT); MakeTable_comment(MR_COMMENT_STRING); for (i=0; i < StdDeck_Rank_COUNT; i++) { StdDeck_CardMask c; StdDeck_CardMask_RESET(c); c.cards.spades = (1 << i); c.cards.hearts = (1 << i); c.cards.diamonds = (1 << i); c.cards.clubs = (1 << i); #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(); }
StdDeck_CardMask parseLongStandard(jlong lmask) { int i; jlong flag; StdDeck_CardMask mask; StdDeck_CardMask_RESET(mask); for (i=0, flag=1; i<StdDeck_N_CARDS; i++, flag<<=1) if (lmask & flag) StdDeck_CardMask_SET(mask, i); return mask; }
int main(int argc, char** argv) { StdDeck_CardMask hole; StdDeck_CardMask empty_deck; StdDeck_CardMask_RESET(empty_deck); DECK_ENUMERATE_4_CARDS_D(StdDeck, hole, empty_deck, { if(hole.cards.spades >= hole.cards.clubs && hole.cards.clubs >= hole.cards.diamonds && hole.cards.diamonds >= hole.cards.hearts) { puts(StdDeck_maskString(hole)); //print hand } // });
int main() { StdDeck_CardMask set_var[2]; int num_sets = 2; int set_sizes[2] = {2, 1}; StdDeck_CardMask dead_cards; int i; StdDeck_CardMask_RESET(dead_cards); for (i=0; i<39; i++) /* remove three suits to reduce output */ StdDeck_CardMask_SET(dead_cards, i); DECK_ENUMERATE_COMBINATIONS_D(StdDeck, set_var, num_sets, set_sizes, dead_cards, { for (i=0; i<num_sets; i++) { printf("%s | ", DmaskString(StdDeck, set_var[i])); } printf("\n"); } );
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)); });
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(); }
int enumExhaustive(enum_game_t game, StdDeck_CardMask pockets[], StdDeck_CardMask board, StdDeck_CardMask dead, int npockets, int nboard, int orderflag, enum_result_t *result) { enumResultClear(result); if (npockets > ENUM_MAXPLAYERS) return 1; if (orderflag) { enum_ordering_mode_t mode; switch (game) { case game_holdem: case game_omaha: case game_7stud: case game_5draw: mode = enum_ordering_mode_hi; break; case game_razz: case game_lowball: case game_lowball27: mode = enum_ordering_mode_lo; break; case game_holdem8: case game_omaha8: case game_7stud8: case game_7studnsq: case game_5draw8: case game_5drawnsq: mode = enum_ordering_mode_hilo; break; default: return 1; } if (enumResultAlloc(result, npockets, mode)) return 1; } if (game == game_holdem) { StdDeck_CardMask sharedCards; if (nboard == 0) { DECK_ENUMERATE_5_CARDS_D(StdDeck, sharedCards, dead, INNER_LOOP_HOLDEM); } else if (nboard == 3) { DECK_ENUMERATE_2_CARDS_D(StdDeck, sharedCards, dead, INNER_LOOP_HOLDEM); } else if (nboard == 4) { DECK_ENUMERATE_1_CARDS_D(StdDeck, sharedCards, dead, INNER_LOOP_HOLDEM); } else if (nboard == 5) { StdDeck_CardMask_RESET(sharedCards); INNER_LOOP_HOLDEM; } else { return 1; } } else { return 1; } result->game = game; result->nplayers = npockets; result->sampleType = ENUM_EXHAUSTIVE; return 0; }
static int parseArgs(int argc, char **argv, enum_game_t *game, enum_sample_t *enumType, int *niter, StdDeck_CardMask pockets[], StdDeck_CardMask *board, StdDeck_CardMask *dead, int *npockets, int *nboard, int *terse) { /* we have a type problem: we define the masks here as StdDeck_CardMask, which makes it impossible to hold jokers. we need to redesign some of the deck typing to make this work... */ enum_gameparams_t *gameParams = enumGameParams(game_holdem); enum { ST_OPTIONS, ST_POCKET, ST_BOARD, ST_DEAD } state; int ncards; int card; int i; state = ST_OPTIONS; *npockets = *nboard = ncards = 0; *terse = 0; *game = game_holdem; *enumType = ENUM_EXHAUSTIVE; StdDeck_CardMask_RESET(*dead); StdDeck_CardMask_RESET(*board); for (i=0; i<ENUM_MAXPLAYERS; i++) StdDeck_CardMask_RESET(pockets[i]); while (++argv, --argc) { if (state == ST_OPTIONS) { if (argv[0][0] != '-') { state = ST_POCKET; argv--; argc++; } else { if (strcmp(*argv, "-mc") == 0) { *enumType = ENUM_SAMPLE; if (argc < 1) return 1; *niter = strtol(argv[1], NULL, 0); if (*niter <= 0 || errno != 0) return 1; argv++; argc--; /* put card back in list */ } else if (strcmp(*argv, "-t") == 0) { *terse = 1; } else if (strcmp(*argv, "-h") == 0) { *game = game_holdem; } else if (strcmp(*argv, "-h8") == 0) { *game = game_holdem8; } else if (strcmp(*argv, "-o") == 0) { *game = game_omaha; } else if (strcmp(*argv, "-o8") == 0) { *game = game_omaha8; } else if (strcmp(*argv, "-7s") == 0) { *game = game_7stud; } else if (strcmp(*argv, "-7s8") == 0) { *game = game_7stud8; } else if (strcmp(*argv, "-7snsq") == 0) { *game = game_7studnsq; } else if (strcmp(*argv, "-r") == 0) { *game = game_razz; } else if (strcmp(*argv, "-5d") == 0) { *game = game_5draw; } else if (strcmp(*argv, "-5d8") == 0) { *game = game_5draw8; } else if (strcmp(*argv, "-5dnsq") == 0) { *game = game_5drawnsq; } else if (strcmp(*argv, "-l") == 0) { *game = game_lowball; } else if (strcmp(*argv, "-l27") == 0) { *game = game_lowball27; } else { /* unknown option switch */ return 1; } if ((gameParams = enumGameParams(*game)) == NULL) return 1; } } else if (state == ST_POCKET) { if (strcmp(*argv, "-") == 0) { /* player delimiter */ if (ncards > 0) { /* is a player pending? */ if (ncards < gameParams->minpocket) /* too few pocket cards */ return 1; (*npockets)++; ncards = 0; } state = ST_POCKET; } else if (strcmp(*argv, "--") == 0) { /* board prefix */ state = ST_BOARD; } else if (strcmp(*argv, "/") == 0) { /* dead card prefix */ state = ST_DEAD; } else { if (*npockets >= ENUM_MAXPLAYERS) /* too many players */ return 1; if (DstringToCard(StdDeck, *argv, &card) == 0) /* parse error */ return 1; if (StdDeck_CardMask_CARD_IS_SET(*dead, card)) /* card already seen */ return 1; StdDeck_CardMask_SET(pockets[*npockets], card); StdDeck_CardMask_SET(*dead, card); ncards++; if (ncards == gameParams->maxpocket) { /* implicit player delimiter */ (*npockets)++; ncards = 0; } } } else if (state == ST_BOARD) { if (strcmp(*argv, "/") == 0) { /* dead card prefix */ state = ST_DEAD; } else { if (DstringToCard(StdDeck, *argv, &card) == 0) /* parse error */ return 1; if (StdDeck_CardMask_CARD_IS_SET(*dead, card)) /* card already seen */ return 1; if (*nboard >= gameParams->maxboard) /* too many board cards */ return 1; StdDeck_CardMask_SET(*board, card); StdDeck_CardMask_SET(*dead, card); (*nboard)++; } } else if (state == ST_DEAD) { if (strcmp(*argv, "-") == 0) { /* player delimiter */ if (ncards > 0) { /* is a player pending? */ if (ncards < gameParams->minpocket) /* too few pocket cards */ return 1; (*npockets)++; ncards = 0; } state = ST_POCKET; } else { if (DstringToCard(StdDeck, *argv, &card) == 0) /* parse error */ return 1; if (StdDeck_CardMask_CARD_IS_SET(*dead, card)) /* card already seen */ return 1; StdDeck_CardMask_SET(*dead, card); } } } if (ncards > 0) { /* is a player pending? */ if (ncards < gameParams->minpocket) /* too few pocket cards */ return 1; (*npockets)++; ncards = 0; } if (*npockets == 0) /* no players seen */ return 1; return 0; }
StdDeck_CardMask wrap_StdDeck_CardMask_RESET() { StdDeck_CardMask mask; StdDeck_CardMask_RESET(mask); return mask; }
static PyObject* eval_hand(PyObject* self, PyObject *args) { PyObject* result = 0; char* hilow_string = 0; PyObject* pyhand = 0; PyObject* pyboard = 0; int low = 0; CardMask hand; CardMask board; int board_size = 0; CardMask best; HandVal best_handval; StdDeck_CardMask_RESET(best); if (!PyArg_ParseTuple(args, "sOO", &hilow_string, &pyhand, &pyboard)) return NULL; if(!strcmp(hilow_string, "low")) low = 1; if(PyList2CardMask(pyhand, &hand) < 0) return NULL; board_size = PyList2CardMask(pyboard, &board); if(board_size > 0) { CardMask hicards; CardMask locards; HandVal hival = 0; HandVal loval = 0; StdDeck_CardMask_RESET(hicards); StdDeck_CardMask_RESET(locards); OmahaHiLow8_Best(hand, board, &hival, &loval, &hicards, &locards); if(low) { best_handval = loval; if(best_handval != LowHandVal_NOTHING) best = locards; } else { best = hicards; best_handval = hival; } } else { CardMask cards; CardMask dead; StdDeck_CardMask_RESET(best); StdDeck_CardMask_RESET(dead); StdDeck_CardMask_OR(dead, dead, hand); StdDeck_CardMask_NOT(dead, dead); if(low) { best_handval = LowHandVal_NOTHING; } else { best_handval = HandVal_NOTHING; } ENUMERATE_N_CARDS_D(cards, 5, dead, { HandVal handval; if(low) { handval = Hand_EVAL_LOW8(cards, 5); } else { handval = Hand_EVAL_N(cards, 5); } if(low ? (handval < best_handval) : (handval > best_handval)) { best = cards; best_handval = handval; } } );
static int OmahaHiLow8_Best(StdDeck_CardMask hole, StdDeck_CardMask board, HandVal *hival, LowHandVal *loval, StdDeck_CardMask *hicards, StdDeck_CardMask *locards) { StdDeck_CardMask allcards; LowHandVal allval; HandVal curhi, besthi; LowHandVal curlo, bestlo; StdDeck_CardMask hole1[OMAHA_MAXHOLE]; StdDeck_CardMask board1[OMAHA_MAXBOARD]; StdDeck_CardMask n1, n2, n3, n4, n5; int nhole, nboard; int eligible = 0; int i, h1, h2, b1, b2, b3; /* pluck out individual cards from hole and board masks, save in arrays */ nhole = nboard = 0; for (i=0; i<StdDeck_N_CARDS; i++) { if (StdDeck_CardMask_CARD_IS_SET(hole, i)) { if (nhole >= OMAHA_MAXHOLE) return 1; /* too many hole cards */ StdDeck_CardMask_RESET(hole1[nhole]); StdDeck_CardMask_SET(hole1[nhole], i); nhole++; } if (StdDeck_CardMask_CARD_IS_SET(board, i)) { if (StdDeck_CardMask_CARD_IS_SET(hole, i)) /* same card in hole and board */ return 2; if (nboard >= OMAHA_MAXBOARD) return 3; /* too many board cards */ StdDeck_CardMask_RESET(board1[nboard]); StdDeck_CardMask_SET(board1[nboard], i); nboard++; } } if (nhole < OMAHA_MINHOLE || nhole > OMAHA_MAXHOLE) return 4; /* wrong # of hole cards */ if (nboard < OMAHA_MINBOARD || nboard > OMAHA_MAXBOARD) return 5; /* wrong # of board cards */ /* quick test in case no low is possible with all 9 cards */ if (loval != NULL) { StdDeck_CardMask_OR(allcards, hole, board); allval = StdDeck_Lowball8_EVAL(allcards, nhole + nboard); eligible = (allval != LowHandVal_NOTHING); } /* loop over all combinations of hole with board (60 for 4 hole cards and 5 board cards). */ besthi = HandVal_NOTHING; bestlo = LowHandVal_NOTHING; /* {h1,h2} loop over all hole card combinations */ for (h1=0; h1<nhole-1; h1++) { StdDeck_CardMask_RESET(n1); StdDeck_CardMask_OR(n1, n1, hole1[h1]); for (h2=h1+1; h2<nhole; h2++) { StdDeck_CardMask_OR(n2, n1, hole1[h2]); /* {b1,b2,b3} loop over all board card combinations */ for (b1=0; b1<nboard-2; b1++) { StdDeck_CardMask_OR(n3, n2, board1[b1]); for (b2=b1+1; b2<nboard-1; b2++) { StdDeck_CardMask_OR(n4, n3, board1[b2]); for (b3=b2+1; b3<nboard; b3++) { if (hival != NULL) { StdDeck_CardMask_OR(n5, n4, board1[b3]); curhi = StdDeck_StdRules_EVAL_N(n5, 5); if (curhi > besthi || besthi == HandVal_NOTHING) { besthi = curhi; *hicards = n5; } } if (loval != NULL && eligible) { curlo = StdDeck_Lowball8_EVAL(n5, 5); if (curlo < bestlo || bestlo == LowHandVal_NOTHING) { bestlo = curlo; *locards = n5; } } } } } } } if (hival != NULL) *hival = besthi; if (loval != NULL) *loval = bestlo; return 0; }
static VALUE t_eval_hand(VALUE self, VALUE args) { VALUE result = 0; VALUE rbboard = 0; VALUE rbhand = 0; char* hilow_string = 0; hilow_string = RSTRING_PTR(rb_hash_aref(args, rb_str_new2("side"))); rbboard = rb_hash_aref(args, rb_str_new2("board")); rbhand = rb_hash_aref(args, rb_str_new2("hand")); int low = 0; CardMask hand; CardMask board; int board_size = 0; CardMask best; HandVal best_handval; StdDeck_CardMask_RESET(best); if(!strcmp(hilow_string, "low")) { low = 1; } if(rbList2CardMask(rbhand, &hand) < 0) rb_fatal("empty hand given"); if( !NIL_P(rbboard)) { board_size = rbList2CardMask(rbboard, &board); } if(board_size > 0) { CardMask hicards; CardMask locards; HandVal hival = 0; HandVal loval = 0; StdDeck_CardMask_RESET(hicards); StdDeck_CardMask_RESET(locards); OmahaHiLow8_Best(hand, board, &hival, &loval, &hicards, &locards); if(low) { best_handval = loval; if(best_handval != LowHandVal_NOTHING) best = locards; } else { best = hicards; best_handval = hival; } } else { CardMask cards; CardMask dead; StdDeck_CardMask_RESET(best); StdDeck_CardMask_RESET(dead); StdDeck_CardMask_OR(dead, dead, hand); StdDeck_CardMask_NOT(dead, dead); if(low) { best_handval = LowHandVal_NOTHING; } else { best_handval = HandVal_NOTHING; } ENUMERATE_N_CARDS_D(cards, 5, dead, { HandVal handval; if(low) { handval = Hand_EVAL_LOW8(cards, 5); } else { handval = Hand_EVAL_N(cards, 5); } if(low ? (handval < best_handval) : (handval > best_handval)) { best = cards; best_handval = handval; } } );