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;
}
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));
});
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() {
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");
}
);
static CardMask Strings2CardMask(int strings_count, char* strings[])
{
CardMask cards;
CardMask dead;
CardMask_RESET(cards);
CardMask_RESET(dead);
int card;
int i;
for(i = 0; i < strings_count; i++) {
card = -1;
assert(Deck_stringToCard(strings[i], &card) != 0);
assert(StdDeck_CardMask_CARD_IS_SET(dead, card) == 0);
StdDeck_CardMask_SET(cards, card);
}
return cards;
}
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_SET(StdDeck_CardMask mask, unsigned int index) { StdDeck_CardMask_SET(mask, index); return mask; } ;
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;
}
