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_NumCards(void *cardMask) {
StdDeck_CardMask c = *((StdDeck_CardMask *) cardMask);
int i;
int ncards = 0;
for (i=0; i<StdDeck_N_CARDS; i++)
if (StdDeck_CardMask_CARD_IS_SET(c, i))
ncards++;
return ncards;
}
int
StdDeck_maskToCards(void *cardMask, int cards[]) {
int i, n=0;
StdDeck_CardMask c = *((StdDeck_CardMask *) cardMask);
for (i=StdDeck_N_CARDS-1; i >= 0; i--)
if (StdDeck_CardMask_CARD_IS_SET(c, i))
cards[n++] = i;
return 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;
}
int wrap_StdDeck_CardMask_CARD_IS_SET(StdDeck_CardMask mask, unsigned int index) { return StdDeck_CardMask_CARD_IS_SET(mask, index); }
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 PyObject*
CardMask2SortedPyList(CardMask hand, int low)
{
int i;
HandVal handval;
PyObject* result = PyList_New(0);
if(StdDeck_CardMask_IS_EMPTY(hand)) {
PyObject* pyvalue = Py_BuildValue("s", "Nothing");
PyList_Append(result, pyvalue);
Py_DECREF(pyvalue);
return result;
}
if(low) {
handval = Hand_EVAL_LOW8(hand, 5);
} else {
handval = Hand_EVAL_N(hand, 5);
}
int htype = HandVal_HANDTYPE(handval);
{
PyObject* pyvalue = Py_BuildValue("s", StdRules_handTypeNames[htype]);
PyList_Append(result, pyvalue);
Py_DECREF(pyvalue);
}
if(!low || htype != LowHandVal_NOTHING) {
if (StdRules_nSigCards[htype] >= 1) {
int rank = HandVal_TOP_CARD(handval);
if(low) rank = LOWRANK2RANK(rank);
if(htype == HandType_STRAIGHT || htype == HandType_STFLUSH) {
for(i = rank; rank - i < 5; i--) {
int rank_modulo = i < 0 ? StdDeck_Rank_ACE : i;
PyObject* pyvalue = Py_BuildValue("i", findanddelete(&hand, rank_modulo));
PyList_Append(result, pyvalue);
Py_DECREF(pyvalue);
}
} else {
int count;
switch(htype) {
case HandType_ONEPAIR:
case HandType_TWOPAIR:
count = 2;
break;
case HandType_TRIPS:
case HandType_FULLHOUSE:
count = 3;
break;
case HandType_QUADS:
count = 4;
break;
default:
count = 1;
break;
}
for(i = 0; i < count; i++) {
PyObject* pyvalue = Py_BuildValue("i", findanddelete(&hand, rank));
PyList_Append(result, pyvalue);
Py_DECREF(pyvalue);
}
}
}
if (StdRules_nSigCards[htype] >= 2) {
int rank = HandVal_SECOND_CARD(handval);
int count = 1;
if(low) rank = LOWRANK2RANK(rank);
if(htype == HandType_TWOPAIR ||
htype == HandType_FULLHOUSE)
count = 2;
for(i = 0; i < count; i++) {
PyObject* pyvalue = Py_BuildValue("i", findanddelete(&hand, rank));
PyList_Append(result, pyvalue);
Py_DECREF(pyvalue);
}
}
if (StdRules_nSigCards[htype] >= 3) {
int rank = HandVal_THIRD_CARD(handval);
if(low) rank = LOWRANK2RANK(rank);
PyObject* pyvalue = Py_BuildValue("i", findanddelete(&hand, rank));
PyList_Append(result, pyvalue);
Py_DECREF(pyvalue);
}
if (StdRules_nSigCards[htype] >= 4) {
int rank = HandVal_FOURTH_CARD(handval);
if(low) rank = LOWRANK2RANK(rank);
PyObject* pyvalue = Py_BuildValue("i", findanddelete(&hand, rank));
PyList_Append(result, pyvalue);
Py_DECREF(pyvalue);
}
if (StdRules_nSigCards[htype] >= 5) {
int rank = HandVal_FIFTH_CARD(handval);
if(low) rank = LOWRANK2RANK(rank);
PyObject* pyvalue = Py_BuildValue("i", findanddelete(&hand, rank));
PyList_Append(result, pyvalue);
Py_DECREF(pyvalue);
}
}
/*
* Append remaining cards, highest first
*/
for(i = Deck_N_CARDS - 1; i >= 0; i--) {
if (StdDeck_CardMask_CARD_IS_SET(hand, i)) {
PyObject* pyvalue = Py_BuildValue("i", i);
PyList_Append(result, pyvalue);
Py_DECREF(pyvalue);
}
}
return result;
}
