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
}
