// Evaluate the best 7 card hand given our hole cards and 5 common_cards
// TODO: Change this to evalute best 5+ card hand
// TODO: Change this to store common cards (so we can print it out later)
unsigned int Hand::Evaluate(const CommonCards& common_cards)
{
CardMask eval_cards;
// char buf[256];
// Debug::log(LDEBUG) << "Hand: " << (*this) << std::endl;
// Debug::log(LDEBUG) << "Common cards: " << common_cards << std::endl;
// Set a poker-eval card mask with the values of all the cards
CardMask_RESET(eval_cards);
CardMask_SET(eval_cards, pokereval_cards[0]);
CardMask_SET(eval_cards, pokereval_cards[1]);
CardMask_SET(eval_cards, ConvertCardToPokerEvalCard(common_cards.flop1));
CardMask_SET(eval_cards, ConvertCardToPokerEvalCard(common_cards.flop2));
CardMask_SET(eval_cards, ConvertCardToPokerEvalCard(common_cards.flop3));
CardMask_SET(eval_cards, ConvertCardToPokerEvalCard(common_cards.turn));
CardMask_SET(eval_cards, ConvertCardToPokerEvalCard(common_cards.river));
// StdDeck_maskToString(eval_cards, buf);
// Debug::log(LDEBUG) << "Mask: " << buf << std::endl;
// Get my handval/pokerval
hand_value = Hand_EVAL_N(eval_cards, 7);
// StdRules_HandVal_toString(hand_value, buf);
// Debug::log(LDEBUG) << "Hand_EVAL_N: " << buf << std::endl << std::endl;
return hand_value;
}
int
main(int argc, char **argv) {
HandVal handval;
LowHandVal low;
gNCards = 0;
CardMask_RESET(gCards);
parseArgs(argc, argv);
if (!gLow) {
handval = Hand_EVAL_N(gCards, gNCards);
printf("%s: ", Deck_maskString(gCards));
HandVal_print(handval);
printf("\n");
};
if (gLow || gHighLow) {
#if defined(Hand_EVAL_LOW)
if (gNCards < 5)
printf("Not enough cards to evaluate low hand\n");
else {
low = Hand_EVAL_LOW(gCards, gNCards);
printf("%s (low): ", Deck_maskString(gCards));
LowHandVal_print(low);
printf("\n");
};
#else
printf("Low evaluator not available \n");
#endif
};
return 0;
}
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));
});
static PyObject*
poker_evaln(PyObject* self, PyObject *args)
{
CardMask cards;
PyObject* pycards;
HandVal handval;
if (!PyArg_ParseTuple(args, "O", &pycards))
return NULL;
if(PyList2CardMask(pycards, &cards) < 0)
return NULL;
handval = Hand_EVAL_N(cards, PyList_Size(pycards));
return Py_BuildValue("i", handval);
}
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);
});
bool CVersus::GetCounts(void)
{
if (_versus_fh == k_undefined)
return false;
int i = 0, j = 0;
CardMask plCards, oppCards, deadCards, comCardsScrape, comCardsEnum, comCardsAll, usedCards;
unsigned int wintemp = 0, tietemp = 0, lostemp = 0, offset = 0;
unsigned int nhiwin = 0, nhitie = 0, nhilos = 0, ntiwin = 0, ntitie = 0, ntilos = 0, nlowin = 0, nlotie = 0, nlolos = 0;
unsigned int nhinowwin = 0, nhinowtie = 0, nhinowlos = 0, ntinowwin = 0, ntinowtie = 0, ntinowlos = 0, nlonowwin = 0, nlonowtie = 0, nlonowlos = 0;
unsigned int c0rank = 0, c1rank = 0, temprank = 0;
BYTE byte[8] = {0};
long pos = 0;
int listnum = 0;
int card0_offset[52] = { 0, 62475, 123725, 183750, 242550, 300125, 356475, 411600, 465500, 518175, 569625,
619850, 668850, 716625, 763175, 808500, 852600, 895475, 937125, 977550, 1016750,
1054725, 1091475, 1127000, 1161300, 1194375, 1226225, 1256850, 1286250, 1314425,
1341375, 1367100, 1391600, 1414875, 1436925, 1457750, 1477350, 1495725, 1512875,
1528800, 1543500, 1556975, 1569225, 1580250, 1590050, 1598625, 1605975, 1612100,
1617000, 1620675, 1623125, 1624350
};
int betround = p_betround_calculator->betround();
int sym_userchair = (int) p_symbol_engine_userchair->userchair();
unsigned int pcard[2] = {0};
for (i=0; i<=1; i++)
pcard[i] = CARD_NOCARD;
unsigned int card_player[2] = {0}, card_common[5] = {0};
for (i=0; i<=1; i++)
card_player[i] = p_scraper->card_player(sym_userchair, i);
for (i=0; i<=4; i++)
card_common[i] = p_scraper->card_common(i);
// Get the lock
CSLock lock(m_critsec);
if (!p_symbol_engine_userchair->userchair_confirmed())
return false;
if (card_player[0] == CARD_NOCARD || card_player[0] == CARD_BACK ||
card_player[1] == CARD_NOCARD || card_player[1] == CARD_BACK)
{
return false;
}
_nwin = _ntie = _nlos = _nhands = 0;
_nhandshi = _nhandsti = _nhandslo = 0;
_nhandshinow = _nhandstinow = _nhandslonow = 0;
_vsprwinhi = _vsprtiehi = _vsprloshi = 0;
_vsprwinti = _vsprtieti = _vsprlosti = 0;
_vsprwinlo = _vsprtielo = _vsprloslo = 0;
_vsprwinhinow = _vsprtiehinow = _vsprloshinow = 0;
_vsprwintinow = _vsprtietinow = _vsprlostinow = 0;
_vsprwinlonow = _vsprtielonow = _vsprloslonow = 0;
nhiwin = nhitie = nhilos = ntiwin = ntitie = ntilos = nlowin = nlotie = nlolos = 0;
// Clear counters
for (listnum=0; listnum<MAX_HAND_LISTS; listnum++)
_nlistwin[listnum] = _nlisttie[listnum] = _nlistlos[listnum] = 0;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// PREFLOP
if (betround == k_betround_preflop)
{
// order cards properly
if (card_player[0] < card_player[1])
{
pcard[0] = card_player[0];
pcard[1] = card_player[1];
}
else
{
pcard[0] = card_player[1];
pcard[1] = card_player[0];
}
// figure out offset into file
offset = 0;
//for (i=1; i<pcard[0]; i++) offset += (52-i)*1225;
offset += card0_offset[pcard[0]];
offset += (pcard[1]-pcard[0]-1)*1225;
offset *= sizeof(byte);
// seek to right position in file
if ((pos = _lseek(_versus_fh, offset, SEEK_SET)) == long(k_undefined))
{
return false;
}
wintemp = lostemp = 0;
for (i=0; i<(k_number_of_cards_per_deck - 1); i++)
{
for (j=i+1; j<k_number_of_cards_per_deck; j++)
{
if (i!=pcard[0] && i!=pcard[1] && j!=pcard[0] && j!=pcard[1])
{
_read(_versus_fh, &byte, sizeof(byte));
memcpy(&wintemp, &byte[0], sizeof(unsigned int));
memcpy(&lostemp, &byte[4], sizeof(unsigned int));
_nwin += wintemp;
_ntie += 1712304 - wintemp - lostemp;
_nlos += lostemp;
_nhands = _nhands + 1;
if (wintemp<lostemp)
{
_nhandshi = _nhandshi + 1;
nhiwin += wintemp;
nhitie += 1712304 - wintemp - lostemp;
nhilos += lostemp;
}
else if (wintemp>lostemp)
{
_nhandslo = _nhandslo + 1;
nlowin += wintemp;
nlotie += 1712304 - wintemp - lostemp;
nlolos += lostemp;
}
else
{
_nhandsti = _nhandsti + 1;
ntiwin += wintemp;
ntitie += 1712304 - wintemp - lostemp;
ntilos += lostemp;
}
// Calculations for vs$xx$prwin, vs$xx$prtie, vs$xx$prlos
c0rank = StdDeck_RANK(i);
c1rank = StdDeck_RANK(j);
if (c0rank < c1rank)
{
temprank = c0rank;
c0rank = c1rank;
c1rank = temprank;
}
for (listnum=0; listnum<MAX_HAND_LISTS; listnum++)
{
if ((StdDeck_SUIT(i)==StdDeck_SUIT(j) && p_formula->formula()->inlist[listnum][c0rank][c1rank]) ||
(StdDeck_SUIT(i)!=StdDeck_SUIT(j) && p_formula->formula()->inlist[listnum][c1rank][c0rank]))
{
_nlistwin[listnum] += wintemp;
_nlisttie[listnum] += 1712304 - wintemp - lostemp;
_nlistlos[listnum] += lostemp;
}
}
}
}
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// FLOP, TURN, RIVER
else if (betround >= k_betround_flop)
{
CardMask playerEvalCardsNow, oppEvalCardsNow;
HandVal player_hv_now = 0, opp_hv_now = 0;
// Common cards
CardMask_RESET(comCardsScrape);
if (betround >= k_betround_flop) CardMask_SET(comCardsScrape, card_common[0]);
if (betround >= k_betround_flop) CardMask_SET(comCardsScrape, card_common[1]);
if (betround >= k_betround_flop) CardMask_SET(comCardsScrape, card_common[2]);
if (betround >= k_betround_turn) CardMask_SET(comCardsScrape, card_common[3]);
if (betround >= k_betround_river) CardMask_SET(comCardsScrape, card_common[4]);
// player cards
CardMask_RESET(plCards);
CardMask_SET(plCards, card_player[0]);
CardMask_SET(plCards, card_player[1]);
// all used cards
CardMask_OR(usedCards, comCardsScrape, plCards);
// eval player hand now
CardMask_OR(playerEvalCardsNow, plCards, comCardsScrape);
player_hv_now = Hand_EVAL_N(playerEvalCardsNow, betround+3);
// Enumerate through all possible opponent hands (excludes already used cards)
for (i=0; i<=50; i++)
{
for (j=i+1; j<=51; j++)
{
if (!CardMask_CARD_IS_SET(usedCards, i) && !CardMask_CARD_IS_SET(usedCards, j))
{
CardMask_RESET(oppCards);
CardMask_SET(oppCards, i);
CardMask_SET(oppCards, j);
// Enumerate through all possible river situations (exclude player cards and opponent cards)
CardMask_OR(deadCards, usedCards, oppCards);
wintemp = tietemp = lostemp = 0;
if (betround==k_betround_flop || betround==k_betround_turn)
{
ENUMERATE_N_CARDS_D(comCardsEnum, betround==k_betround_flop ? 2 :
betround==k_betround_turn ? 1 : 0, deadCards,
{
CardMask_OR(comCardsAll, comCardsScrape, comCardsEnum);
DoCalc(plCards, oppCards, comCardsAll, &wintemp, &tietemp, &lostemp);
});
}
void COpenHoldemStatusbar::ComputeCurrentStatus() {
CardMask Cards;
CString temp;
int userchair = p_symbol_engine_userchair->userchair();
// Player cards
CardMask_RESET(Cards);
int nCards = 0;
_status_plcards = "";
if (p_table_state->User()->HasKnownCards()) {
for (int i=0; i<k_number_of_cards_per_player; i++) {
// This condition got already checked: "playing"
Card card = p_table_state->User()->_hole_cards[i];
// Assertion removeed, because the scraper runs in a different thread.
// assert(card.IsKnownCard());
_status_plcards.Append(card.ToString());
CardMask_SET(Cards, card.GetValue());
nCards++;
}
_status_nopp.Format("%d", p_symbol_engine_prwin->nopponents_for_prwin());
} else {
for (int i=0; i<k_number_of_cards_per_player; i++) {
if (p_table_state->User()->HasKnownCards()) {
Card card = p_table_state->User()->_hole_cards[i];
_status_plcards.Append(card.ToString());
CardMask_SET(Cards, card.GetValue());
nCards++;
}
}
// Not playing, therefore no opponents to be considered for prwin.
_status_nopp = "";
}
// Common cards
_status_comcards = "";
for (int i=0; i<k_number_of_community_cards; i++) {
Card card = p_table_state->_common_cards[i];
if (card.IsKnownCard()) {
_status_comcards.Append(card.ToString());
CardMask_SET(Cards, card.GetValue());
nCards++;
}
}
// poker hand
HandVal hv = Hand_EVAL_N(Cards, nCards);
char hvstring[100] = {0};
HandVal_toString(hv, hvstring);
_status_pokerhand = hvstring;
_status_pokerhand = _status_pokerhand.Mid(0, _status_pokerhand.Find(" "));
// Always use handrank169 here
_status_handrank.Format("%.0f/169", p_symbol_engine_handrank->handrank169());
// Always update prwin/nit
if (p_symbol_engine_userchair->userchair_confirmed()
&& p_table_state->User()->HasKnownCards()) {
_status_prwin.Format("%d/%d/%d",
(int) (p_iterator_thread->prwin()*1000),
(int) (p_iterator_thread->prtie()*1000),
(int) (p_iterator_thread->prlos()*1000));
double iterations;
p_engine_container->EvaluateSymbol("f$prwin_number_of_iterations", &iterations);
_status_nit.Format("%d/%s",
p_iterator_thread->IteratorThreadProgress(),
Number2CString(iterations));
} else {
_status_prwin = "0/0/0";
// No iteratrions without userchair or cards
_status_nit.Format("0");
}
}
void CSymbolEnginePrwin::CalculateNhands()
{
CardMask plCards = {0}, comCards = {0}, oppCards = {0}, playerEvalCards = {0}, opponentEvalCards = {0};
HandVal hv_player = 0, hv_opponent = 0;
unsigned int pl_pokval = 0, opp_pokval = 0;
int dummy = 0;
int nplCards, ncomCards;
_nhandshi = 0;
_nhandsti = 0;
_nhandslo = 0;
// player cards
CardMask_RESET(plCards);
nplCards = 0;
for (int i=0; i<k_number_of_cards_per_player; i++)
{
if (p_scraper_access->IsKnownCard(p_scraper->card_player(USER_CHAIR, i)))
{
CardMask_SET(plCards, p_scraper->card_player(USER_CHAIR, i));
nplCards++;
}
}
// common cards
CardMask_RESET(comCards);
ncomCards = 0;
for (int i=0; i<k_number_of_community_cards; i++)
{
if (p_scraper_access->IsKnownCard(p_scraper->card_common(i)))
{
CardMask_SET(comCards, p_scraper->card_common(i));
ncomCards++;
}
}
// player/common cards and pokerval
CardMask_OR(playerEvalCards, plCards, comCards);
hv_player = Hand_EVAL_N(playerEvalCards, nplCards+ncomCards);
pl_pokval = p_symbol_engine_pokerval->CalculatePokerval(hv_player,
nplCards+ncomCards, &dummy, CARD_NOCARD, CARD_NOCARD);
for (int i=0; i<(k_number_of_cards_per_deck-1); i++)
{
for (int j=(i+1); j<k_number_of_cards_per_deck; j++)
{
if (!CardMask_CARD_IS_SET(plCards, i)
&& !CardMask_CARD_IS_SET(plCards, j)
&& !CardMask_CARD_IS_SET(comCards, i)
&& !CardMask_CARD_IS_SET(comCards, j))
{
// opponent cards
CardMask_RESET(oppCards);
CardMask_SET(oppCards, i);
CardMask_SET(oppCards, j);
CardMask_OR(opponentEvalCards, oppCards, comCards);
hv_opponent = Hand_EVAL_N(opponentEvalCards, 2+ncomCards);
opp_pokval = p_symbol_engine_pokerval->CalculatePokerval(hv_opponent,
(k_number_of_cards_per_player + ncomCards),
&dummy, CARD_NOCARD, CARD_NOCARD);
if (pl_pokval > opp_pokval)
{
_nhandslo++;
}
else if (pl_pokval < opp_pokval)
{
_nhandshi++;
}
else
{
_nhandsti++;
}
}
}
}
AssertRange(_nhandshi, 0, nhands());
AssertRange(_nhandsti, 0, nhands());
AssertRange(_nhandslo, 0, nhands());
assert((_nhandshi + _nhandsti + _nhandslo) == nhands());
_prwinnow = pow(((double)_nhandslo/nhands()), _nopponents_for_prwin);
_prlosnow = 1 - pow((((double)_nhandslo + _nhandsti)/nhands()), _nopponents_for_prwin);
AssertRange(_prwinnow, 0, 1);
AssertRange(_prlosnow, 0, 1);
}
UINT CIteratorThread::IteratorThreadFunction(LPVOID pParam)
{
CIteratorThread *pParent = static_cast<CIteratorThread*>(pParam);
// Loop-variables j, k get used inside and outside loops.
// It is a bit messy, nearly impossible to fix it.
// At least the outer loops ("f$prwin_number_of_iterations" and "i") could be improved.
unsigned int pl_pokval = 0, opp_pokval = 0, opp_pokvalmax = 0;
HandVal pl_hv = 0, opp_hv = 0;
int dummy = 0;
int sym_nopponents = p_symbol_engine_prwin->nopponents_for_prwin();
bool hand_lost;
ResetGlobalVariables();
// Seed the RNG
srand((unsigned)GetTickCount());
//
// Main iterator loop
//
write_log(preferences.debug_prwin(), "[PrWinThread] Start of main loop.\n");
// "f$prwin_number_of_iterations" has to be declared outside of the loop,
// as we check afterwards, if the loop terminated successfully.
AdjustPrwinVariablesIfNecessary(pParent);
unsigned int nit;
for (nit=0; nit < iter_vars.nit(); nit++)
{
// Check event for thread stop signal
if(::WaitForSingleObject(pParent->_m_stop_thread, 0) == WAIT_OBJECT_0)
{
// Set event
::SetEvent(pParent->_m_wait_thread);
AfxEndThread(0);
}
CardMask_OR(usedCards, pParent->_plCards, pParent->_comCards);
if (UseEnhancedPrWin())
{
EnhancedDealingAlgorithm();
}
else
{
StandardDealingAlgorithm(sym_nopponents);
}
// Get my handval/pokerval
CardMask_OR(evalCards, pParent->_plCards, pParent->_comCards);
CardMask_OR(evalCards, evalCards, addlcomCards);
pl_hv = Hand_EVAL_N(evalCards, 7);
pl_pokval = p_symbol_engine_pokerval->CalculatePokerval(pl_hv, 7, &dummy, CARD_NOCARD, CARD_NOCARD);
// Scan through opponents' handvals/pokervals
// - if we find one better than ours, then we are done, increment los
// - for win/tie, we need to wait until we scan them all
opp_pokvalmax = 0;
hand_lost = false;
for (int i=0; i<sym_nopponents; i++)
{
CardMask_RESET(opp_evalCards);
CardMask_OR(opp_evalCards, pParent->_comCards, addlcomCards);
CardMask_SET(opp_evalCards, ocard[i*2]);
CardMask_SET(opp_evalCards, ocard[(i*2)+1]);
opp_hv = Hand_EVAL_N(opp_evalCards, 7);
opp_pokval = p_symbol_engine_pokerval->CalculatePokerval(opp_hv, 7, &dummy, CARD_NOCARD, CARD_NOCARD);
if (opp_pokval>pl_pokval)
{
_los++;
hand_lost = true;
break;
}
else
{
if (opp_pokval > opp_pokvalmax)
{
opp_pokvalmax = opp_pokval;
}
}
}
if (!hand_lost)
{
if (pl_pokval > opp_pokvalmax)
{
_win++;
}
else
{
_tie++;
}
}
UpdateIteratorVarsForDisplay(nit);
}
write_log(preferences.debug_prwin(), "[PrWinThread] End of main loop.\n");
if (SimulationFinished(nit))
{
iter_vars.set_iterator_thread_running(false);
iter_vars.set_iterator_thread_complete(true);
UpdateIteratorVarsForDisplay(nit);
}
else
{
iter_vars.set_iterator_thread_running(false);
iter_vars.set_iterator_thread_complete(false);
iter_vars.set_iterator_thread_progress(0); //???
iter_vars.set_nit(0);
for (int i=0; i<k_number_of_cards_per_player; i++)
iter_vars.set_pcard(i, CARD_NOCARD);
for (int i=0; i<k_number_of_community_cards; i++)
{
iter_vars.set_ccard(i, CARD_NOCARD);
}
ResetIteratorVars();
}
::SetEvent(pParent->_m_wait_thread);
StopIteratorThread();
return 0;
}
UINT CIteratorThread::IteratorThreadFunction(LPVOID pParam) {
CIteratorThread *pParent = static_cast<CIteratorThread*>(pParam);
// Loop-variables j, k get used inside and outside loops.
// It is a bit messy, nearly impossible to fix it.
// At least the outer loops ("f$prwin_number_of_iterations" and "i") could be improved.
unsigned int pl_pokval = 0, opp_pokval = 0, opp_pokvalmax = 0;
HandVal pl_hv = 0, opp_hv = 0;
int dummy = 0, enhanced_dealing_return=0;
bool hand_lost;
ResetGlobalVariables();
// Seed the RNG
srand((unsigned)GetTickCount());
while (true) {
// Check event for thread stop signal once per main iterator loop
// (and additionally once every 1000 iterations later)
if(::WaitForSingleObject(pParent->_m_stop_thread, 0) == WAIT_OBJECT_0) {
// Set event
::SetEvent(pParent->_m_wait_thread);
AfxEndThread(0);
}
Sleep(500);
if (!p_symbol_engine_autoplayer->ismyturn()) {
// Not my turn;
// Nothing to simulate
continue;
}
if (IteratorThreadComplete()) {
// No longer anything to do
continue;
}
write_log(preferences.debug_prwin(), "[PrWinThread] Start of main loop.\n");
// "f$prwin_number_of_iterations" has to be declared outside of the loop,
// as we check afterwards, if the loop terminated successfully.
_nopponents = p_symbol_engine_prwin->nopponents_for_prwin();
AdjustPrwinVariablesIfNecessary();
LARGE_INTEGER frequency; // ticks per second
LARGE_INTEGER t1, t2; // ticks
double elapsedTime = 0;
QueryPerformanceFrequency(&frequency); // get ticks per second
CalculateTotalWeights();
//
// Main iterator loop
//
for (_iterations_calculated=0; _iterations_calculated < _iterations_required; ++_iterations_calculated) {
// Check event for thread stop signal once every 1000 iterations
if ((_iterations_calculated % 1000 == 0)
&& (_iterations_calculated > 0)
&& (::WaitForSingleObject(pParent->_m_stop_thread, 0) == WAIT_OBJECT_0)) {
// Set event
::SetEvent(pParent->_m_wait_thread);
AfxEndThread(0);
}
CardMask_OR(usedCards, pParent->_plCards, pParent->_comCards);
if (UseEnhancedPrWin()) {
QueryPerformanceCounter(&t1); // start timer
enhanced_dealing_return = EnhancedDealingAlgorithm();
if (enhanced_dealing_return < 0) {
_prwin = enhanced_dealing_return;
_prtie = enhanced_dealing_return;
_prlos = enhanced_dealing_return;
_iterations_calculated = _iterations_required;
write_log(preferences.debug_prwin(), "[PrWinThread] Chair's %i range consists of dead cards only.\n",enhanced_dealing_return);
break;
}
QueryPerformanceCounter(&t2); // stop timer
elapsedTime = elapsedTime + (t2.QuadPart - t1.QuadPart) * 1000.0 / frequency.QuadPart; // compute the elapsed time in millisec
} else {
QueryPerformanceCounter(&t1); // start timer
StandardDealingAlgorithm(_nopponents);
QueryPerformanceCounter(&t2); // stop timer
elapsedTime = elapsedTime + (t2.QuadPart - t1.QuadPart) * 1000.0 / frequency.QuadPart; // compute the elapsed time in millisec
}
// Get my handval/pokerval
CardMask_OR(evalCards, pParent->_plCards, pParent->_comCards);
CardMask_OR(evalCards, evalCards, addlcomCards);
pl_hv = Hand_EVAL_N(evalCards, 7);
pl_pokval = p_symbol_engine_pokerval->CalculatePokerval(pl_hv, 7, &dummy, CARD_NOCARD, CARD_NOCARD);//??
// Scan through opponents' handvals/pokervals
// - if we find one better than ours, then we are done, increment los
// - for win/tie, we need to wait until we scan them all
opp_pokvalmax = 0;
hand_lost = false;
for (int i=0; i<_nopponents; i++) {
CardMask_RESET(opp_evalCards);
CardMask_OR(opp_evalCards, pParent->_comCards, addlcomCards);
CardMask_SET(opp_evalCards, ocard[i*2]);
CardMask_SET(opp_evalCards, ocard[(i*2)+1]);
opp_hv = Hand_EVAL_N(opp_evalCards, 7);
opp_pokval = p_symbol_engine_pokerval->CalculatePokerval(opp_hv, 7, &dummy, CARD_NOCARD, CARD_NOCARD);
write_log(preferences.debug_prwin(), "[PrWinThread] PlayerPV: %i OppPV: %i\n",
pl_pokval, opp_pokval);
if (opp_pokval > pl_pokval) {
write_log(preferences.debug_prwin(), "[PrWinThread] Lost\n");
_los++;
hand_lost = true;
break;
} else {
if (opp_pokval > opp_pokvalmax)
{
opp_pokvalmax = opp_pokval;
}
}
}
if (!hand_lost) {
if (pl_pokval > opp_pokvalmax) {
write_log(preferences.debug_prwin(), "[PrWinThread] Won\n");
_win++;
} else {
write_log(preferences.debug_prwin(), "[PrWinThread] Tie\n");
_tie++;
}
}
UpdateIteratorVarsForDisplay();
}
write_log(preferences.debug_prwin(), "[PrWinThread] End of main loop.\n");
if (!IteratorThreadComplete()) {
// Computation stopped with some kind of error.
// Reset vars to avoid bogus data
ResetIteratorVars();
}
if(enhanced_dealing_return == 0)
{
UpdateIteratorVarsForDisplay(); //calculates _prwin, _prtie, _prlos
}
if(UseEnhancedPrWin())
{
write_log(preferences.debug_prwin(), "EnhancedDealingAlgorithm elapsed time in millisec: %.3f Iterations: %d prwin: %.3f prtie: %.3f prlos: %.3f vanilla.limit: %i \n",
elapsedTime,_iterations_calculated, _prwin, _prtie, _prlos, _prw1326.vanilla_chair.limit );
}
else
{
write_log(preferences.debug_prwin(), "StandardDealingAlgorithm elapsed time in millisec: %.3f Iterations: %d prwin: %.3f prtie: %.3f prlos: %.3f\n",
elapsedTime,_iterations_calculated, _prwin, _prtie, _prlos);
}
::SetEvent(pParent->_m_wait_thread);
}
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;
}
}
);
UINT CIteratorThread::IteratorThreadFunction(LPVOID pParam) {
CIteratorThread *pParent = static_cast<CIteratorThread*>(pParam);
// Loop-variables j, k get used inside and outside loops.
// It is a bit messy, nearly impossible to fix it.
// At least the outer loops ("f$prwin_number_of_iterations" and "i") could be improved.
unsigned int pl_pokval = 0, opp_pokval = 0, opp_pokvalmax = 0;
HandVal pl_hv = 0, opp_hv = 0;
int dummy = 0;
bool hand_lost;
ResetGlobalVariables();
// Seed the RNG
srand((unsigned)GetTickCount());
while (true) {
// Check event for thread stop signal once per main iterator loop
// (and additionally once every 1000 iterations later)
if(::WaitForSingleObject(pParent->_m_stop_thread, 0) == WAIT_OBJECT_0) {
// Set event
::SetEvent(pParent->_m_wait_thread);
AfxEndThread(0);
}
Sleep(500);
if (!p_symbol_engine_autoplayer->ismyturn()) {
// Not my turn;
// Nothing to simulate
continue;
}
if (IteratorThreadComplete()) {
// No longer anything to do
continue;
}
//
// Main iterator loop
//
write_log(preferences.debug_prwin(), "[PrWinThread] Start of main loop.\n");
// "f$prwin_number_of_iterations" has to be declared outside of the loop,
// as we check afterwards, if the loop terminated successfully.
_nopponents = p_symbol_engine_prwin->nopponents_for_prwin();
AdjustPrwinVariablesIfNecessary();
for (_iterations_calculated=0; _iterations_calculated < _iterations_required; ++_iterations_calculated) {
// Check event for thread stop signal once every 1000 iterations
if ((_iterations_calculated % 1000 == 0)
&& (_iterations_calculated > 0)
&& (::WaitForSingleObject(pParent->_m_stop_thread, 0) == WAIT_OBJECT_0)) {
// Set event
::SetEvent(pParent->_m_wait_thread);
AfxEndThread(0);
}
CardMask_OR(usedCards, pParent->_plCards, pParent->_comCards);
if (UseEnhancedPrWin()) {
EnhancedDealingAlgorithm();
} else {
StandardDealingAlgorithm(_nopponents);
}
// Get my handval/pokerval
CardMask_OR(evalCards, pParent->_plCards, pParent->_comCards);
CardMask_OR(evalCards, evalCards, addlcomCards);
pl_hv = Hand_EVAL_N(evalCards, 7);
pl_pokval = p_symbol_engine_pokerval->CalculatePokerval(pl_hv, 7, &dummy, CARD_NOCARD, CARD_NOCARD);//??
// Scan through opponents' handvals/pokervals
// - if we find one better than ours, then we are done, increment los
// - for win/tie, we need to wait until we scan them all
opp_pokvalmax = 0;
hand_lost = false;
for (int i=0; i<_nopponents; i++) {
CardMask_RESET(opp_evalCards);
CardMask_OR(opp_evalCards, pParent->_comCards, addlcomCards);
CardMask_SET(opp_evalCards, ocard[i*2]);
CardMask_SET(opp_evalCards, ocard[(i*2)+1]);
opp_hv = Hand_EVAL_N(opp_evalCards, 7);
opp_pokval = p_symbol_engine_pokerval->CalculatePokerval(opp_hv, 7, &dummy, CARD_NOCARD, CARD_NOCARD);
write_log(preferences.debug_prwin(), "[PrWinThread] PlayerPV: %i OppPV: %i\n",
pl_pokval, opp_pokval);
if (opp_pokval > pl_pokval) {
write_log(preferences.debug_prwin(), "[PrWinThread] Lost\n");
_los++;
hand_lost = true;
break;
} else {
if (opp_pokval > opp_pokvalmax) {
opp_pokvalmax = opp_pokval;
}
}
}
if (!hand_lost) {
if (pl_pokval > opp_pokvalmax) {
write_log(preferences.debug_prwin(), "[PrWinThread] Won\n");
_win++;
} else {
write_log(preferences.debug_prwin(), "[PrWinThread] Tie\n");
_tie++;
}
}
UpdateIteratorVarsForDisplay();
}
write_log(preferences.debug_prwin(), "[PrWinThread] End of main loop.\n");
if (!IteratorThreadComplete()) {
// Computation stopped with some kind of error.
// Reset vars to avoid bogus data
ResetIteratorVars();
}
UpdateIteratorVarsForDisplay();
::SetEvent(pParent->_m_wait_thread);
}
return 0;
}
UINT CIteratorThread::IteratorThreadFunction(LPVOID pParam)
{
CIteratorThread *pParent = static_cast<CIteratorThread*>(pParam);
// Loop-variables j, k get used inside and outside loops.
// It is a bit messy, nearly impossible to fix it.
// At least the outer loops ("f$prwin_number_of_iterations" and "i") could be improved.
int j = 0, k = 0;
int randfix = 0;
CardMask addlcomCards = {0}, evalCards = {0}, opp_evalCards = {0}, usedCards = {0}, temp_usedCards = {0};
unsigned int ocard[MAX_OPPONENTS*2] = {0}, card = 0, pl_pokval = 0, opp_pokval = 0, opp_pokvalmax = 0;
HandVal pl_hv = 0, opp_hv = 0;
int dummy = 0;
int deck[k_number_of_cards_per_deck] = {0}, x = 0;
int numberOfCards = 0;
int betround = p_betround_calculator->betround();
int sym_playersplayingbits = p_symbol_engine_active_dealt_playing->playersplayingbits();
double sym_nbetsround = p_symbol_engine_history->nbetsround(betround);
int sym_bblindbits = p_symbol_engine_blinds->bblindbits();
bool sym_didcall = p_symbol_engine_history->didcall(betround);
int sym_nopponents = p_symbol_engine_prwin->nopponents_for_prwin();
int nopp = sym_nopponents <= MAX_OPPONENTS ? sym_nopponents : MAX_OPPONENTS;
bool hand_lost;
// Seed the RNG
srand((unsigned)GetTickCount());
//
// Main iterator loop
//
write_log(prefs.debug_prwin(), "[PrWinThread] Start of main loop.\n");
// "f$prwin_number_of_iterations" has to be declared outside of the loop,
// as we check afterwards, if the loop terminated successfully.
unsigned int nit;
for (nit=0; nit < iter_vars.nit(); nit++)
{
// Check event for thread stop signal
if(::WaitForSingleObject(pParent->_m_stop_thread, 0) == WAIT_OBJECT_0)
{
// Set event
::SetEvent(pParent->_m_wait_thread);
AfxEndThread(0);
}
CardMask_OR(usedCards, pParent->_plCards, pParent->_comCards);
//Correct the protection aganst low f$willplay/f$wontplay - Matrix 2008-12-22
if (pParent->_willplay && (pParent->_willplay<nopp*2+1) )
{
write_log(prefs.debug_prwin(), "[PrWinThread] Adjusting willplay (too low)\n");
pParent->_willplay=nopp*2+1; //too low a value can give lockup
}
if (pParent->_wontplay<pParent->_willplay)
{
write_log(prefs.debug_prwin(), "[PrWinThread] Adjusting wontplay (too low)\n");
pParent->_wontplay=pParent->_willplay; //wontplay cannot safely be less than willplay
}
if (_prw1326.useme==1326 && (betround>=k_betround_flop || _prw1326.preflop==1326))
{
write_log(prefs.debug_prwin(), "[PrWinThread] Using Matrix's enhanced prwin.\n");
//prw1326 active Matrix 2008-05-08
k = nopp = 0; //k is used as an index into ocard[]
// loop through active opponents
for(int i=0; i<k_max_number_of_players; i++)
{
if (i==(int) p_symbol_engine_userchair->userchair())
continue; //skip our own chair!
if (!((sym_playersplayingbits) & (1<<i)))
continue; //skip inactive chairs
nopp++; //we have to use actual opponents for prw1326 calculations
// first deal with the special non-weighted cases
// player who is marked 'ignore' or one who is BB and has not VPIP'd
if (_prw1326.chair[i].ignore ||
(_prw1326.bblimp && sym_nbetsround<1.1 && (sym_bblindbits&(1<<i))) )
{
do
{
card = rand() & 63;
}
while (card>51 || CardMask_CARD_IS_SET(usedCards, card));
CardMask_SET(usedCards, card);
ocard[k++] = card;
do
{
card = rand() & 63;
}
while (card>51 || CardMask_CARD_IS_SET(usedCards, card));
CardMask_SET(usedCards, card);
ocard[k++] = card;
continue;
} // end of special non-weighted cases
randfix=(RAND_MAX/_prw1326.chair[i].limit) * _prw1326.chair[i].limit;
while (true)
{ //find a possible hand for this chair NOTE: may want to put in loop limits to prevent hanging
do
{
j=rand();
} while (j>=randfix);
j = j % _prw1326.chair[i].limit; //j is now any one of the allowed hands
if(CardMask_CARD_IS_SET(usedCards, _prw1326.chair[i].rankhi[j] ))
continue; //hand contains dead card
if(CardMask_CARD_IS_SET(usedCards, _prw1326.chair[i].ranklo[j] ))
continue; //hand contains dead card
// if(symbols.prw1326.chair[i].ignore)break; //chair marked as not to be weighted
if(_prw1326.chair[i].level <= _prw1326.chair[i].weight[j])
break; //hand marked as always uae
//check if we want a player who is BB and has not VPIP'd to be analysed further
// if(symbols.prw1326.bblimp)
// {
// if ((symbols.sym.nbetsround[0]<1.1) && ((int)symbols.sym.bblindbits&(1<<i)))break;
// }
//we should really do a 'randfix' here for the case where RAND_MAX is not an integral
//multiple of .level, but the bias introduced is trivial compared to other uncertainties.
if(rand() % _prw1326.chair[i].level < _prw1326.chair[i].weight[j])
break; //allowable
//if we reach here we will loop again to find a suitable hand
} //end of possible hand find
ocard[k++] = _prw1326.chair[i].rankhi[j];
ocard[k++] = _prw1326.chair[i].ranklo[j];
CardMask_SET(usedCards, ocard[k-2]);
CardMask_SET(usedCards, ocard[k-1]);
} //end of active opponent loop
// additional common cards
CardMask_RESET(addlcomCards);
for (int i=0; i<(k_number_of_community_cards - pParent->_ncomCards); i++)
{
do
{
card = rand() & 63;
}
while (card>51 ||CardMask_CARD_IS_SET(usedCards, card));
CardMask_SET(usedCards, card);
CardMask_SET(addlcomCards, card);
}
} //end of prw1326 code
else
{
// normal prwin opponent card selection
write_log(prefs.debug_prwin(), "[PrWinThread] Using standard prwin.\n");
// if f$prwin_number_of_opponents<=13 then deal with random replacement algorithm, otherwise deal with swap algorithm
if (nopp <= 13)
{
write_log(prefs.debug_prwin(), "[PrWinThread] Using random algorithm, as f$prwin_number_of_opponents <= 13\n");
// random replacement algorithm
// opponent cards
if (nopp < 1)
{
write_log(prefs.debug_prwin(), "[PrWinThread] No opponents.\n");
}
for (int i=0; i<nopp*2; i+=2)
{
temp_usedCards=usedCards;
do
{
usedCards=temp_usedCards; //reset the card mask to clear settings from failed card assignments
do {
card = rand() & 63;
}
while (card>51 || CardMask_CARD_IS_SET(usedCards, card));
CardMask_SET(usedCards, card);
ocard[i] = card;
do {
card = rand() & 63;
}
while (card>51 || CardMask_CARD_IS_SET(usedCards, card));
CardMask_SET(usedCards, card);
ocard[i+1] = card;
if (!pParent->_willplay)
{
write_log(prefs.debug_prwin(), "[PrWinThread] Weighting disabled. Willplay is 0.\n");
break; //0 disables weighting
}
//put break for i=0 and opponent unraised BB case (cannot assume anything about his cards)
//In round 1 we should really do an analysis of chairs to find out how many have still to
//place a bet. Not implemented since accuracy of prwin pre-flop is less critical.
if (!i)
{
//if we called then we are not BB, BB limped to flop,
//BB still playing, so do not weight his cards
if (sym_nbetsround<1.1 && sym_didcall && (sym_playersplayingbits&sym_bblindbits) )
{
break;
}
}
}
while (!pParent->InRange(ocard[i], ocard[i+1], pParent->_willplay,
pParent->_wontplay, pParent->_topclip, pParent->_mustplay));
}
// additional common cards
CardMask_RESET(addlcomCards);
for (int i=0; i<(k_number_of_community_cards - pParent->_ncomCards); i++)
{
do {
card = rand() & 63;
}
while (card>51 ||CardMask_CARD_IS_SET(usedCards, card));
CardMask_SET(usedCards, card);
CardMask_SET(addlcomCards, card);
}
}
else
{
write_log(prefs.debug_prwin(), "[PrWinThread] Useing swap-algorithm, as f$prwin_number_of_opponents > 13\n");
// swap alogorithm
//weighted prwin not implemented for this case
numberOfCards=52;
for (int i=0; i<numberOfCards; i++)
deck[i] = i;
while (numberOfCards>=1)
{
x = rand() % numberOfCards;
numberOfCards--;
if (x != numberOfCards)
{
SwapInts(&deck[x], &deck[numberOfCards]);
}
}
// opponent cards
x = 0;
for (int i=0; i<nopp*2; i++)
{
while (CardMask_CARD_IS_SET(usedCards, deck[x]) && x<=51) {
x++;
}
ocard[i] = deck[x++];
}
// additional common cards
CardMask_RESET(addlcomCards);
for (int i=0; i<(k_number_of_community_cards - pParent->_ncomCards); i++)
{
while (CardMask_CARD_IS_SET(usedCards, deck[x]) && x<=51) {
x++;
}
CardMask_SET(addlcomCards, deck[x++]);
}
}
}
// Get my handval/pokerval
CardMask_OR(evalCards, pParent->_plCards, pParent->_comCards);
CardMask_OR(evalCards, evalCards, addlcomCards);
pl_hv = Hand_EVAL_N(evalCards, 7);
pl_pokval = p_symbol_engine_pokerval->CalculatePokerval(pl_hv, 7, &dummy, CARD_NOCARD, CARD_NOCARD);
// Scan through opponents' handvals/pokervals
// - if we find one better than ours, then we are done, increment los
// - for win/tie, we need to wait until we scan them all
opp_pokvalmax = 0;
hand_lost = false;
for (int i=0; i<nopp; i++)
{
CardMask_RESET(opp_evalCards);
CardMask_OR(opp_evalCards, pParent->_comCards, addlcomCards);
CardMask_SET(opp_evalCards, ocard[i*2]);
CardMask_SET(opp_evalCards, ocard[(i*2)+1]);
opp_hv = Hand_EVAL_N(opp_evalCards, 7);
opp_pokval = p_symbol_engine_pokerval->CalculatePokerval(opp_hv, 7, &dummy, CARD_NOCARD, CARD_NOCARD);
if (opp_pokval>pl_pokval)
{
pParent->_los++;
hand_lost = true;
break;
}
else
{
if (opp_pokval > opp_pokvalmax)
opp_pokvalmax = opp_pokval;
}
}
if (!hand_lost)
{
if (pl_pokval > opp_pokvalmax)
pParent->_win++;
else
pParent->_tie++;
}
// Update display once every 1000 iterations
if ((nit % 1000 == 0) && nit >= 1000)
{
write_log(prefs.debug_prwin(), "[PrWinThread] Progress: %d %.3f %.3f %.3f\n", nit, pParent->_win / (double) nit, pParent->_tie / (double) nit, pParent->_los / (double) nit);
iter_vars.set_iterator_thread_progress(nit);
iter_vars.set_prwin(pParent->_win / (double) nit);
iter_vars.set_prtie(pParent->_tie / (double) nit);
iter_vars.set_prlos(pParent->_los / (double) nit);
}
}
write_log(prefs.debug_prwin(), "[PrWinThread] End of main loop.\n");
if (nit >= iter_vars.nit())
{
iter_vars.set_iterator_thread_running(false);
iter_vars.set_iterator_thread_complete(true);
iter_vars.set_iterator_thread_progress(nit);
iter_vars.set_prwin(pParent->_win / (double) iter_vars.nit());
iter_vars.set_prtie(pParent->_tie / (double) iter_vars.nit());
iter_vars.set_prlos(pParent->_los / (double) iter_vars.nit());
}
else
{
iter_vars.set_iterator_thread_running(false);
iter_vars.set_iterator_thread_complete(false);
iter_vars.set_iterator_thread_progress(0);
iter_vars.set_nit(0);
iter_vars.set_f$p(0);
iter_vars.set_br(0);
for (int i=0; i<k_number_of_cards_per_player; i++)
iter_vars.set_pcard(i, CARD_NOCARD);
for (int i=0; i<k_number_of_community_cards; i++)
iter_vars.set_ccard(i, CARD_NOCARD);
iter_vars.set_prwin(0);
iter_vars.set_prtie(0);
iter_vars.set_prlos(0);
}
::SetEvent(pParent->_m_wait_thread);
delete p_iterator_thread;
p_iterator_thread = NULL;
return 0;
}
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*
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 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;
}
void CSymbolEnginePrwin::CalculateNhands() {
CardMask plCards = {0}, comCards = {0}, oppCards = {0}, playerEvalCards = {0}, opponentEvalCards = {0};
HandVal hv_player = 0, hv_opponent = 0;
unsigned int pl_pokval = 0, opp_pokval = 0;
int dummy = 0;
int nplCards, ncomCards;
_nhandshi = 0;
_nhandsti = 0;
_nhandslo = 0;
// player cards
CardMask_RESET(plCards);
nplCards = 0;
for (int i=0; i<kNumberOfCardsPerPlayer; i++) {
Card card = p_table_state->User()->_hole_cards[i];
if (card.IsKnownCard()) {
CardMask_SET(plCards, card.GetValue());
nplCards++;
}
}
// common cards
CardMask_RESET(comCards);
ncomCards = 0;
for (int i=0; i<kNumberOfCommunityCards; i++) {
Card card = p_table_state->_common_cards[i];
if (card.IsKnownCard()) {
CardMask_SET(comCards, card.GetValue());
ncomCards++;
}
}
// player/common cards and pokerval
CardMask_OR(playerEvalCards, plCards, comCards);
hv_player = Hand_EVAL_N(playerEvalCards, nplCards+ncomCards);
pl_pokval = p_symbol_engine_pokerval->CalculatePokerval(hv_player,
nplCards+ncomCards, &dummy, CARD_NOCARD, CARD_NOCARD);
for (int i=0; i<(kNumberOfCardsPerDeck-1); i++)
{
for (int j=(i+1); j<kNumberOfCardsPerDeck; j++)
{
if (!CardMask_CARD_IS_SET(plCards, i)
&& !CardMask_CARD_IS_SET(plCards, j)
&& !CardMask_CARD_IS_SET(comCards, i)
&& !CardMask_CARD_IS_SET(comCards, j))
{
// opponent cards
CardMask_RESET(oppCards);
CardMask_SET(oppCards, i);
CardMask_SET(oppCards, j);
CardMask_OR(opponentEvalCards, oppCards, comCards);
hv_opponent = Hand_EVAL_N(opponentEvalCards, 2+ncomCards);
opp_pokval = p_symbol_engine_pokerval->CalculatePokerval(hv_opponent,
(kNumberOfCardsPerPlayer + ncomCards),
&dummy, CARD_NOCARD, CARD_NOCARD);
if (pl_pokval > opp_pokval)
{
_nhandslo++;
}
else if (pl_pokval < opp_pokval)
{
_nhandshi++;
}
else
{
_nhandsti++;
}
}
}
}
AssertRange(_nhandshi, 0, nhands());
AssertRange(_nhandsti, 0, nhands());
AssertRange(_nhandslo, 0, nhands());
assert((_nhandshi + _nhandsti + _nhandslo) == nhands());
_prwinnow = pow(((double)_nhandslo/nhands()), _nopponents_for_prwin);
_prlosnow = 1 - pow((((double)_nhandslo + _nhandsti)/nhands()), _nopponents_for_prwin);
AssertRange(_prwinnow, 0, 1);
AssertRange(_prlosnow, 0, 1);
}
void GetHandState(const Hand& shand, PostFlopState* state)
{
ZeroPostFlopState(state);
if (!CollaspeCardMask(shand.common))
return; //This shouldn't be called pre flop.
{
CardMask first, second;
CardMask_OR(first, shand.firstHoleCard, shand.common);
CardMask_OR(second, shand.secondHoleCard, shand.common);
unsigned int bothRank = Hand_EVAL_N(shand.dead, shand.size);
unsigned int firstRank = Hand_EVAL_N(first, shand.size - 1);
unsigned int secondRank = Hand_EVAL_N(second, shand.size - 1);
unsigned int boardRank = Hand_EVAL_N(shand.common, shand.size - 2);
if (bothRank > firstRank && bothRank > secondRank)
state->UsesBoth = true;
else if (firstRank > boardRank || secondRank > boardRank)
state->UsesOne = true;
else
state->UsesNone = true;
}
int currentType = Hand_EVAL_TYPE(shand.dead, shand.size);
switch (currentType)
{
case StdRules_HandType_NOPAIR: state->IsNoPair = true; break;
case StdRules_HandType_ONEPAIR: state->IsOnePair = true; break;
case StdRules_HandType_TWOPAIR: state->IsTwoPair = true; break;
case StdRules_HandType_TRIPS: state->IsTrips = true; break;
case StdRules_HandType_STRAIGHT: state->IsStraight = true; break;
case StdRules_HandType_FLUSH: state->IsFlush = true; break;
case StdRules_HandType_FULLHOUSE: state->IsFullHouse = true; break;
case StdRules_HandType_QUADS: state->IsQuads = true; break;
case StdRules_HandType_STFLUSH: state->IsStFlush = true; break;
}
if (state->IsNoPair || state->IsOnePair) //Attempt to find out what kind of one pair or nothing.
{
uint32 board = CollaspeCardMask(shand.common); //Board cards.
uint32 h1Rank = CollaspeCardMask(shand.firstHoleCard); //Grab the first card.
uint32 h2Rank = CollaspeCardMask(shand.secondHoleCard); //second card.
//Loop through all the board card ranks until we find the highest card.
uint32 highestBoardCard;
for (uint32 i = 0x1000; true; i >>= 1) //Start with the 13th bit set for an ace.
if (board & i)
{
highestBoardCard = i;
break;
}
//Loop through all the board card ranks until we find the lowest card.
uint32 lowestBoardCard;
for (uint32 i = 1; true; i <<= 1) //Start with the 1 bit set for a duece.
if (board & i)
{
lowestBoardCard = i;
break;
}
if (h1Rank == highestBoardCard || h2Rank == highestBoardCard)
state->IsTopPair = true;
if (h1Rank == lowestBoardCard || h2Rank == lowestBoardCard)
state->IsBottomPair = true;
if (h1Rank == h2Rank && h1Rank > highestBoardCard)
state->IsOverPair = true;
else if (h1Rank > highestBoardCard && h2Rank > highestBoardCard)
state->IsOverCards = true;
else if (state->IsOnePair && !state->IsTopPair && !state->IsBottomPair)
state->IsMiddlePair = true;
}
