Ejemplo n.º 1
0
int main() {

	std::cout << "Running Hand tests..." << std::endl;
	testHand();
	std::cout << "Hand tests passed!" << std::endl;
	return 0;
}
Ejemplo n.º 2
0
int main()
{
	int i;
	int seed = 1000;
	int numPlayers = 2;
	int player  = 0;
	int *deckZero,*deckOne;
	struct gameState preTest, postTest;
	int k[10] = {adventurer, council_room, feast, gardens, mine ,remodel, smithy, village, baron, great_hall};
	/* Test Specification Variables */
	int drawCountTestZero = 3;
	int drawCountTestOne = 0;

	initializeGame(numPlayers,k,seed,&postTest);
	printf("\n\nBeginning Test for Village...\n\n");
	memcpy(&preTest,&postTest,sizeof(struct gameState));
	insertCard(&postTest,player);
	playCard((postTest.handCount[player]-1),0,0,0,&postTest);
	testDraw(&preTest,&postTest,player);
	testHand(&preTest,&postTest,player);
	testDiscard(&preTest,&postTest,player);
	testSupply(&preTest,&postTest);
	testPlayed(&preTest,&postTest);
	testUtility(&preTest,&postTest);
	printf("\n\tTesting finished\n\n");
}
Ejemplo n.º 3
0
void kpok::drawCardsEvent()
{
   int testResult;

   cardW[drawStat]->show();
   cardW[drawStat]->paintCard(cards[drawStat],0,0);

   if (!cardW[drawStat]->queryHeld())
      playSound("cardflip.wav");

   if (drawStat == 4) { /* just did last card */
      drawButton->setEnabled(true);
      drawStat=0;
      if (status == 1) {
         testResult=testHand();
         switch (testResult) {
         case 1 : if (foundCards[0].cardType >= 17) {
               foundCards[0].cardType=0; foundCards[1].cardType=0; displayWin(locale->translate("nothing"),0); break;
            }
            displayWin(locale->translate("One Pair"),5);  break;
         case 2 : displayWin(locale->translate("Two Pairs"), 10); break;
         case 3 : displayWin(locale->translate("3 of a kind"), 15); break;
         case 4 : displayWin(locale->translate("Full House"), 40); break;
         case 6 : displayWin(locale->translate("4 of a kind"), 125); break;
         case 7 : displayWin(locale->translate("Straight"),20); break;
         case 8 : displayWin(locale->translate("Flush"),25); break;
         case 9 : displayWin(locale->translate("Straight Flush"),250); break;
         case 10 : displayWin(locale->translate("Royal Flush"),2000); break;

         default: displayWin(locale->translate("nothing"),0); break;
         }

         startBlinking();
         status = 0;

         if (getCash() < cashPerRound) {
            KMsgBox::message(0,locale->translate("You Lost"), 
                             locale->translate("Oops - you went bankrupt.\n"),
                             KMsgBox::EXCLAMATION,locale->translate("New game"));
            initPoker();
         }

      } else {
         clickToHold->show();
         status =1;
      }

   } else { /* only inc drawStat if not done with displaying */
      drawStat++;
      /* look at next card and if it is held instantly call drawCardEvent again */
      if (cardW[drawStat]->queryHeld())
         drawTimer->start(0,TRUE);
      else
         drawTimer->start(drawDelay,TRUE);
   }
}
void BJPlayer::computeOverall(BJRules & rules, BJStrategy & strategy) {
    overallValue = 0;
    bool surrender = rules.getLateSurrender();
    shoe.reset();
    for (int upCard = Card::Ace; upCard <= Card::Ten; ++upCard) {
        overallValues[upCard - 1] = 0;
        if (shoe.getCards(upCard)) {
            shoe.deal(upCard);
            for (int card1 = Card::Ace; card1 <= Card::Ten; ++card1) {
                for (int card2 = Card::Ace; card2 <= Card::Ten; ++card2) {
                    if (shoe.getCards(card1) && shoe.getCards(card2) &&
						(card1 != card2 || shoe.getCards(card1) >= 2)) {
                        currentHand.reset();
                        double p = shoe.getProbability(card1);
                        shoe.deal(card1); currentHand.deal(card1);
                        p *= shoe.getProbability(card2);
                        shoe.deal(card2); currentHand.deal(card2);
                        PlayerHand & hand = playerHands[findHand(currentHand)];
                        double value;
                        BJHand testHand(hand.cards);
                        bool doubleDown = rules.getDoubleDown(testHand),
                            split = (card1 == card2
                                    && resplit[card1 - 1] >= 2);
                        double valueSurrender;
                        switch (strategy.getOption(testHand, upCard,
                                doubleDown, split, surrender)) {
                        case BJ_MAX_VALUE :
                            value = hand.valueStand[false][upCard - 1];
                            if (value < hand.valueHit[false][upCard - 1]) {
                                value = hand.valueHit[false][upCard - 1];
                            }
                            if (doubleDown) {
                                if (value < hand.
                                        valueDoubleDown[false][upCard - 1]) {
                                    value = hand.
                                        valueDoubleDown[false][upCard - 1];
                                }
                            }
                            if (split) {
                                if (value < valueSplit[card1 - 1]
                                        [upCard - 1]) {
                                    value = valueSplit[card1 - 1][upCard - 1];
                                }
                            }
                            if (surrender) {
                                valueSurrender = computeSurrender(upCard);
                                if (value < valueSurrender) {
                                    value = valueSurrender;
                                }
                            }
                            break;
                        case BJ_STAND :
                            value = hand.valueStand[false][upCard - 1];
                            break;
                        case BJ_HIT :
                            value = hand.valueHit[false][upCard - 1];
                            break;
                        case BJ_DOUBLE_DOWN :
                            value = hand.valueDoubleDown[false][upCard - 1];
                            break;
                        case BJ_SPLIT :
                            value = valueSplit[card1 - 1][upCard - 1];
                            break;
                        case BJ_SURRENDER :
                            value = computeSurrender(upCard);
                            break;
                        }
                        overallValues[upCard - 1] += value*p;
                        shoe.undeal(card2);
                        shoe.undeal(card1);
                    }
                }
            }
            shoe.undeal(upCard);
            overallValue += overallValues[upCard - 1]
                    *shoe.getProbability(upCard);
        }
    }
}