static void
parseArgs(int argc, char **argv) {
int i, c;
for (i = 1; i < argc; ++i) {
if (!strcmp(argv[i], "-low"))
gLow = 1;
else if (!strcmp(argv[i], "-hl"))
gHighLow = 1;
else {
if (Deck_stringToCard(argv[i], &c) == 0)
goto error;
if (!CardMask_CARD_IS_SET(gCards, c)) {
CardMask_SET(gCards, c);
++gNCards;
};
};
}
return;
error:
fprintf(stderr, "Usage: eval [ -low ] [ -hl ] cards \n");
exit(0);
}
void CIteratorThread::SwapDealingAlgorithmForMoreThan13Opponents(int nopponents)
{
write_log(preferences.debug_prwin(), "[PrWinThread] Useing swap-algorithm, as f$prwin_number_of_opponents > 13\n");
// swap alogorithm
// weighted prwin not implemented for this case
int numberOfCards = k_number_of_cards_per_deck;
for (int i=0; i<numberOfCards; i++)
{
deck[i] = i;
}
while (numberOfCards >= 1)
{
int selected_card = rand() % numberOfCards;
numberOfCards--;
if (selected_card != numberOfCards)
{
SwapInts(&deck[selected_card], &deck[numberOfCards]);
}
}
// opponent cards
int x = 0;
for (int i=0;
i<nopponents*k_number_of_cards_per_player;
i++)
{
while (CardMask_CARD_IS_SET(usedCards, deck[x])
&& (x < k_number_of_cards_per_deck))
{
x++;
}
ocard[i] = deck[x++];
}
// additional common cards
CardMask_RESET(addlcomCards);
for (int i=0; i<(k_number_of_community_cards - _ncomCards); i++)
{
while (CardMask_CARD_IS_SET(usedCards, deck[x])
&& (x < k_number_of_cards_per_deck))
{
x++;
}
CardMask_SET(addlcomCards, deck[x++]);
}
}
/*
* Find the card with highest suit matching rank in hand
* and remove it from hand. The removed card is returned.
*/
int findanddelete(CardMask* hand, int rank)
{
int suit;
for(suit = StdDeck_Suit_LAST; suit >= StdDeck_Suit_FIRST; suit--) {
int card = StdDeck_MAKE_CARD(rank, suit);
if(CardMask_CARD_IS_SET(*hand, card)) {
CardMask_UNSET(*hand, card);
return card;
}
}
return -1;
}
int CIteratorThread::GetRandomCard()
{
// We use bit-operations for truncation
// That is better as modulo (52) which introdues a bias
const int k_low_6_bits = 0x3F;
// The search-loop is guaranteed to terminate,
// as there are 52-cards in the deck,
// but at most 25 cards in use (10*2 player-cards + 5 community-cards).
while (true)
{
int card = rand() & k_low_6_bits;
if ((card < k_number_of_cards_per_deck)
&& !CardMask_CARD_IS_SET(usedCards, card))
{
// We found a good card
return card;
}
}
}
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 CIteratorThread::EnhancedDealingAlgorithm()
{
// Dealing algorithm for enhanced prwin
// (user-defined weighting at DLL-level).
write_log(preferences.debug_prwin(), "[PrWinThread] Using Matrix's enhanced prwin.\n");
//prw1326 active Matrix 2008-05-08
int k = 0; //k is used as an index into ocard[]
unsigned int card = 0;
int userchair = p_symbol_engine_userchair->userchair();
int playersplayingbits = p_symbol_engine_active_dealt_playing->playersplayingbits();
//we have to use actual opponents for prw1326 calculations
int nopponents = bitcount(playersplayingbits & ~(1 << userchair));
int betround = p_betround_calculator->betround();
int bblindbits = p_symbol_engine_blinds->bblindbits();
// loop through active opponents
for(int i=0; i<k_max_number_of_players; i++)
{
if (i == userchair)
continue; //skip our own chair!
if (!(playersplayingbits & (1<<i)))
continue; //skip inactive chairs
// 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 && p_symbol_engine_history->nbetsround(betround)<1.1
&& (bblindbits&(1<<i))) )
{
card = GetRandomCard();
CardMask_SET(usedCards, card);
ocard[k++] = card;
card = GetRandomCard();
CardMask_SET(usedCards, card);
ocard[k++] = card;
continue;
} // end of special non-weighted cases
int randfix=(RAND_MAX/_prw1326.chair[i].limit) * _prw1326.chair[i].limit;
int j;
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 - _ncomCards); i++)
{
card = GetRandomCard();
CardMask_SET(usedCards, card);
CardMask_SET(addlcomCards, card);
}
} //end of prw1326 code
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 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);
}
int CIteratorThread::EnhancedDealingAlgorithm() {
write_log(preferences.debug_prwin(), "[PrWinThread] Using ZeeZooLaa's enhanced prwin.\n");
unsigned int card = 0, deadHandsCounter = 0;
int k = 0; //k is used as an index into ocard[]
int userchair = p_symbol_engine_userchair->userchair();
int playersplayingbits = p_symbol_engine_active_dealt_playing->playersplayingbits();
int chairWeight;
bool deadHands[k_number_of_pocketcard_combinations_without_order];
for(int eachChair=0; eachChair < kMaxNumberOfPlayers; eachChair++) { // loop through playing opponents
if (eachChair == userchair) continue; //skip our own chair!
if (!(playersplayingbits & (1<<eachChair))) continue; //skip inactive chairs
chairWeight = _total_weight[eachChair];
if (_prw1326.chair[eachChair].ignore || chairWeight <= 0 ) {
card = GetRandomCard();
CardMask_SET(usedCards, card);
ocard[k++] = card;
card = GetRandomCard();
CardMask_SET(usedCards, card);
ocard[k++] = card;
continue;
} // end of special non-weighted cases
memset(deadHands,false,sizeof(deadHands));
deadHandsCounter = 0;
bool random_weighted_hand_was_found = false;
while(!random_weighted_hand_was_found) {
int random_weight = RNG::Instance()->under(chairWeight); //find random_weight which is between [0..chairWeight)
for (int eachPossibleHand=0; eachPossibleHand < _prw1326.chair[eachChair].limit; eachPossibleHand++) { //find random weighted hand
if (!deadHands[eachPossibleHand] && random_weight < _prw1326.chair[eachChair].weight[eachPossibleHand]) { //random hand found.
if(CardMask_CARD_IS_SET(usedCards, _prw1326.chair[eachChair].rankhi[eachPossibleHand] )
|| CardMask_CARD_IS_SET(usedCards, _prw1326.chair[eachChair].ranklo[eachPossibleHand] )) {
//hand contains dead card
deadHands[eachPossibleHand] = true;
deadHandsCounter++;
chairWeight -= _prw1326.chair[eachChair].weight[eachPossibleHand];
if(deadHandsCounter == _prw1326.chair[eachChair].limit || chairWeight <= 0) {
//all range consists only of dead cards
//failed to satisfy the specified range, user possibly needs to expand the range of corresponding chair
if(eachChair == 0) return -10;
return 0-eachChair;
}
break; //generate new random_weight
}
//hand not dead, use it
ocard[k++] = _prw1326.chair[eachChair].rankhi[eachPossibleHand];
ocard[k++] = _prw1326.chair[eachChair].ranklo[eachPossibleHand];
CardMask_SET(usedCards, ocard[k-2]);
CardMask_SET(usedCards, ocard[k-1]);
random_weighted_hand_was_found = true;
break;
}
//keep decreasing the random_weight until it becomes less then _prw1326.chair[eachPlayer].weight
if(!deadHands[eachPossibleHand]) {
random_weight -= _prw1326.chair[eachChair].weight[eachPossibleHand];
}
}//end of eachPossibleHand
}//end of random_weighted_hand_was_found
} //end of eachPlayer
// additional common cards
CardMask_RESET(addlcomCards);
for (int i=0; i<(kNumberOfCommunityCards - _ncomCards); i++) {
card = GetRandomCard();
CardMask_SET(usedCards, card);
CardMask_SET(addlcomCards, card);
}
return 0; //success
}
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;
}
