Esempio n. 1
0
int cardEffect(int card, int choice1, int choice2, int choice3, struct gameState *state, int handPos, int *bonus)
{
  int i;
  int j;
  int k;
  int x;
  int index;
  int currentPlayer = whoseTurn(state);
  int nextPlayer = currentPlayer + 1;

  int tributeRevealedCards[2] = {-1, -1};
  int temphand[MAX_HAND];// moved above the if statement
  //int drawntreasure=0;
  //int cardDrawn;
  //int z = 0;// this is the counter for the temp hand
  if (nextPlayer > (state->numPlayers - 1)){
    nextPlayer = 0;
  }
  
  
  //uses switch to select card and perform actions
  switch( card ) 
  {
    case adventurer:
      playAdventurer(temphand, state, currentPlayer);
      return 0;
      
    case council_room:
      playCouncilRoom(currentPlayer, state, handPos);
      return 0;
      
    case feast:
      //gain card with cost up to 5
      //Backup hand
      for (i = 0; i <= state->handCount[currentPlayer]; i++){
        temphand[i] = state->hand[currentPlayer][i];//Backup card
        state->hand[currentPlayer][i] = -1;//Set to nothing
      }
      //Backup hand

      //Update Coins for Buy
      updateCoins(currentPlayer, state, 5);
      x = 1;//Condition to loop on
      while( x == 1) {//Buy one card
        if (supplyCount(choice1, state) <= 0){
          if (DEBUG)
            printf("None of that card left, sorry!\n");

          if (DEBUG){
            printf("Cards Left: %d\n", supplyCount(choice1, state));
          }
        }
        else if (state->coins < getCost(choice1)){
          printf("That card is too expensive!\n");

          if (DEBUG){
            printf("Coins: %d < %d\n", state->coins, getCost(choice1));
          }
        }
        else{
          if (DEBUG){
            printf("Deck Count: %d\n", state->handCount[currentPlayer] + state->deckCount[currentPlayer] + state->discardCount[currentPlayer]);
          }

          gainCard(choice1, state, 0, currentPlayer);//Gain the card
          x = 0;//No more buying cards

          if (DEBUG){
            printf("Deck Count: %d\n", state->handCount[currentPlayer] + state->deckCount[currentPlayer] + state->discardCount[currentPlayer]);
          }

        }
      }     

      //Reset Hand
      for (i = 0; i <= state->handCount[currentPlayer]; i++){
        state->hand[currentPlayer][i] = temphand[i];
        temphand[i] = -1;
      }
      //Reset Hand
            
      return 0;
      
    case gardens:
      return -1;
      
    case mine:
      j = state->hand[currentPlayer][choice1];  //store card we will trash

      if (state->hand[currentPlayer][choice1] < copper || state->hand[currentPlayer][choice1] > gold)
      {
        return -1;
      }
    
      if (choice2 > treasure_map || choice2 < curse)
      {
        return -1;
      }

      if ( (getCost(state->hand[currentPlayer][choice1]) + 3) > getCost(choice2) )
      {
        return -1;
      }

      gainCard(choice2, state, 2, currentPlayer);

      //discard card from hand
      discardCard(handPos, currentPlayer, state, 0);

      //discard trashed card
      for (i = 0; i < state->handCount[currentPlayer]; i++)
      {
        if (state->hand[currentPlayer][i] == j)
          {
            discardCard(i, currentPlayer, state, 0);      
            break;
          }
      }
      
      return 0;
      
    case remodel:
      j = state->hand[currentPlayer][choice1];  //store card we will trash

      if ( (getCost(state->hand[currentPlayer][choice1]) + 2) > getCost(choice2) )
      {
        return -1;
      }

      gainCard(choice2, state, 0, currentPlayer);

      //discard card from hand
      discardCard(handPos, currentPlayer, state, 0);

      //discard trashed card
      for (i = 0; i < state->handCount[currentPlayer]; i++)
      {
        if (state->hand[currentPlayer][i] == j)
          {
            discardCard(i, currentPlayer, state, 0);      
            break;
          }
      }


      return 0;
    
    case smithy:
      playSmithy(currentPlayer, state, handPos);
      return 0;
    
    case village:
      playVillage(currentPlayer, state, handPos);
      return 0;
    
    case baron:
      playBaron(currentPlayer, state, choice1);
      return 0;
    
    case great_hall:
      //+1 Card
      drawCard(currentPlayer, state);
      
      //+1 Actions
      state->numActions++;
      
      //discard card from hand
      discardCard(handPos, currentPlayer, state, 0);
      return 0;
    
    case minion:
      //+1 action
      state->numActions++;
      
      //discard card from hand
      discardCard(handPos, currentPlayer, state, 0);
      
      if (choice1)    //+2 coins
      {
        state->coins = state->coins + 2;
      }
      else if (choice2)   //discard hand, redraw 4, other players with 5+ cards discard hand and draw 4
      {
        //discard hand
        while(numHandCards(state) > 0)
          {
            discardCard(handPos, currentPlayer, state, 0);
          }
            
        //draw 4
        for (i = 0; i < 4; i++)
          {
            drawCard(currentPlayer, state);
          }
            
        //other players discard hand and redraw if hand size > 4
        for (i = 0; i < state->numPlayers; i++)
        {
          if (i != currentPlayer)
          {
            if ( state->handCount[i] > 4 )
            {
              //discard hand
              while( state->handCount[i] > 0 )
              {
                discardCard(handPos, i, state, 0);
              }
                  
              //draw 4
              for (j = 0; j < 4; j++)
              {
                drawCard(i, state);
              }
            }
          }
        }     
      }
      return 0;
    
    case steward:
      if (choice1 == 1)
      {
        //+2 cards
        drawCard(currentPlayer, state);
        drawCard(currentPlayer, state);
      }
      else if (choice1 == 2)
      {
        //+2 coins
        state->coins = state->coins + 2;
      }
      else
      {
        //trash 2 cards in hand
        discardCard(choice2, currentPlayer, state, 1);
        discardCard(choice3, currentPlayer, state, 1);
      }
      
      //discard card from hand
      discardCard(handPos, currentPlayer, state, 0);
      return 0;
    
    case tribute:
      if ((state->discardCount[nextPlayer] + state->deckCount[nextPlayer]) <= 1){
        if (state->deckCount[nextPlayer] > 0){
          tributeRevealedCards[0] = state->deck[nextPlayer][state->deckCount[nextPlayer]-1];
          state->deckCount[nextPlayer]--;
        }
        else if (state->discardCount[nextPlayer] > 0){
          tributeRevealedCards[0] = state->discard[nextPlayer][state->discardCount[nextPlayer]-1];
          state->discardCount[nextPlayer]--;
        }
        else{
          //No Card to Reveal
          if (DEBUG){
            printf("No cards to reveal\n");
          }
        }
      }
      
      else{
        if (state->deckCount[nextPlayer] == 0){
          for (i = 0; i < state->discardCount[nextPlayer]; i++){
            state->deck[nextPlayer][i] = state->discard[nextPlayer][i];//Move to deck
            state->deckCount[nextPlayer]++;
            state->discard[nextPlayer][i] = -1;
            state->discardCount[nextPlayer]--;
        }
          
          shuffle(nextPlayer,state);//Shuffle the deck
        } 
        tributeRevealedCards[0] = state->deck[nextPlayer][state->deckCount[nextPlayer]-1];
        state->deck[nextPlayer][state->deckCount[nextPlayer]--] = -1;
        state->deckCount[nextPlayer]--;
        tributeRevealedCards[1] = state->deck[nextPlayer][state->deckCount[nextPlayer]-1];
        state->deck[nextPlayer][state->deckCount[nextPlayer]--] = -1;
        state->deckCount[nextPlayer]--;
      }    
           
      if (tributeRevealedCards[0] == tributeRevealedCards[1]){//If we have a duplicate card, just drop one 
        state->playedCards[state->playedCardCount] = tributeRevealedCards[1];
        state->playedCardCount++;
        tributeRevealedCards[1] = -1;
      }

      for (i = 0; i <= 2; i ++){
        if (tributeRevealedCards[i] == copper || tributeRevealedCards[i] == silver || tributeRevealedCards[i] == gold){//Treasure cards
          state->coins += 2;
        }
        
        else if (tributeRevealedCards[i] == estate || tributeRevealedCards[i] == duchy || tributeRevealedCards[i] == province || tributeRevealedCards[i] == gardens || tributeRevealedCards[i] == great_hall){//Victory Card Found
          drawCard(currentPlayer, state);
          drawCard(currentPlayer, state);
        }
        else{//Action Card
          state->numActions = state->numActions + 2;
        }
      }
      
      return 0;
    
    case ambassador:
      j = 0;    //used to check if player has enough cards to discard

      if (choice2 > 2 || choice2 < 0)
      {
        return -1;        
      }

      if (choice1 == handPos)
      {
        return -1;
      }

      for (i = 0; i < state->handCount[currentPlayer]; i++)
      {
        if (i != handPos && i == state->hand[currentPlayer][choice1] && i != choice1)
          {
            j++;
          }
      }
      if (j < choice2)
      {
        return -1;        
      }

      if (DEBUG) 
        printf("Player %d reveals card number: %d\n", currentPlayer, state->hand[currentPlayer][choice1]);

      //increase supply count for choosen card by amount being discarded
      state->supplyCount[state->hand[currentPlayer][choice1]] += choice2;
      
      //each other player gains a copy of revealed card
      for (i = 0; i < state->numPlayers; i++)
      {
        if (i != currentPlayer)
          {
            gainCard(state->hand[currentPlayer][choice1], state, 0, i);
          }
      }

      //discard played card from hand
      discardCard(handPos, currentPlayer, state, 0);      

      //trash copies of cards returned to supply
      for (j = 0; j < choice2; j++)
      {
        for (i = 0; i < state->handCount[currentPlayer]; i++)
          {
            if (state->hand[currentPlayer][i] == state->hand[currentPlayer][choice1])
        {
          discardCard(i, currentPlayer, state, 1);
          break;
        }
          }
      }     

      return 0;
    
    case cutpurse:
      updateCoins(currentPlayer, state, 2);
      for (i = 0; i < state->numPlayers; i++)
      {
        if (i != currentPlayer)
        {
          for (j = 0; j < state->handCount[i]; j++)
          {
            if (state->hand[i][j] == copper)
            {
              discardCard(j, i, state, 0);
              break;
            }
            if (j == state->handCount[i])
            {
              for (k = 0; k < state->handCount[i]; k++)
              {
                if (DEBUG)
                  printf("Player %d reveals card number %d\n", i, state->hand[i][k]);
              } 
              break;
            }   
          }
        }  
      }       

      //discard played card from hand
      discardCard(handPos, currentPlayer, state, 0);      

      return 0;

    case embargo: 
      //+2 Coins
      state->coins = state->coins + 2;
      
      //see if selected pile is in play
      if ( state->supplyCount[choice1] == -1 )
      {
        return -1;
      }
      
      //add embargo token to selected supply pile
      state->embargoTokens[choice1]++;
      
      //trash card
      discardCard(handPos, currentPlayer, state, 1);    
      return 0;
    
    case outpost:
      //set outpost flag
      state->outpostPlayed++;
      
      //discard card
      discardCard(handPos, currentPlayer, state, 0);
      return 0;
    
    case salvager:
      //+1 buy
      state->numBuys++;
      
      if (choice1)
      {
        //gain coins equal to trashed card
        state->coins = state->coins + getCost( handCard(choice1, state) );
        //trash card
        discardCard(choice1, currentPlayer, state, 1);  
      }
      
      //discard card
      discardCard(handPos, currentPlayer, state, 0);
      return 0;
    
    case sea_hag:
      for (i = 0; i < state->numPlayers; i++){
        if (i != currentPlayer){
          state->discard[i][state->discardCount[i]] = state->deck[i][state->deckCount[i]--];          state->deckCount[i]--;
          state->discardCount[i]++;
          state->deck[i][state->deckCount[i]--] = curse;//Top card now a curse
        }
      }
      return 0;
    
    case treasure_map:
      //search hand for another treasure_map
      index = -1;
      for (i = 0; i < state->handCount[currentPlayer]; i++)
      {
        if (state->hand[currentPlayer][i] == treasure_map && i != handPos)
        {
          index = i;
          break;
        }
      }
      if (index > -1)
      {
        //trash both treasure cards
        discardCard(handPos, currentPlayer, state, 1);
        discardCard(index, currentPlayer, state, 1);

        //gain 4 Gold cards
        for (i = 0; i < 4; i++)
        {
          gainCard(gold, state, 1, currentPlayer);
        }
            
        //return success
        return 1;
      }
      
      //no second treasure_map found in hand
      return -1;
    }
  
  return -1;
}
Esempio n. 2
0
int main(){
   int seed = 1234;
   int numPlayers = 2;
   int i, r, t;
   int k[10] = {adventurer, council_room, feast, gardens, mine,
   		remodel, smithy, village, baron, great_hall};
   struct gameState G;

   int handCount, discardCount, estateCount, coins, buys;
   int heldEstates = 0;
   int newEstates = 0;

   printf("Testing playBaron():\n\n");

   r = initializeGame(numPlayers, k, seed, &G);

   G.hand[0][0] = copper;
   G.hand[0][1] = copper;
   G.hand[0][2] = estate;
   G.hand[0][3] = copper;
   G.hand[0][4] = estate;
   
   handCount = G.handCount[0];
   discardCount = G.discardCount[0];
   estateCount = G.supplyCount[estate];
   coins = G.coins = 3;
   buys = G.numBuys;


   i = playBaron(&G, 0, 1);

   printf("\nTesting choice to discard with estate card in hand\n");
   //add a buy
   if (G.numBuys == buys + 1){
      printf("PASSED: Buys increased by 1\n");
   } else {
      printf("FAILED: Buys increased by 1\n");
   }

   /* 
    * Choice 1
    *
    * Estate card in hand
    *
    * */
   //discard estate
   //gain 4 coins
   //loose card from hand
   if (G.coins == coins + 4 &&
       G.discardCount[0] == discardCount + 1 &&
       G.handCount[0] == handCount - 1){
      printf("PASSED: Coins gained & card moved to discard pile\n");
   } else {
      printf("FAILED: Coins gained & card moved to discard pile\n");
   }
   


   /*
    * Choice 1
    *
    * Estate card not in hand
    *
    * */
   //gain an estate in discard pile
   //supply count down by one

   G.hand[0][0] = copper;
   G.hand[0][1] = copper;
   G.hand[0][2] = copper;
   G.hand[0][3] = copper;
   G.hand[0][4] = silver;
   
   handCount = G.handCount[0];
   discardCount = G.discardCount[0];
   estateCount = G.supplyCount[estate];
   buys = G.numBuys;

   for (t = 0; t < G.discardCount[0]; t++){
      if (G.discard[0][t] == estate){
	 heldEstates++;
      }
   }

   i = playBaron(&G, 0, 1);

   printf("\nTesting choice to discard with no estate card in hand\n");
   if (G.numBuys == buys + 1){
      printf("PASSED: Buys increased by 1\n");
   } else {
      printf("FAILED: Buys increased by 1\n");
   }

   for (t = 0; t < G.discardCount[0]; t++){
      if (G.discard[0][t] == estate){
	 newEstates++;
      }
   }

   if (G.discardCount[0] == discardCount + 1 &&
       G.supplyCount[estate] == estateCount - 1 &&
       newEstates == heldEstates + 1){

   printf("%d - %d\n", heldEstates, newEstates);
      printf("PASSED: Estate added to discard pile\n");
   } else {
      printf("FAILED: Estate added to discard pile\n");
   }

   handCount = G.handCount[0];
   discardCount = G.discardCount[0];
   estateCount = G.supplyCount[estate];
   buys = G.numBuys;
   heldEstates = newEstates = 0;

   for (t = 0; t < G.discardCount[0]; t++){
      if (G.discard[0][t] == estate){
	 heldEstates++;
      }
   }

   i = playBaron(&G, 0, 0);

   printf("\nTesting choice to gain estate\n");
   if (G.numBuys == buys + 1){
      printf("PASSED: Buys increased by 1\n");
   } else {
      printf("FAILED: Buys increased by 1\n");
   }

   for (t = 0; t < G.discardCount[0]; t++){
      if (G.discard[0][t] == estate){
	 newEstates++;
      }
   }

   if (G.discardCount[0] == discardCount + 1 &&
       G.supplyCount[estate] == estateCount - 1 &&
       newEstates == heldEstates + 1){
      printf("PASSED: Estate added to discard pile\n");
   } else {
      printf("FAILED: Estate added to discard pile\n");
   }


   printf("Tests complete\n\n");



   return 0;
}
Esempio n. 3
0
int cardEffect(int card, int choice1, int choice2, int choice3, struct gameState *state, int handPos, int *bonus)
{
   //uses switch to select card and perform actions
  switch( card ) 
    {
    case adventurer:
       return (playAdventurer(state));
	
    case council_room:
       return (playCouncil_Room(state, handPos));
			
    case feast:
       return(playFeast(state, choice1)); 
	
    case gardens:
       return -1;

    case smithy:
      return (playSmithy(state, handPos));
		
    case village:
      return (playVillage(state, handPos));
			
    case mine:
      return(playMine(state, choice1, choice2, handPos));
			
    case remodel:
      return(playRemodel(state, choice1, choice2, handPos));
 
    case baron:
      return(playBaron(state, choice1, choice2, handPos));
   
    case great_hall:
      return(playGreat_hall(state, handPos));
 
    case minion:
      return(playMinion(state, choice1, choice2, handPos));

    case steward:
      return(playSteward(state, choice1, choice2, choice3, handPos));
		
    case tribute:
      return(playTribute(state));

    case ambassador:
      return(playAmbassador(state,choice1, choice2, handPos));
		
    case cutpurse:
      return(playCutpurse(state, handPos));
		
    case embargo:
      return(playEmbargo(state, choice1, handPos));
		
    case outpost:
      return(playOutpost(state, handPos));
		
    case salvager:
      return(playSalvager(state, choice1, handPos));
		
    case sea_hag:
      return(playSea_hag(state));
		
    case treasure_map:
      return(playTreasure_map(state, handPos));
 
    }
  return -1;
}