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; }