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;
}
}
);
