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;
}
Hand(CardMask firstHoleCard, CardMask secondHoleCard, CardMask common, int size): firstHoleCard(firstHoleCard),
secondHoleCard(secondHoleCard), common(common), size(size)
{
CardMask_OR(ours, firstHoleCard, secondHoleCard);
CardMask_OR(dead, ours, common);
}
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);
});
}
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 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<NumberOfCardsPerPlayer(); 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->CommonCards(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_engine_container->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_engine_container->symbol_engine_pokerval()->CalculatePokerval(hv_opponent,
(NumberOfCardsPerPlayer() + 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;
}
