int
LowHandVal_toString(LowHandVal hv, char *outString) {
char *p = outString;
int htype = HandVal_HANDTYPE(hv);
if (hv == LowHandVal_NOTHING)
p += sprintf(outString, "NoLow");
else {
p += sprintf(outString, "%s (", StdRules_handTypeNames[htype]);
if (StdRules_nSigCards[htype] >= 1)
p += sprintf(p, "%c",
StdDeck_rankChars[CARD_TO_RANK(HandVal_TOP_CARD(hv))]);
if (StdRules_nSigCards[htype] >= 2)
p += sprintf(p, " %c",
StdDeck_rankChars[CARD_TO_RANK(HandVal_SECOND_CARD(hv))]);
if (StdRules_nSigCards[htype] >= 3)
p += sprintf(p, " %c",
StdDeck_rankChars[CARD_TO_RANK(HandVal_THIRD_CARD(hv))]);
if (StdRules_nSigCards[htype] >= 4)
p += sprintf(p, " %c",
StdDeck_rankChars[CARD_TO_RANK(HandVal_FOURTH_CARD(hv))]);
if (StdRules_nSigCards[htype] >= 5)
p += sprintf(p, " %c",
StdDeck_rankChars[CARD_TO_RANK(HandVal_FIFTH_CARD(hv))]);
p += sprintf(p, ")");
};
return p - outString;
}
int main( void )
{
CardMask cards;
HandVal handval1, handval2;
EvxHandVal evxHandVal;
ENUMERATE_5_CARDS(cards,
{
handval1 = Hand_EVAL_N(cards, 5);
evxHandVal = Hand_EVAL_X5(CardMask_CLUBS(cards),
CardMask_DIAMONDS(cards),
CardMask_HEARTS(cards),
CardMask_SPADES(cards));
handval2 = EvxHandVal_toHandVal(evxHandVal);
if (handval1 != handval2)
{
fprintf(stderr, "eval_n() and eval_x5() 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));
});
int
AStudRules_HandVal_toString(HandVal handval, char *outString) {
char *p = outString;
int htype = HandVal_HANDTYPE(handval);
p += sprintf(outString, "%s (", AStudRules_handTypeNames[htype]);
if (AStudRules_nSigCards[htype] >= 1)
p += sprintf(p, "%c",
AStudDeck_rankChars[HandVal_TOP_CARD(handval)]);
if (AStudRules_nSigCards[htype] >= 2)
p += sprintf(p, " %c",
AStudDeck_rankChars[HandVal_SECOND_CARD(handval)]);
if (AStudRules_nSigCards[htype] >= 3)
p += sprintf(p, " %c",
AStudDeck_rankChars[HandVal_THIRD_CARD(handval)]);
if (AStudRules_nSigCards[htype] >= 4)
p += sprintf(p, " %c",
AStudDeck_rankChars[HandVal_FOURTH_CARD(handval)]);
if (AStudRules_nSigCards[htype] >= 5)
p += sprintf(p, " %c",
AStudDeck_rankChars[HandVal_FIFTH_CARD(handval)]);
p += sprintf(p, ")");
return p - outString;
}
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));
});
int main( void )
{
CardMask cards;
HandVal handval1, handval2;
EvxHandVal evxHandVal;
Md5Context ctx;
Md5RawDigest raw;
Md5CodedDigest coded;
unsigned char hashvals[6];
ctx = MD5Begin();
ENUMERATE_5_CARDS(cards,
{
handval1 = Hand_EVAL_N(cards, 5);
evxHandVal = Hand_EVAL_X5(CardMask_CLUBS(cards),
CardMask_DIAMONDS(cards),
CardMask_HEARTS(cards),
CardMask_SPADES(cards));
handval2 = EvxHandVal_toHandVal(evxHandVal);
if (handval1 != handval2)
{
fprintf(stderr, "eval_n() and eval_x5() disagree\n");
printf("0\n");
Deck_printMask(cards);
printf(": ");
HandVal_print(handval1);
printf(", ");
HandVal_print(handval2);
printf("\n");
exit(0);
}
hashvals[0] = HandVal_HANDTYPE(handval1);
hashvals[1] = HandVal_TOP_CARD(handval1);
hashvals[2] = HandVal_SECOND_CARD(handval1);
hashvals[3] = HandVal_THIRD_CARD(handval1);
hashvals[4] = HandVal_FOURTH_CARD(handval1);
hashvals[5] = HandVal_FIFTH_CARD(handval1);
MD5DigestBytes(ctx, hashvals, 6);
});
void write_logautoplay(int level, const char * action)
{
char nowtime[26];
CString pcards, comcards, temp, rank, pokerhand, bestaction, fcra_seen;
char *card;
CardMask Cards;
int i, nCards;
HandVal hv;
CString fcra_formula_status;
int sym_userchair = (int) p_symbols->sym()->userchair;
int sym_br = (int) p_symbols->sym()->br;
if (level>prefs.log_level())
return;
if (log_fp != NULL)
{
CSLock lock(log_critsec);
// log$ writing
if (prefs.log_symbol_enabled())
{
int max_log = p_symbols->logsymbols_collection()->GetCount();
if (max_log > 0)
{
if (max_log > prefs.log_symbol_max_log())
{
max_log = prefs.log_symbol_max_log();
}
write_log(1, "*** log$ (Total: %d | Showing: %d)\n", p_symbols->logsymbols_collection()->GetCount(), max_log);
for (int i=0; i<max_log; i++)
{
write_log(1, "*** %s\n", p_symbols->logsymbols_collection()->GetAt(i));
}
}
}
CardMask_RESET(Cards);
nCards=0;
// player cards
if (p_symbols->user_chair_confirmed())
{
for (i=0; i<=1; i++)
{
card = StdDeck_cardString(p_scraper->card_player(sym_userchair, i));
temp.Format("%s", card);
pcards.Append(temp);
CardMask_SET(Cards, p_scraper->card_player(sym_userchair, i));
nCards++;
}
}
else
{
pcards = "....";
}
// common cards
comcards = "";
if (sym_br >= 2)
{
for (i=0; i<=2; i++)
{
if (p_scraper->card_common(i) != CARD_BACK &&
p_scraper->card_common(i) != CARD_NOCARD)
{
card = StdDeck_cardString(p_scraper->card_common(i));
temp.Format("%s", card);
comcards.Append(temp);
CardMask_SET(Cards, p_scraper->card_common(i));
nCards++;
}
}
}
if (sym_br >= 3)
{
card = StdDeck_cardString(p_scraper->card_common(3));
temp.Format("%s", card);
comcards.Append(temp);
CardMask_SET(Cards, p_scraper->card_common(3));
nCards++;
}
if (sym_br >= 4)
{
card = StdDeck_cardString(p_scraper->card_common(4));
temp.Format("%s", card);
comcards.Append(temp);
CardMask_SET(Cards, p_scraper->card_common(4));
nCards++;
}
comcards.Append("..........");
comcards = comcards.Left(10);
// handrank
if (prefs.sym_handrank_value() == "169")
rank.Format("%.0f", p_symbols->sym()->handrank169);
else if (prefs.sym_handrank_value() == "1000")
rank.Format("%.0f", p_symbols->sym()->handrank1000);
else if (prefs.sym_handrank_value() == "1326")
rank.Format("%.0f", p_symbols->sym()->handrank1326);
else if (prefs.sym_handrank_value() == "2652")
rank.Format("%.0f", p_symbols->sym()->handrank2652);
else if (prefs.sym_handrank_value() == "p")
rank.Format("%.2f", p_symbols->sym()->handrankp);
// poker hand
hv = Hand_EVAL_N(Cards, nCards);
if (HandVal_HANDTYPE(hv)==HandType_STFLUSH && StdDeck_RANK(HandVal_TOP_CARD(hv))==Rank_ACE)
pokerhand="royfl";
else if (HandVal_HANDTYPE(hv)==HandType_STFLUSH)
pokerhand="strfl";
else if (HandVal_HANDTYPE(hv)==HandType_QUADS)
pokerhand="4kind";
else if (HandVal_HANDTYPE(hv)==HandType_FULLHOUSE)
pokerhand="fullh";
else if (HandVal_HANDTYPE(hv)==HandType_FLUSH)
pokerhand="flush";
else if (HandVal_HANDTYPE(hv)==HandType_STRAIGHT)
pokerhand="strai";
else if (HandVal_HANDTYPE(hv)==HandType_TRIPS)
pokerhand="3kind";
else if (HandVal_HANDTYPE(hv)==HandType_TWOPAIR)
pokerhand="2pair";
else if (HandVal_HANDTYPE(hv)==HandType_ONEPAIR)
pokerhand="1pair";
else if (HandVal_HANDTYPE(hv)==HandType_NOPAIR)
pokerhand="hcard";
// best action
if (strcmp(action, "SWAG")==0)
{
bestaction.Format("$%.2f", p_symbols->f$betsize());
}
else
{
if (p_symbols->f$alli())
bestaction = "Allin";
else if (p_symbols->f$betsize())
bestaction = "SWAG";
else if (p_symbols->f$rais())
bestaction = "Bet/Raise";
else if (p_symbols->f$call())
bestaction = "Call/Check";
else if (p_symbols->f$prefold())
bestaction = "Pre-fold";
else
bestaction = "Fold/Check";
}
// fcra_seen
int sym_myturnbits = (int) p_symbols->sym()->myturnbits;
fcra_seen.Format("%s%s%s%s%s",
sym_myturnbits&0x01 ? "F" : ".",
sym_myturnbits&0x02 ? "C" : ".",
// Check button out of order to stay consistent
// with button order in manual mode.
sym_myturnbits&0x10 ? "K" : ".",
sym_myturnbits&0x04 ? "R" : ".",
sym_myturnbits&0x08 ? "A" : ".");
// fcra formula status
fcra_formula_status.Format("%s%s%s%s",
!p_symbols->f$alli() && !p_symbols->f$rais() && !p_symbols->f$call() && !p_symbols->f$betsize() ? "F" : ".",
p_symbols->f$call() ? "C" : ".",
p_symbols->f$rais() ? "R" : ".",
p_symbols->f$alli() ? "A" : ".");
fprintf(log_fp, "%s - %1d ",
get_time(nowtime),
p_tablemap->nchairs());
fprintf(log_fp, "%4s %10s %4s %5s ",
pcards.GetString(),
comcards.GetString(),
rank.GetString(),
pokerhand.GetString());
fprintf(log_fp, "%4d %4d %4d ",
(int) (p_symbols->sym()->prwin*1000),
(int) (p_symbols->sym()->prlos*1000),
(int) (p_symbols->sym()->prtie*1000));
fprintf(log_fp, "%2d %8d %-10s - ",
(int) p_symbols->sym()->nopponents,
(int) p_symbols->sym()->nit,
bestaction.GetString());
fprintf(log_fp, "%-5s %9.2f %9.2f %9.2f ",
action,
p_symbols->sym()->call,
p_tablelimits->bet(),
p_symbols->sym()->pot);
fprintf(log_fp, "%9.2f - %s %s %.2f\n",
p_symbols->sym()->balance[10],
fcra_seen.GetString(),
fcra_formula_status.GetString(),
p_symbols->f$betsize() );
if (prefs.trace_enabled() && p_symbols->symboltrace_collection()->GetSize() > 0)
{
write_log_nostamp(1, "***** Autoplayer Trace ****\n");
for (int i=0; i<p_symbols->symboltrace_collection()->GetSize(); i++)
{
write_log_nostamp(1, "%s\n", p_symbols->symboltrace_collection()->GetAt(i));
}
write_log_nostamp(1, "***********************\n");
}
fflush(log_fp);
}
}
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;
}
