From 07c9da7e3b1acd97f90ab0f43d4bf2728afe6a5d Mon Sep 17 00:00:00 2001 From: NickJohansen <50577890+NickJohansen@users.noreply.github.com> Date: Sun, 29 Sep 2019 21:48:53 -0700 Subject: [PATCH 1/6] Add files via upload Added folder --- projects/johansen/README.md | 1 + 1 file changed, 1 insertion(+) create mode 100644 projects/johansen/README.md diff --git a/projects/johansen/README.md b/projects/johansen/README.md new file mode 100644 index 000000000..e8304b7c5 --- /dev/null +++ b/projects/johansen/README.md @@ -0,0 +1 @@ +#Nicholas Johansen, johansen \ No newline at end of file From a81dd40fd21a457beb429a3409f1fe0ba0b1d327 Mon Sep 17 00:00:00 2001 From: NickJohansen <50577890+NickJohansen@users.noreply.github.com> Date: Sun, 29 Sep 2019 21:49:58 -0700 Subject: [PATCH 2/6] Add files via upload Readme --- projects/johansen/README.md | 1 + 1 file changed, 1 insertion(+) create mode 100644 projects/johansen/README.md diff --git a/projects/johansen/README.md b/projects/johansen/README.md new file mode 100644 index 000000000..e8304b7c5 --- /dev/null +++ b/projects/johansen/README.md @@ -0,0 +1 @@ +#Nicholas Johansen, johansen \ No newline at end of file From b0316ecec79afaa9d527216da353d542ceb8e67d Mon Sep 17 00:00:00 2001 From: NickJohansen <50577890+NickJohansen@users.noreply.github.com> Date: Sun, 29 Sep 2019 21:52:21 -0700 Subject: [PATCH 3/6] Add files via upload Dominionuploaded --- projects/johansen/dominion/Makefile | 31 + projects/johansen/dominion/READM.md | 2 + projects/johansen/dominion/dominion.c | 1373 +++++++++++++++++ projects/johansen/dominion/dominion.h | 131 ++ projects/johansen/dominion/dominion_helpers.h | 15 + projects/johansen/dominion/interface.c | 425 +++++ projects/johansen/dominion/interface.h | 128 ++ projects/johansen/dominion/playdom.c | 135 ++ projects/johansen/dominion/player.c | 205 +++ projects/johansen/dominion/rngs.c | 183 +++ projects/johansen/dominion/rngs.h | 19 + projects/johansen/dominion/rt.c | 27 + projects/johansen/dominion/testdrawcard.c | 74 + 13 files changed, 2748 insertions(+) create mode 100644 projects/johansen/dominion/Makefile create mode 100644 projects/johansen/dominion/READM.md create mode 100644 projects/johansen/dominion/dominion.c create mode 100644 projects/johansen/dominion/dominion.h create mode 100644 projects/johansen/dominion/dominion_helpers.h create mode 100644 projects/johansen/dominion/interface.c create mode 100644 projects/johansen/dominion/interface.h create mode 100644 projects/johansen/dominion/playdom.c create mode 100644 projects/johansen/dominion/player.c create mode 100644 projects/johansen/dominion/rngs.c create mode 100644 projects/johansen/dominion/rngs.h create mode 100644 projects/johansen/dominion/rt.c create mode 100644 projects/johansen/dominion/testdrawcard.c diff --git a/projects/johansen/dominion/Makefile b/projects/johansen/dominion/Makefile new file mode 100644 index 000000000..e04a81c27 --- /dev/null +++ b/projects/johansen/dominion/Makefile @@ -0,0 +1,31 @@ +CFLAGS= -Wall -fpic -coverage -lm -std=c99 + +rngs.o: rngs.h rngs.c + gcc -c rngs.c -g $(CFLAGS) + +dominion.o: dominion.h dominion.c rngs.o + gcc -c dominion.c -g $(CFLAGS) + +playdom: dominion.o playdom.c + gcc -o playdom playdom.c -g dominion.o rngs.o $(CFLAGS) +#To run playdom you need to entere: ./playdom like ./playdom 10*/ + +testDrawCard: testDrawCard.c dominion.o rngs.o + gcc -o testDrawCard -g testDrawCard.c dominion.o rngs.o $(CFLAGS) + +interface.o: interface.h interface.c + gcc -c interface.c -g $(CFLAGS) + +runtests: testDrawCard + ./testDrawCard &> unittestresult.out + gcov dominion.c >> unittestresult.out + cat dominion.c.gcov >> unittestresult.out + + +player: player.c interface.o + gcc -o player player.c -g dominion.o rngs.o interface.o $(CFLAGS) + +all: playdom player + +clean: + rm -f *.o playdom.exe playdom player player.exe *.gcov *.gcda *.gcno *.so *.out testDrawCard testDrawCard.exe diff --git a/projects/johansen/dominion/READM.md b/projects/johansen/dominion/READM.md new file mode 100644 index 000000000..4294e09e0 --- /dev/null +++ b/projects/johansen/dominion/READM.md @@ -0,0 +1,2 @@ +run make all #To compile the dominion code +run ./playdom 30 # to run playdom code diff --git a/projects/johansen/dominion/dominion.c b/projects/johansen/dominion/dominion.c new file mode 100644 index 000000000..74200d0d3 --- /dev/null +++ b/projects/johansen/dominion/dominion.c @@ -0,0 +1,1373 @@ +#include "dominion.h" +#include "dominion_helpers.h" +#include "rngs.h" +#include +#include +#include + +int compare(const void* a, const void* b) { + if (*(int*)a > *(int*)b) + return 1; + if (*(int*)a < *(int*)b) + return -1; + return 0; +} + +struct gameState* newGame() { + struct gameState* g = malloc(sizeof(struct gameState)); + return g; +} + +int* kingdomCards(int k1, int k2, int k3, int k4, int k5, int k6, int k7, + int k8, int k9, int k10) { + int* k = malloc(10 * sizeof(int)); + k[0] = k1; + k[1] = k2; + k[2] = k3; + k[3] = k4; + k[4] = k5; + k[5] = k6; + k[6] = k7; + k[7] = k8; + k[8] = k9; + k[9] = k10; + return k; +} + +int initializeGame(int numPlayers, int kingdomCards[10], int randomSeed, + struct gameState *state) { + int i; + int j; + int it; + + //set up random number generator + SelectStream(1); + PutSeed((long)randomSeed); + + //check number of players + if (numPlayers > MAX_PLAYERS || numPlayers < 2) + { + return -1; + } + + //set number of players + state->numPlayers = numPlayers; + + //check selected kingdom cards are different + for (i = 0; i < 10; i++) + { + for (j = 0; j < 10; j++) + { + if (j != i && kingdomCards[j] == kingdomCards[i]) + { + return -1; + } + } + } + + + //initialize supply + /////////////////////////////// + + //set number of Curse cards + if (numPlayers == 2) + { + state->supplyCount[curse] = 10; + } + else if (numPlayers == 3) + { + state->supplyCount[curse] = 20; + } + else + { + state->supplyCount[curse] = 30; + } + + //set number of Victory cards + if (numPlayers == 2) + { + state->supplyCount[estate] = 8; + state->supplyCount[duchy] = 8; + state->supplyCount[province] = 8; + } + else + { + state->supplyCount[estate] = 12; + state->supplyCount[duchy] = 12; + state->supplyCount[province] = 12; + } + + //set number of Treasure cards + state->supplyCount[copper] = 60 - (7 * numPlayers); + state->supplyCount[silver] = 40; + state->supplyCount[gold] = 30; + + //set number of Kingdom cards + for (i = adventurer; i <= treasure_map; i++) //loop all cards + { + for (j = 0; j < 10; j++) //loop chosen cards + { + if (kingdomCards[j] == i) + { + //check if card is a 'Victory' Kingdom card + if (kingdomCards[j] == great_hall || kingdomCards[j] == gardens) + { + if (numPlayers == 2) { + state->supplyCount[i] = 8; + } + else { + state->supplyCount[i] = 12; + } + } + else + { + state->supplyCount[i] = 10; + } + break; + } + else //card is not in the set choosen for the game + { + state->supplyCount[i] = -1; + } + } + + } + + //////////////////////// + //supply intilization complete + + //set player decks + for (i = 0; i < numPlayers; i++) + { + state->deckCount[i] = 0; + for (j = 0; j < 3; j++) + { + state->deck[i][j] = estate; + state->deckCount[i]++; + } + for (j = 3; j < 10; j++) + { + state->deck[i][j] = copper; + state->deckCount[i]++; + } + } + + //shuffle player decks + for (i = 0; i < numPlayers; i++) + { + if ( shuffle(i, state) < 0 ) + { + return -1; + } + } + + //draw player hands + for (i = 0; i < numPlayers; i++) + { + //initialize hand size to zero + state->handCount[i] = 0; + state->discardCount[i] = 0; + //draw 5 cards + // for (j = 0; j < 5; j++) + // { + // drawCard(i, state); + // } + } + + //set embargo tokens to 0 for all supply piles + for (i = 0; i <= treasure_map; i++) + { + state->embargoTokens[i] = 0; + } + + //initialize first player's turn + state->outpostPlayed = 0; + state->phase = 0; + state->numActions = 1; + state->numBuys = 1; + state->playedCardCount = 0; + state->whoseTurn = 0; + state->handCount[state->whoseTurn] = 0; + //int it; move to top + + //Moved draw cards to here, only drawing at the start of a turn + for (it = 0; it < 5; it++) { + drawCard(state->whoseTurn, state); + } + + updateCoins(state->whoseTurn, state, 0); + + return 0; +} + +int shuffle(int player, struct gameState *state) { + + + int newDeck[MAX_DECK]; + int newDeckPos = 0; + int card; + int i; + + if (state->deckCount[player] < 1) + return -1; + qsort ((void*)(state->deck[player]), state->deckCount[player], sizeof(int), compare); + /* SORT CARDS IN DECK TO ENSURE DETERMINISM! */ + + while (state->deckCount[player] > 0) { + card = floor(Random() * state->deckCount[player]); + newDeck[newDeckPos] = state->deck[player][card]; + newDeckPos++; + for (i = card; i < state->deckCount[player]-1; i++) { + state->deck[player][i] = state->deck[player][i+1]; + } + state->deckCount[player]--; + } + for (i = 0; i < newDeckPos; i++) { + state->deck[player][i] = newDeck[i]; + state->deckCount[player]++; + } + + return 0; +} + +int playCard(int handPos, int choice1, int choice2, int choice3, struct gameState *state) +{ + int card; + int coin_bonus = 0; //tracks coins gain from actions + + //check if it is the right phase + if (state->phase != 0) + { + return -1; + } + + //check if player has enough actions + if ( state->numActions < 1 ) + { + return -1; + } + + //get card played + card = handCard(handPos, state); + + //check if selected card is an action + if ( card < adventurer || card > treasure_map ) + { + return -1; + } + + //play card + if ( cardEffect(card, choice1, choice2, choice3, state, handPos, &coin_bonus) < 0 ) + { + return -1; + } + + //reduce number of actions + state->numActions--; + + //update coins (Treasure cards may be added with card draws) + updateCoins(state->whoseTurn, state, coin_bonus); + + return 0; +} + +int buyCard(int supplyPos, struct gameState *state) { + int who; + if (DEBUG) { + printf("Entering buyCard...\n"); + } + + // I don't know what to do about the phase thing. + + who = state->whoseTurn; + + if (state->numBuys < 1) { + if (DEBUG) + printf("You do not have any buys left\n"); + return -1; + } else if (supplyCount(supplyPos, state) <1) { + if (DEBUG) + printf("There are not any of that type of card left\n"); + return -1; + } else if (state->coins < getCost(supplyPos)) { + if (DEBUG) + printf("You do not have enough money to buy that. You have %d coins.\n", state->coins); + return -1; + } else { + state->phase=1; + //state->supplyCount[supplyPos]--; + gainCard(supplyPos, state, 0, who); //card goes in discard, this might be wrong.. (2 means goes into hand, 0 goes into discard) + + state->coins = (state->coins) - (getCost(supplyPos)); + state->numBuys--; + if (DEBUG) + printf("You bought card number %d for %d coins. You now have %d buys and %d coins.\n", supplyPos, getCost(supplyPos), state->numBuys, state->coins); + } + + //state->discard[who][state->discardCount[who]] = supplyPos; + //state->discardCount[who]++; + + return 0; +} + +int numHandCards(struct gameState *state) { + return state->handCount[ whoseTurn(state) ]; +} + +int handCard(int handPos, struct gameState *state) { + int currentPlayer = whoseTurn(state); + return state->hand[currentPlayer][handPos]; +} + +int supplyCount(int card, struct gameState *state) { + return state->supplyCount[card]; +} + +int fullDeckCount(int player, int card, struct gameState *state) { + int i; + int count = 0; + + for (i = 0; i < state->deckCount[player]; i++) + { + if (state->deck[player][i] == card) count++; + } + + for (i = 0; i < state->handCount[player]; i++) + { + if (state->hand[player][i] == card) count++; + } + + for (i = 0; i < state->discardCount[player]; i++) + { + if (state->discard[player][i] == card) count++; + } + + return count; +} + +int whoseTurn(struct gameState *state) { + return state->whoseTurn; +} + +int endTurn(struct gameState *state) { + int k; + int i; + int currentPlayer = whoseTurn(state); + + //Discard hand + for (i = 0; i < state->handCount[currentPlayer]; i++) { + state->discard[currentPlayer][state->discardCount[currentPlayer]++] = state->hand[currentPlayer][i];//Discard + state->hand[currentPlayer][i] = -1;//Set card to -1 + } + state->handCount[currentPlayer] = 0;//Reset hand count + + //Code for determining the player + if (currentPlayer < (state->numPlayers - 1)) { + state->whoseTurn = currentPlayer + 1;//Still safe to increment + } + else { + state->whoseTurn = 0;//Max player has been reached, loop back around to player 1 + } + + state->outpostPlayed = 0; + state->phase = 0; + state->numActions = 1; + state->coins = 0; + state->numBuys = 1; + state->playedCardCount = 0; + state->handCount[state->whoseTurn] = 0; + + //int k; move to top + //Next player draws hand + for (k = 0; k < 5; k++) { + drawCard(state->whoseTurn, state);//Draw a card + } + + //Update money + updateCoins(state->whoseTurn, state, 0); + + return 0; +} + +int isGameOver(struct gameState *state) { + int i; + int j; + + //if stack of Province cards is empty, the game ends + if (state->supplyCount[province] == 0) + { + return 1; + } + + //if three supply pile are at 0, the game ends + j = 0; + for (i = 0; i < 25; i++) + { + if (state->supplyCount[i] == 0) + { + j++; + } + } + if ( j >= 3) + { + return 1; + } + + return 0; +} + +int scoreFor (int player, struct gameState *state) { + + int i; + int score = 0; + //score from hand + for (i = 0; i < state->handCount[player]; i++) + { + if (state->hand[player][i] == curse) { + score = score - 1; + }; + if (state->hand[player][i] == estate) { + score = score + 1; + }; + if (state->hand[player][i] == duchy) { + score = score + 3; + }; + if (state->hand[player][i] == province) { + score = score + 6; + }; + if (state->hand[player][i] == great_hall) { + score = score + 1; + }; + if (state->hand[player][i] == gardens) { + score = score + ( fullDeckCount(player, 0, state) / 10 ); + }; + } + + //score from discard + for (i = 0; i < state->discardCount[player]; i++) + { + if (state->discard[player][i] == curse) { + score = score - 1; + }; + if (state->discard[player][i] == estate) { + score = score + 1; + }; + if (state->discard[player][i] == duchy) { + score = score + 3; + }; + if (state->discard[player][i] == province) { + score = score + 6; + }; + if (state->discard[player][i] == great_hall) { + score = score + 1; + }; + if (state->discard[player][i] == gardens) { + score = score + ( fullDeckCount(player, 0, state) / 10 ); + }; + } + + //score from deck + for (i = 0; i < state->discardCount[player]; i++) + { + if (state->deck[player][i] == curse) { + score = score - 1; + }; + if (state->deck[player][i] == estate) { + score = score + 1; + }; + if (state->deck[player][i] == duchy) { + score = score + 3; + }; + if (state->deck[player][i] == province) { + score = score + 6; + }; + if (state->deck[player][i] == great_hall) { + score = score + 1; + }; + if (state->deck[player][i] == gardens) { + score = score + ( fullDeckCount(player, 0, state) / 10 ); + }; + } + + return score; +} + +int getWinners(int players[MAX_PLAYERS], struct gameState *state) { + int i; + int j; + int highScore; + int currentPlayer; + + //get score for each player + for (i = 0; i < MAX_PLAYERS; i++) + { + //set unused player scores to -9999 + if (i >= state->numPlayers) + { + players[i] = -9999; + } + else + { + players[i] = scoreFor (i, state); + } + } + + //find highest score + j = 0; + for (i = 0; i < MAX_PLAYERS; i++) + { + if (players[i] > players[j]) + { + j = i; + } + } + highScore = players[j]; + + //add 1 to players who had less turns + currentPlayer = whoseTurn(state); + for (i = 0; i < MAX_PLAYERS; i++) + { + if ( players[i] == highScore && i > currentPlayer ) + { + players[i]++; + } + } + + //find new highest score + j = 0; + for (i = 0; i < MAX_PLAYERS; i++) + { + if ( players[i] > players[j] ) + { + j = i; + } + } + highScore = players[j]; + + //set winners in array to 1 and rest to 0 + for (i = 0; i < MAX_PLAYERS; i++) + { + if ( players[i] == highScore ) + { + players[i] = 1; + } + else + { + players[i] = 0; + } + } + + return 0; +} + +int drawCard(int player, struct gameState *state) +{ int count; + int deckCounter; + if (state->deckCount[player] <= 0) { //Deck is empty + + //Step 1 Shuffle the discard pile back into a deck + int i; + //Move discard to deck + for (i = 0; i < state->discardCount[player]; i++) { + state->deck[player][i] = state->discard[player][i]; + state->discard[player][i] = -1; + } + + state->deckCount[player] = state->discardCount[player]; + state->discardCount[player] = 0;//Reset discard + + //Shufffle the deck + shuffle(player, state);//Shuffle the deck up and make it so that we can draw + + if (DEBUG) { //Debug statements + printf("Deck count now: %d\n", state->deckCount[player]); + } + + state->discardCount[player] = 0; + + //Step 2 Draw Card + count = state->handCount[player];//Get current player's hand count + + if (DEBUG) { //Debug statements + printf("Current hand count: %d\n", count); + } + + deckCounter = state->deckCount[player];//Create a holder for the deck count + + if (deckCounter == 0) + return -1; + + state->hand[player][count] = state->deck[player][deckCounter - 1];//Add card to hand + state->deckCount[player]--; + state->handCount[player]++;//Increment hand count + } + + else { + int count = state->handCount[player];//Get current hand count for player + int deckCounter; + if (DEBUG) { //Debug statements + printf("Current hand count: %d\n", count); + } + + deckCounter = state->deckCount[player];//Create holder for the deck count + state->hand[player][count] = state->deck[player][deckCounter - 1];//Add card to the hand + state->deckCount[player]--; + state->handCount[player]++;//Increment hand count + } + + return 0; +} + +int getCost(int cardNumber) +{ + switch( cardNumber ) + { + case curse: + return 0; + case estate: + return 2; + case duchy: + return 5; + case province: + return 8; + case copper: + return 0; + case silver: + return 3; + case gold: + return 6; + case adventurer: + return 6; + case council_room: + return 5; + case feast: + return 4; + case gardens: + return 4; + case mine: + return 5; + case remodel: + return 4; + case smithy: + return 4; + case village: + return 3; + case baron: + return 4; + case great_hall: + return 3; + case minion: + return 5; + case steward: + return 3; + case tribute: + return 5; + case ambassador: + return 3; + case cutpurse: + return 4; + case embargo: + return 2; + case outpost: + return 5; + case salvager: + return 4; + case sea_hag: + return 4; + case treasure_map: + return 4; + } + + return -1; +} + +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: + while(drawntreasure<2) { + if (state->deckCount[currentPlayer] <1) { //if the deck is empty we need to shuffle discard and add to deck + shuffle(currentPlayer, state); + } + drawCard(currentPlayer, state); + cardDrawn = state->hand[currentPlayer][state->handCount[currentPlayer]-1];//top card of hand is most recently drawn card. + if (cardDrawn == copper || cardDrawn == silver || cardDrawn == gold) + drawntreasure++; + else { + temphand[z]=cardDrawn; + state->handCount[currentPlayer]--; //this should just remove the top card (the most recently drawn one). + z++; + } + } + while(z-1>=0) { + state->discard[currentPlayer][state->discardCount[currentPlayer]++]=temphand[z-1]; // discard all cards in play that have been drawn + z=z-1; + } + return 0; + + case council_room: + //+4 Cards + for (i = 0; i < 4; i++) + { + drawCard(currentPlayer, state); + } + + //+1 Buy + state->numBuys++; + + //Each other player draws a card + for (i = 0; i < state->numPlayers; i++) + { + if ( i != currentPlayer ) + { + drawCard(i, state); + } + } + + //put played card in played card pile + discardCard(handPos, currentPlayer, state, 0); + + 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: + //+3 Cards + for (i = 0; i < 3; i++) + { + drawCard(currentPlayer, state); + } + + //discard card from hand + discardCard(handPos, currentPlayer, state, 0); + return 0; + + case village: + //+1 Card + drawCard(currentPlayer, state); + + //+2 Actions + state->numActions = state->numActions + 2; + + //discard played card from hand + discardCard(handPos, currentPlayer, state, 0); + return 0; + + case baron: + state->numBuys++;//Increase buys by 1! + if (choice1 > 0) { //Boolean true or going to discard an estate + int p = 0;//Iterator for hand! + int card_not_discarded = 1;//Flag for discard set! + while(card_not_discarded) { + if (state->hand[currentPlayer][p] == estate) { //Found an estate card! + state->coins += 4;//Add 4 coins to the amount of coins + state->discard[currentPlayer][state->discardCount[currentPlayer]] = state->hand[currentPlayer][p]; + state->discardCount[currentPlayer]++; + for (; p < state->handCount[currentPlayer]; p++) { + state->hand[currentPlayer][p] = state->hand[currentPlayer][p+1]; + } + state->hand[currentPlayer][state->handCount[currentPlayer]] = -1; + state->handCount[currentPlayer]--; + card_not_discarded = 0;//Exit the loop + } + else if (p > state->handCount[currentPlayer]) { + if(DEBUG) { + printf("No estate cards in your hand, invalid choice\n"); + printf("Must gain an estate if there are any\n"); + } + if (supplyCount(estate, state) > 0) { + gainCard(estate, state, 0, currentPlayer); + + state->supplyCount[estate]--;//Decrement estates + if (supplyCount(estate, state) == 0) { + isGameOver(state); + } + } + card_not_discarded = 0;//Exit the loop + } + + else { + p++;//Next card + } + } + } + + else { + if (supplyCount(estate, state) > 0) { + gainCard(estate, state, 0, currentPlayer);//Gain an estate + + state->supplyCount[estate]--;//Decrement Estates + if (supplyCount(estate, state) == 0) { + isGameOver(state); + } + } + } + + + 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) + { + 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; +} + +int discardCard(int handPos, int currentPlayer, struct gameState *state, int trashFlag) +{ + + //if card is not trashed, added to Played pile + if (trashFlag < 1) + { + //add card to played pile + state->playedCards[state->playedCardCount] = state->hand[currentPlayer][handPos]; + state->playedCardCount++; + } + + //set played card to -1 + state->hand[currentPlayer][handPos] = -1; + + //remove card from player's hand + if ( handPos == (state->handCount[currentPlayer] - 1) ) //last card in hand array is played + { + //reduce number of cards in hand + state->handCount[currentPlayer]--; + } + else if ( state->handCount[currentPlayer] == 1 ) //only one card in hand + { + //reduce number of cards in hand + state->handCount[currentPlayer]--; + } + else + { + //replace discarded card with last card in hand + state->hand[currentPlayer][handPos] = state->hand[currentPlayer][ (state->handCount[currentPlayer] - 1)]; + //set last card to -1 + state->hand[currentPlayer][state->handCount[currentPlayer] - 1] = -1; + //reduce number of cards in hand + state->handCount[currentPlayer]--; + } + + return 0; +} + +int gainCard(int supplyPos, struct gameState *state, int toFlag, int player) +{ + //Note: supplyPos is enum of choosen card + + //check if supply pile is empty (0) or card is not used in game (-1) + if ( supplyCount(supplyPos, state) < 1 ) + { + return -1; + } + + //added card for [whoseTurn] current player: + // toFlag = 0 : add to discard + // toFlag = 1 : add to deck + // toFlag = 2 : add to hand + + if (toFlag == 1) + { + state->deck[ player ][ state->deckCount[player] ] = supplyPos; + state->deckCount[player]++; + } + else if (toFlag == 2) + { + state->hand[ player ][ state->handCount[player] ] = supplyPos; + state->handCount[player]++; + } + else + { + state->discard[player][ state->discardCount[player] ] = supplyPos; + state->discardCount[player]++; + } + + //decrease number in supply pile + state->supplyCount[supplyPos]--; + + return 0; +} + +int updateCoins(int player, struct gameState *state, int bonus) +{ + int i; + + //reset coin count + state->coins = 0; + + //add coins for each Treasure card in player's hand + for (i = 0; i < state->handCount[player]; i++) + { + if (state->hand[player][i] == copper) + { + state->coins += 1; + } + else if (state->hand[player][i] == silver) + { + state->coins += 2; + } + else if (state->hand[player][i] == gold) + { + state->coins += 3; + } + } + + //add bonus + state->coins += bonus; + + return 0; +} + + +//end of dominion.c + diff --git a/projects/johansen/dominion/dominion.h b/projects/johansen/dominion/dominion.h new file mode 100644 index 000000000..19a3c844d --- /dev/null +++ b/projects/johansen/dominion/dominion.h @@ -0,0 +1,131 @@ +#ifndef _DOMINION_H +#define _DOMINION_H + +// Code from various sources, baseline from Kristen Bartosz + +#define MAX_HAND 500 +#define MAX_DECK 500 + +#define MAX_PLAYERS 4 + +#define DEBUG 0 + +/* http://dominion.diehrstraits.com has card texts */ +/* http://dominion.isotropic.org has other stuff */ + +/* hand# means index of a card in current active player's hand */ + +enum CARD +{ curse = 0, + estate, + duchy, + province, + + copper, + silver, + gold, + + adventurer, + /* If no/only 1 treasure found, stop when full deck seen */ + council_room, + feast, /* choice1 is supply # of card gained) */ + gardens, + mine, /* choice1 is hand# of money to trash, choice2 is supply# of + money to put in hand */ + remodel, /* choice1 is hand# of card to remodel, choice2 is supply# */ + smithy, + village, + + baron, /* choice1: boolean for discard of estate */ + /* Discard is always of first (lowest index) estate */ + great_hall, + minion, /* choice1: 1 = +2 coin, 2 = redraw */ + steward, /* choice1: 1 = +2 card, 2 = +2 coin, 3 = trash 2 (choice2,3) */ + tribute, + + ambassador, /* choice1 = hand#, choice2 = number to return to supply */ + cutpurse, + embargo, /* choice1 = supply# */ + outpost, + salvager, /* choice1 = hand# to trash */ + sea_hag, + treasure_map +}; + +struct gameState { + int numPlayers; //number of players + int supplyCount[treasure_map+1]; //this is the amount of a specific type of card given a specific number. + int embargoTokens[treasure_map+1]; + int outpostPlayed; + int outpostTurn; + int whoseTurn; + int phase; + int numActions; /* Starts at 1 each turn */ + int coins; /* Use as you see fit! */ + int numBuys; /* Starts at 1 each turn */ + int hand[MAX_PLAYERS][MAX_HAND]; + int handCount[MAX_PLAYERS]; + int deck[MAX_PLAYERS][MAX_DECK]; + int deckCount[MAX_PLAYERS]; + int discard[MAX_PLAYERS][MAX_DECK]; + int discardCount[MAX_PLAYERS]; + int playedCards[MAX_DECK]; + int playedCardCount; +}; + +/* All functions return -1 on failure, and DO NOT CHANGE GAME STATE; + unless specified for other return, return 0 on success */ + +struct gameState* newGame(); + +int* kingdomCards(int k1, int k2, int k3, int k4, int k5, int k6, int k7, + int k8, int k9, int k10); + +int initializeGame(int numPlayers, int kingdomCards[10], int randomSeed, + struct gameState *state); +/* Responsible for initializing all supplies, and shuffling deck and + drawing starting hands for all players. Check that 10 cards selected + are in fact (different) kingdom cards, and that numPlayers is valid. + +Cards not in game should initialize supply position to -1 */ + +int shuffle(int player, struct gameState *state); +/* Assumes all cards are now in deck array (or hand/played): discard is + empty */ + +int playCard(int handPos, int choice1, int choice2, int choice3, + struct gameState *state); +/* Play card with index handPos from current player's hand */ + +int buyCard(int supplyPos, struct gameState *state); +/* Buy card with supply index supplyPos */ + +int numHandCards(struct gameState *state); +/* How many cards current player has in hand */ + +int handCard(int handNum, struct gameState *state); +/* enum value of indexed card in player's hand */ + +int supplyCount(int card, struct gameState *state); +/* How many of given card are left in supply */ + +int fullDeckCount(int player, int card, struct gameState *state); +/* Here deck = hand + discard + deck */ + +int whoseTurn(struct gameState *state); + +int endTurn(struct gameState *state); +/* Must do phase C and advance to next player; do not advance whose turn + if game is over */ + +int isGameOver(struct gameState *state); + +int scoreFor(int player, struct gameState *state); +/* Negative here does not mean invalid; scores may be negative, + -9999 means invalid input */ + +int getWinners(int players[MAX_PLAYERS], struct gameState *state); +/* Set array position of each player who won (remember ties!) to + 1, others to 0 */ + +#endif diff --git a/projects/johansen/dominion/dominion_helpers.h b/projects/johansen/dominion/dominion_helpers.h new file mode 100644 index 000000000..2cecbaf83 --- /dev/null +++ b/projects/johansen/dominion/dominion_helpers.h @@ -0,0 +1,15 @@ +#ifndef _DOMINION_HELPERS_H +#define _DOMINION_HELPERS_H + +#include "dominion.h" + +int drawCard(int player, struct gameState *state); +int updateCoins(int player, struct gameState *state, int bonus); +int discardCard(int handPos, int currentPlayer, struct gameState *state, + int trashFlag); +int gainCard(int supplyPos, struct gameState *state, int toFlag, int player); +int getCost(int cardNumber); +int cardEffect(int card, int choice1, int choice2, int choice3, + struct gameState *state, int handPos, int *bonus); + +#endif diff --git a/projects/johansen/dominion/interface.c b/projects/johansen/dominion/interface.c new file mode 100644 index 000000000..ef6fe60b7 --- /dev/null +++ b/projects/johansen/dominion/interface.c @@ -0,0 +1,425 @@ +/* Interactive Dominion Interface + +Sam Heinith CS362 +1/26/2010 +*/ + +#include +#include +#include +#include +#include "rngs.h" +#include "interface.h" +#include "dominion.h" + + +void cardNumToName(int card, char *name) { + switch(card) { + case curse: + strcpy(name,"Curse"); + break; + case estate: + strcpy(name,"Estate"); + break; + case duchy: + strcpy(name,"Duchy"); + break; + case province: + strcpy(name,"Province"); + break; + case copper: + strcpy(name,"Copper"); + break; + case silver: + strcpy(name,"Silver"); + break; + case gold: + strcpy(name,"Gold"); + break; + case adventurer: + strcpy(name,"Adventurer"); + break; + case council_room: + strcpy(name,"Council Room"); + break; + case feast: + strcpy(name,"Feast"); + break; + case gardens: + strcpy(name,"Gardens"); + break; + case mine: + strcpy(name,"Mine"); + break; + case remodel: + strcpy(name,"Remodel"); + break; + case smithy: + strcpy(name,"Smithy"); + break; + case village: + strcpy(name,"Village"); + break; + case baron: + strcpy(name,"Baron"); + break; + case great_hall: + strcpy(name,"Great Hall"); + break; + case minion: + strcpy(name,"Minion"); + break; + case steward: + strcpy(name,"Steward"); + break; + case tribute: + strcpy(name,"Tribute"); + break; + case ambassador: + strcpy(name,"Ambassador"); + break; + case cutpurse: + strcpy(name,"Cutpurse"); + break; + case embargo: + strcpy(name,"Embargo"); + break; + case outpost: + strcpy(name,"Outpost"); + break; + case salvager: + strcpy(name,"Salvager"); + break; + case sea_hag: + strcpy(name,"Sea Hag"); + break; + case treasure_map: + strcpy(name,"Treasure Map"); + break; + + default: + strcpy(name,"?"); + } + +} + + + +int getCardCost(int card) { + int cost; + switch(card) { + case curse: + cost = CURSE_COST; + break; + case estate: + cost = ESTATE_COST; + break; + case duchy: + cost = DUCHY_COST; + break; + case province: + cost = PROVINCE_COST; + break; + case copper: + cost = COPPER_COST; + break; + case silver: + cost = SILVER_COST; + break; + case gold: + cost = GOLD_COST; + break; + case adventurer: + cost = ADVENTURER_COST; + break; + case council_room: + cost = COUNCIL_ROOM_COST; + break; + case feast: + cost = FEAST_COST; + break; + case gardens: + cost = GARDEN_COST; + break; + case mine: + cost = MINE_COST; + break; + case remodel: + cost = REMODEL_COST; + break; + case smithy: + cost = SMITHY_COST; + break; + case village: + cost = VILLAGE_COST; + break; + case baron: + cost = BARON_COST; + break; + case great_hall: + cost = GREAT_HALL_COST; + break; + case minion: + cost = MINION_COST; + break; + case steward: + cost = STEWARD_COST; + break; + case tribute: + cost = TRIBUTE_COST; + break; + case ambassador: + cost = AMBASSADOR_COST; + break; + case cutpurse: + cost = CUTPURSE_COST; + break; + case embargo: + cost = EMBARGO_COST; + break; + case outpost: + cost = OUTPOST_COST; + break; + case salvager: + cost = SALVAGER_COST; + break; + case sea_hag: + cost = SEA_HAG_COST; + break; + case treasure_map: + cost = TREASURE_MAP_COST; + break; + default: + cost = ONETHOUSAND; + } + return cost; +} + + + + + + +void printHand(int player, struct gameState *game) { + int handCount = game->handCount[player]; + int handIndex; + printf("Player %d's hand:\n", player); + if(handCount > 0) printf("# Card\n"); + for(handIndex = 0; handIndex < handCount; handIndex++) { + int card = game->hand[player][handIndex]; + char name[MAX_STRING_LENGTH]; + cardNumToName(card, name); + printf("%-2d %-13s\n", handIndex, name); + } + printf("\n"); +} + + + +void printDeck(int player, struct gameState *game) { + int deckCount = game->deckCount[player]; + int deckIndex; + printf("Player %d's deck: \n", player); + if(deckCount > 0) printf("# Card\n"); + for(deckIndex = 0; deckIndex < deckCount; deckIndex++) { + int card = game->deck[player][deckIndex]; + char name[MAX_STRING_LENGTH]; + cardNumToName(card, name); + printf("%-2d %-13s\n", deckIndex, name); + } + printf("\n"); +} + +void printPlayed(int player, struct gameState *game) { + int playedCount = game->playedCardCount; + int playedIndex; + printf("Player %d's played cards: \n", player); + if(playedCount > 0) printf("# Card\n"); + for(playedIndex = 0; playedIndex < playedCount; playedIndex++) { + int card = game->playedCards[playedIndex]; + char name[MAX_STRING_LENGTH]; + cardNumToName(card, name); + printf("%-2d %-13s \n", playedIndex, name); + } + printf("\n"); +} + + + +void printDiscard(int player, struct gameState *game) { + int discardCount = game->discardCount[player]; + int discardIndex; + printf("Player %d's discard: \n", player); + if(discardCount > 0) printf("# Card\n"); + for(discardIndex = 0; discardIndex < discardCount; discardIndex++) { + int card = game->discard[player][discardIndex]; + char name[MAX_STRING_LENGTH]; + cardNumToName(card, name); + printf("%-2d %-13s \n", discardIndex, name); + } + printf("\n"); +} + + + + +void printSupply(struct gameState *game) { + int cardNum, cardCost, cardCount; + char name[MAX_STRING_LENGTH]; + printf("# Card Cost Copies\n"); + for(cardNum = 0; cardNum < NUM_TOTAL_K_CARDS; cardNum++) { + cardCount = game->supplyCount[cardNum]; + if(cardCount == -1) continue; + cardNumToName(cardNum, name); + cardCost = getCardCost(cardNum); + printf("%-2d %-13s %-5d %-5d", cardNum, name, cardCost, cardCount); + printf("\n"); + } + printf("\n"); +} + + +void printState(struct gameState *game) { + int numActions = game->numActions; + int numCoins = game->coins; + int numBuys = game->numBuys; + int currentPlayer = game->whoseTurn; + int phase = game->phase; + char phaseName[MAX_STRING_LENGTH]; + phaseNumToName(phase,phaseName); + printf("Player %d:\n%s phase\n%d actions\n%d coins\n%d buys\n\n", currentPlayer, phaseName, numActions, numCoins, numBuys); +} + +void printScores(struct gameState *game) { + int playerNum, score[MAX_PLAYERS]; + int numPlayers = game->numPlayers; + for(playerNum = 0; playerNum < numPlayers; playerNum++) { + score[playerNum] = scoreFor(playerNum,game); + printf("Player %d has a score of %d\n", playerNum, score[playerNum]); + } +} + + +void printHelp(void) { + printf("Commands are: \n\ + add [Supply Card Number] - add any card to your hand (teh hacks)\n\ + buy [Supply Card Number] - buy a card at supply position\n\ + end - end your turn\n\ + init [Number of Players] [Number of Bots] - initialize the game\n\ + num - print number of cards in your hand\n\ + play [Hand Index] [Choice] [Choice] [Choice] - play a card from your hand\n\ + resign - end the game showing the current scores\n\ + show - show your current hand\n\ + stat - show your turn's status\n\ + supp - show the supply\n\ + whos - whos turn\n\ + exit - exit the interface"); + printf("\n\n"); + +} + + +void phaseNumToName(int phase, char *name) { + switch(phase) { + case ACTION_PHASE: + strcpy(name,"Action"); + break; + case BUY_PHASE: + strcpy(name,"Buy"); + break; + case CLEANUP_PHASE: + strcpy(name,"Cleanup"); + break; + } +} + + +int addCardToHand(int player, int card, struct gameState *game) { + if(card >= adventurer && card < NUM_TOTAL_K_CARDS) { + int handTop = game->handCount[player]; + game->hand[player][handTop] = card; + game->handCount[player]++; + return SUCCESS; + } else { + return FAILURE; + } + +} + +void selectKingdomCards(int randomSeed, int kingCards[NUM_K_CARDS]) { + int i, used, card, numSelected = 0; + SelectStream(1); + PutSeed((long)randomSeed); + + + while(numSelected < NUM_K_CARDS) { + used = FALSE; + card = floor(Random() * NUM_TOTAL_K_CARDS); + if(card < adventurer) continue; + for(i = 0; i < numSelected; i++) { + if(kingCards[i] == card) { + used = TRUE; + break; + } + } + if(used == TRUE) continue; + kingCards[numSelected] = card; + numSelected++; + } +} + + +int countHandCoins(int player, struct gameState *game) { + int card, index, coinage = 0; + + for(index = 0; index < game->handCount[player]; index++) { + card = game->hand[player][index]; + switch(card) { + case copper: + coinage += COPPER_VALUE; + break; + case silver: + coinage += SILVER_VALUE; + break; + case gold: + coinage += GOLD_VALUE; + break; + } + } + return coinage; +} + + +void executeBotTurn(int player, int *turnNum, struct gameState *game) { + int coins = countHandCoins(player, game); + + printf("*****************Executing Bot Player %d Turn Number %d*****************\n", player, *turnNum); + printSupply(game); + //sleep(1); //Thinking... + + if(coins >= PROVINCE_COST && supplyCount(province,game) > 0) { + buyCard(province,game); + printf("Player %d buys card Province\n\n", player); + } + else if(supplyCount(province,game) == 0 && coins >= DUCHY_COST ) { + buyCard(duchy,game); + printf("Player %d buys card Duchy\n\n", player); + } + else if(coins >= GOLD_COST && supplyCount(gold,game) > 0) { + buyCard(gold,game); + printf("Player %d buys card Gold\n\n", player); + } + else if(coins >= SILVER_COST && supplyCount(silver,game) > 0) { + buyCard(silver,game); + printf("Player %d buys card Silver\n\n", player); + + } + + + if(player == (game->numPlayers -1)) (*turnNum)++; + endTurn(game); + if(! isGameOver(game)) { + int currentPlayer = whoseTurn(game); + printf("Player %d's turn number %d\n\n", currentPlayer, (*turnNum)); + } +} diff --git a/projects/johansen/dominion/interface.h b/projects/johansen/dominion/interface.h new file mode 100644 index 000000000..a4ac15d99 --- /dev/null +++ b/projects/johansen/dominion/interface.h @@ -0,0 +1,128 @@ +/* Interactive Dominion Interface + + Sam Heinith CS362 + 1/26/2010 +*/ + + + +#ifndef _INTERFACE_H +#define _INTERFACE_H + + + +#include "dominion.h" + +//Last card enum (Treasure map) card number plus one for the 0th card. +#define NUM_TOTAL_K_CARDS (treasure_map + 1) +#define NUM_K_CARDS 10 +#define NUM_V_CARDS_2 8 +#define NUM_V_CARDS_3or4 12 +#define NUM_C_CARDS_2 10 +#define NUM_C_CARDS_3 20 +#define NUM_C_CARDS_4 30 +#define NUM_COPPER 60 +#define NUM_SILVER 40 +#define NUM_GOLD 30 +#define UNUSED -1 +#define START_COPPER 7 +#define START_ESTATE 3 +#define HANDSIZE 5 + +#define COMPARE(string1, string2) strncmp(string1, string2, 4) +#define MAX_STRING_LENGTH 32 +#define TRUE 1 +#define FALSE 0 + +#define SUCCESS 0 +#define FAILURE -1 + +#define MATCH 0 +#define WINNER 1 +#define NOT_WINNER 0 + +//The Game Phases +#define ACTION_PHASE 0 +#define BUY_PHASE 1 +#define CLEANUP_PHASE 2 + +#define COPPER_VALUE 1 +#define SILVER_VALUE 2 +#define GOLD_VALUE 3 + +//From Dominion List Spoiler +#define COPPER_COST 0 +#define SILVER_COST 3 +#define GOLD_COST 6 +#define ESTATE_COST 2 +#define DUCHY_COST 5 +#define PROVINCE_COST 8 +#define CURSE_COST 0 +#define ADVENTURER_COST 6 +#define COUNCIL_ROOM_COST 5 +#define FEAST_COST 4 +#define GARDEN_COST 4 +#define MINE_COST 5 +#define MONEYLENDER_COST 4 +#define REMODEL_COST 4 +#define SMITHY_COST 4 +#define VILLAGE_COST 3 +#define WOODCUTTER_COST 3 +#define BARON_COST 4 +#define GREAT_HALL_COST 3 +#define MINION_COST 5 +#define SHANTY_TOWN_COST 3 +#define STEWARD_COST 3 +#define TRIBUTE_COST 5 +#define WISHING_WELL_COST 3 +#define AMBASSADOR_COST 3 +#define CUTPURSE_COST 4 +#define EMBARGO_COST 2 +#define OUTPOST_COST 5 +#define SALVAGER_COST 4 +#define SEA_HAG_COST 4 +#define TREASURE_MAP_COST 4 +#define ONETHOUSAND 1000 + + +int addCardToHand(int player, int card, struct gameState *game); + +int countHandCoins(int player, struct gameState *game); + + +void executeBotTurn(int player, int *turnNum, struct gameState *game); + +void phaseNumToName(int phase, char *name); +void cardNumToName(int card, char *name); + +int getCardCost(int card); + +void printHelp(void); + +void printHand(int player, struct gameState *game); + +void printDeck(int player, struct gameState *game); + +void printDiscard(int player, struct gameState *game); + +void printPlayed(int player, struct gameState *game); + +void printState(struct gameState *game); + +void printSupply(struct gameState *game); + +void printGameState(struct gameState *game); + +void printScores(struct gameState *game); + +void selectKingdomCards(int randomSeed, int kingdomCards[NUM_K_CARDS]); + + + +#endif + + + + + + diff --git a/projects/johansen/dominion/playdom.c b/projects/johansen/dominion/playdom.c new file mode 100644 index 000000000..c8552c941 --- /dev/null +++ b/projects/johansen/dominion/playdom.c @@ -0,0 +1,135 @@ +#include "dominion.h" +#include +#include "rngs.h" +#include + +int main (int argc, char** argv) { + struct gameState G; + int k[10] = {adventurer, gardens, embargo, village, minion, mine, cutpurse, + sea_hag, tribute, smithy + }; + + printf ("Starting game.\n"); + + initializeGame(2, k, atoi(argv[1]), &G); + + int money = 0; + int smithyPos = -1; + int adventurerPos = -1; + int i=0; + + int numSmithies = 0; + int numAdventurers = 0; + + while (!isGameOver(&G)) { + money = 0; + smithyPos = -1; + adventurerPos = -1; + for (i = 0; i < numHandCards(&G); i++) { + if (handCard(i, &G) == copper) + money++; + else if (handCard(i, &G) == silver) + money += 2; + else if (handCard(i, &G) == gold) + money += 3; + else if (handCard(i, &G) == smithy) + smithyPos = i; + else if (handCard(i, &G) == adventurer) + adventurerPos = i; + } + + if (whoseTurn(&G) == 0) { + if (smithyPos != -1) { + printf("0: smithy played from position %d\n", smithyPos); + playCard(smithyPos, -1, -1, -1, &G); + printf("smithy played.\n"); + money = 0; + i=0; + while(i= 8) { + printf("0: bought province\n"); + buyCard(province, &G); + } + else if (money >= 6) { + printf("0: bought gold\n"); + buyCard(gold, &G); + } + else if ((money >= 4) && (numSmithies < 2)) { + printf("0: bought smithy\n"); + buyCard(smithy, &G); + numSmithies++; + } + else if (money >= 3) { + printf("0: bought silver\n"); + buyCard(silver, &G); + } + + printf("0: end turn\n"); + endTurn(&G); + } + else { + if (adventurerPos != -1) { + printf("1: adventurer played from position %d\n", adventurerPos); + playCard(adventurerPos, -1, -1, -1, &G); + money = 0; + i=0; + while(i= 8) { + printf("1: bought province\n"); + buyCard(province, &G); + } + else if ((money >= 6) && (numAdventurers < 2)) { + printf("1: bought adventurer\n"); + buyCard(adventurer, &G); + numAdventurers++; + } else if (money >= 6) { + printf("1: bought gold\n"); + buyCard(gold, &G); + } + else if (money >= 3) { + printf("1: bought silver\n"); + buyCard(silver, &G); + } + printf("1: endTurn\n"); + + endTurn(&G); + } + } // end of While + + printf ("Finished game.\n"); + printf ("Player 0: %d\nPlayer 1: %d\n", scoreFor(0, &G), scoreFor(1, &G)); + + return 0; +} diff --git a/projects/johansen/dominion/player.c b/projects/johansen/dominion/player.c new file mode 100644 index 000000000..ad81d9c5e --- /dev/null +++ b/projects/johansen/dominion/player.c @@ -0,0 +1,205 @@ +/* Interactive Dominion Interface + Version 7 + + Sam Heinith CS362 + Questions/Comments: + heiniths@onid.orst.edu + 1/26/2010 +*/ + + +#include +#include +#include +#include +#include +#include +#include +#include "dominion.h" +#include "interface.h" +#include "rngs.h" + + +int main2(int argc, char *argv[]) { + //Default cards, as defined in playDom + int k[10] = {adventurer, gardens, embargo, village, minion, mine, cutpurse, sea_hag, tribute, smithy}; + struct gameState g; + initializeGame(2,k,1,&g); + printf ("SUCCESSFUL INIT\n"); + getchar(); + return 0; +} + +int main(int argc, char* argv[]) { + char *add = "add"; + char *buyC = "buy"; + char *endT = "end"; + char *exit = "exit"; + char *help = "help"; + char *init = "init"; + char *numH = "num"; + char *play = "play"; + char *resign = "resi"; + char *show = "show"; + char *stat = "stat"; + char *supply = "supp"; + char *whos = "whos"; + + char command[MAX_STRING_LENGTH]; + char line[MAX_STRING_LENGTH]; + char cardName[MAX_STRING_LENGTH]; + + //Array to hold bot presence + int isBot[MAX_PLAYERS] = { 0, 0, 0, 0}; + + int players[MAX_PLAYERS]; + int playerNum; + int outcome; + int currentPlayer; + int gameOver = FALSE; + int gameStarted = FALSE; + int turnNum = 0; + + int randomSeed = atoi(argv[1]); + + //Default cards, as defined in playDom + int kCards[10] = {adventurer, gardens, embargo, village, minion, mine, cutpurse, sea_hag, tribute, smithy}; + + struct gameState g; + struct gameState * game = &g; + + memset(game,0,sizeof(struct gameState)); + + if(argc != 2) { + printf("Usage: player [integer random number seed]\n"); + return EXIT_SUCCESS; + } + + if(randomSeed <= 0) { + printf("Usage: player [integer random number seed]\n"); + return EXIT_SUCCESS; + } + + initializeGame(2,kCards,randomSeed,game); + + printf("Please enter a command or \"help\" for commands\n"); + + + while(TRUE) { + int arg0 = UNUSED; + int arg1 = UNUSED; + int arg2 = UNUSED; + int arg3 = UNUSED; + + outcome = FAILURE; + strcpy(line,""); + strcpy(command,""); + strcpy(cardName,""); + + currentPlayer = whoseTurn(game); + + //If you are getting a seg fault comment this if block out + gameOver = isGameOver(game); + if(gameStarted == TRUE && gameOver == TRUE) { + printScores(game); + getWinners(players, game); + printf("After %d turns, the winner(s) are:\n", turnNum); + for(playerNum = 0; playerNum < game->numPlayers; playerNum++) { + if(players[playerNum] == WINNER) printf("Player %d\n", playerNum); + } + for(playerNum = 0; playerNum < game->numPlayers; playerNum++) { + printHand(playerNum, game); + printPlayed(playerNum, game); + printDiscard(playerNum, game); + printDeck(playerNum, game); + } + + break; //Exit out of the game/while loop + } + + + if(isBot[currentPlayer] == TRUE) { + executeBotTurn(currentPlayer, &turnNum, game); + continue; + } + + printf("$ "); + fgets(line, MAX_STRING_LENGTH, stdin); + sscanf(line, "%s %d %d %d %d", command, &arg0, &arg1, &arg2, &arg3); + + + if(COMPARE(command, add) == 0) { + outcome = addCardToHand(currentPlayer, arg0, game); + cardNumToName(arg0, cardName); + printf("Player %d adds %s to their hand\n\n", currentPlayer, cardName); + } else if(COMPARE(command, buyC) == 0) { + outcome = buyCard(arg0, game); + cardNumToName(arg0, cardName); + if(outcome == SUCCESS) { + printf("Player %d buys card %d, %s\n\n", currentPlayer, arg0, cardName); + } else { + printf("Player %d cannot buy card %d, %s\n\n", currentPlayer, arg0, cardName); + } + } else if(COMPARE(command, endT) == 0) { + if(gameStarted == TRUE) { + if(currentPlayer == (game->numPlayers -1)) turnNum++; + endTurn(game); + currentPlayer = whoseTurn(game); + printf("Player %d's turn number %d\n\n", currentPlayer, turnNum); + } + + } else if(COMPARE(command, exit) == 0) { + break; + } else if(COMPARE(command, help) == 0) { + printHelp(); + } else if(COMPARE(command, init) == 0) { + int numHuman = arg0 - arg1; + for(playerNum = numHuman; playerNum < arg0; playerNum++) { + isBot[playerNum] = TRUE; + } + // selectKingdomCards(randomSeed, kCards); //Comment this out to use the default card set defined in playDom. + outcome = initializeGame(arg0, kCards, randomSeed, game); + printf("\n"); + if(outcome == SUCCESS) { + gameStarted = TRUE; + currentPlayer = whoseTurn(game); + printf("Player %d's turn number %d\n\n", currentPlayer, turnNum); + } + + } else if(COMPARE(command, numH) == 0) { + int numCards = numHandCards(game); + printf("There are %d cards in your hand.\n", numCards); + } else if(COMPARE(command, play) == 0) { + int card = handCard(arg0,game); + outcome = playCard(arg0, arg1, arg2, arg3, game); + cardNumToName(card, cardName); + if(outcome == SUCCESS) { + printf("Player %d plays %s\n\n", currentPlayer, cardName); + } else { + printf("Player %d cannot play card %d\n\n", currentPlayer, arg0); + } + + } else if(COMPARE(command, resign) == 0) { + endTurn(game); + printScores(game); + break; + } else if(COMPARE(command, show) == 0) { + if(gameStarted == FALSE) continue; + printHand(currentPlayer, game); + printPlayed(currentPlayer, game); + //printDiscard(currentPlayer, game); + //printDeck(currentPlayer, game); + } else if(COMPARE(command, stat) == 0) { + if(gameStarted == FALSE) continue; + printState(game); + } else if(COMPARE(command, supply) == 0) { + printSupply(game); + } else if(COMPARE(command, whos) == 0) { + int playerNum = whoseTurn(game); + printf("Player %d's turn\n", playerNum); + } + } + + return EXIT_SUCCESS; + +} diff --git a/projects/johansen/dominion/rngs.c b/projects/johansen/dominion/rngs.c new file mode 100644 index 000000000..409b5e2cc --- /dev/null +++ b/projects/johansen/dominion/rngs.c @@ -0,0 +1,183 @@ +/* ------------------------------------------------------------------------- + * This is an ANSI C library for multi-stream random number generation. + * The use of this library is recommended as a replacement for the ANSI C + * rand() and srand() functions, particularly in simulation applications + * where the statistical 'goodness' of the random number generator is + * important. The library supplies 256 streams of random numbers; use + * SelectStream(s) to switch between streams indexed s = 0,1,...,255. + * + * The streams must be initialized. The recommended way to do this is by + * using the function PlantSeeds(x) with the value of x used to initialize + * the default stream and all other streams initialized automatically with + * values dependent on the value of x. The following convention is used + * to initialize the default stream: + * if x > 0 then x is the state + * if x < 0 then the state is obtained from the system clock + * if x = 0 then the state is to be supplied interactively. + * + * The generator used in this library is a so-called 'Lehmer random number + * generator' which returns a pseudo-random number uniformly distributed + * 0.0 and 1.0. The period is (m - 1) where m = 2,147,483,647 and the + * smallest and largest possible values are (1 / m) and 1 - (1 / m) + * respectively. For more details see: + * + * "Random Number Generators: Good Ones Are Hard To Find" + * Steve Park and Keith Miller + * Communications of the ACM, October 1988 + * + * Name : rngs.c (Random Number Generation - Multiple Streams) + * Authors : Steve Park & Dave Geyer + * Language : ANSI C + * Latest Revision : 09-22-98 + * ------------------------------------------------------------------------- + */ + +#include +#include +#include "rngs.h" + +#define MODULUS 2147483647 /* DON'T CHANGE THIS VALUE */ +#define MULTIPLIER 48271 /* DON'T CHANGE THIS VALUE */ +#define CHECK 399268537 /* DON'T CHANGE THIS VALUE */ +#define STREAMS 256 /* # of streams, DON'T CHANGE THIS VALUE */ +#define A256 22925 /* jump multiplier, DON'T CHANGE THIS VALUE */ +#define DEFAULT 123456789 /* initial seed, use 0 < DEFAULT < MODULUS */ + +static long seed[STREAMS] = {DEFAULT}; /* current state of each stream */ +static int stream = 0; /* stream index, 0 is the default */ +static int initialized = 0; /* test for stream initialization */ + + +double Random(void) +/* ---------------------------------------------------------------- + * Random returns a pseudo-random real number uniformly distributed + * between 0.0 and 1.0. + * ---------------------------------------------------------------- + */ +{ + const long Q = MODULUS / MULTIPLIER; + const long R = MODULUS % MULTIPLIER; + long t; + + t = MULTIPLIER * (seed[stream] % Q) - R * (seed[stream] / Q); + if (t > 0) + seed[stream] = t; + else + seed[stream] = t + MODULUS; + return ((double) seed[stream] / MODULUS); +} + + +void PlantSeeds(long x) +/* --------------------------------------------------------------------- + * Use this function to set the state of all the random number generator + * streams by "planting" a sequence of states (seeds), one per stream, + * with all states dictated by the state of the default stream. + * The sequence of planted states is separated one from the next by + * 8,367,782 calls to Random(). + * --------------------------------------------------------------------- + */ +{ + const long Q = MODULUS / A256; + const long R = MODULUS % A256; + int j; + int s; + + initialized = 1; + s = stream; /* remember the current stream */ + SelectStream(0); /* change to stream 0 */ + PutSeed(x); /* set seed[0] */ + stream = s; /* reset the current stream */ + for (j = 1; j < STREAMS; j++) { + x = A256 * (seed[j - 1] % Q) - R * (seed[j - 1] / Q); + if (x > 0) + seed[j] = x; + else + seed[j] = x + MODULUS; + } +} + + +void PutSeed(long x) +/* --------------------------------------------------------------- + * Use this function to set the state of the current random number + * generator stream according to the following conventions: + * if x > 0 then x is the state (unless too large) + * if x < 0 then the state is obtained from the system clock + * if x = 0 then the state is to be supplied interactively + * --------------------------------------------------------------- + */ +{ + char ok = 0; + + if (x > 0) + x = x % MODULUS; /* correct if x is too large */ + if (x < 0) + x = ((unsigned long) time((time_t *) NULL)) % MODULUS; + if (x == 0) + while (!ok) { + printf("\nEnter a positive integer seed (9 digits or less) >> "); + scanf("%ld", &x); + ok = (0 < x) && (x < MODULUS); + if (!ok) + printf("\nInput out of range ... try again\n"); + } + seed[stream] = x; +} + + +void GetSeed(long *x) +/* --------------------------------------------------------------- + * Use this function to get the state of the current random number + * generator stream. + * --------------------------------------------------------------- + */ +{ + *x = seed[stream]; +} + + +void SelectStream(int index) +/* ------------------------------------------------------------------ + * Use this function to set the current random number generator + * stream -- that stream from which the next random number will come. + * ------------------------------------------------------------------ + */ +{ + stream = ((unsigned int) index) % STREAMS; + if ((initialized == 0) && (stream != 0)) /* protect against */ + PlantSeeds(DEFAULT); /* un-initialized streams */ +} + + +void TestRandom(void) +/* ------------------------------------------------------------------ + * Use this (optional) function to test for a correct implementation. + * ------------------------------------------------------------------ + */ +{ + long i; + long x; + double u; + char ok = 0; + + SelectStream(0); /* select the default stream */ + PutSeed(1); /* and set the state to 1 */ + for(i = 0; i < 10000; i++) { + u = Random(); + if (ok) + printf(" %f \n\n", u); + + } + GetSeed(&x); /* get the new state value */ + ok = (x == CHECK); /* and check for correctness */ + + SelectStream(1); /* select stream 1 */ + PlantSeeds(1); /* set the state of all streams */ + GetSeed(&x); /* get the state of stream 1 */ + ok = ok && (x == A256); /* x should be the jump multiplier */ + if (ok) + printf("\n The implementation of rngs.c is correct.\n\n"); + else + printf("\n\a ERROR -- the implementation of rngs.c is not correct.\n\n"); +} diff --git a/projects/johansen/dominion/rngs.h b/projects/johansen/dominion/rngs.h new file mode 100644 index 000000000..9b2b6938b --- /dev/null +++ b/projects/johansen/dominion/rngs.h @@ -0,0 +1,19 @@ +/* ----------------------------------------------------------------------- + * Name : rngs.h (header file for the library file rngs.c) + * Author : Steve Park & Dave Geyer + * Language : ANSI C + * Latest Revision : 09-22-98 + * ----------------------------------------------------------------------- + */ + +#if !defined( _RNGS_ ) +#define _RNGS_ + +double Random(void); +void PlantSeeds(long x); +void GetSeed(long *x); +void PutSeed(long x); +void SelectStream(int index); +void TestRandom(void); + +#endif diff --git a/projects/johansen/dominion/rt.c b/projects/johansen/dominion/rt.c new file mode 100644 index 000000000..6f7c533c0 --- /dev/null +++ b/projects/johansen/dominion/rt.c @@ -0,0 +1,27 @@ +#include "rngs.h" +#include +#include + +int main(int argc, char** argv) { + if (argc < 3) { + printf ("Not enough inputs: seed target\n"); + } + + SelectStream(1); + PutSeed((long)atoi(argv[1])); + + int done = 0; + int c = 1000000000; + + while (!done) { + c = floor(Random() * 1000000000); + // if (c % 100000 == 0) { + // printf ("c = %d\n", c); + // } + if (c == atoi(argv[2])) { + printf ("Found the bug!\n"); + done = 1; + } + } +} + diff --git a/projects/johansen/dominion/testdrawcard.c b/projects/johansen/dominion/testdrawcard.c new file mode 100644 index 000000000..e00e19066 --- /dev/null +++ b/projects/johansen/dominion/testdrawcard.c @@ -0,0 +1,74 @@ +#include "dominion.h" +#include "dominion_helpers.h" +#include +#include +#include +#include "rngs.h" + +#define DEBUG 0 +#define NOISY_TEST 1 + +int checkDrawCard(int p, struct gameState *post) { + struct gameState pre; + memcpy (&pre, post, sizeof(struct gameState)); + + int r; + // printf ("drawCard PRE: p %d HC %d DeC %d DiC %d\n", + // p, pre.handCount[p], pre.deckCount[p], pre.discardCount[p]); + + r = drawCard (p, post); + + //printf ("drawCard POST: p %d HC %d DeC %d DiC %d\n", + // p, post->handCount[p], post->deckCount[p], post->discardCount[p]); + + if (pre.deckCount[p] > 0) { + pre.handCount[p]++; + pre.hand[p][pre.handCount[p]-1] = pre.deck[p][pre.deckCount[p]-1]; + pre.deckCount[p]--; + } else if (pre.discardCount[p] > 0) { + memcpy(pre.deck[p], post->deck[p], sizeof(int) * pre.discardCount[p]); + memcpy(pre.discard[p], post->discard[p], sizeof(int)*pre.discardCount[p]); + pre.hand[p][post->handCount[p]-1] = post->hand[p][post->handCount[p]-1]; + pre.handCount[p]++; + pre.deckCount[p] = pre.discardCount[p]-1; + pre.discardCount[p] = 0; + } + + assert (r == 0); + + assert(memcmp(&pre, post, sizeof(struct gameState)) == 0); +} + +int main () { + + int i, n, r, p, deckCount, discardCount, handCount; + + int k[10] = {adventurer, council_room, feast, gardens, mine, + remodel, smithy, village, baron, great_hall + }; + + struct gameState G; + + printf ("Testing drawCard.\n"); + + printf ("RANDOM TESTS.\n"); + + SelectStream(2); + PutSeed(3); + + for (n = 0; n < 2000; n++) { + for (i = 0; i < sizeof(struct gameState); i++) { + ((char*)&G)[i] = floor(Random() * 256); + } + p = floor(Random() * 2); + G.deckCount[p] = floor(Random() * MAX_DECK); + G.discardCount[p] = floor(Random() * MAX_DECK); + G.handCount[p] = floor(Random() * MAX_HAND); + checkDrawCard(p, &G); + } + + printf ("ALL TESTS OK\n"); + + exit(0); + +} From 59f0e63dd59381929303631c465203ca273b72f9 Mon Sep 17 00:00:00 2001 From: NickJohansen <50577890+NickJohansen@users.noreply.github.com> Date: Tue, 8 Oct 2019 21:59:28 -0700 Subject: [PATCH 4/6] Added bugs and changed functions --- dominion.c | 1350 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1350 insertions(+) create mode 100644 dominion.c diff --git a/dominion.c b/dominion.c new file mode 100644 index 000000000..615150322 --- /dev/null +++ b/dominion.c @@ -0,0 +1,1350 @@ +#include "dominion.h" +#include "dominion_helpers.h" +#include "rngs.h" +#include +#include +#include + +int compare(const void* a, const void* b) { + if (*(int*)a > *(int*)b) + return 1; + if (*(int*)a < *(int*)b) + return -1; + return 0; +} + +struct gameState* newGame() { + struct gameState* g = malloc(sizeof(struct gameState)); + return g; +} + +int* kingdomCards(int k1, int k2, int k3, int k4, int k5, int k6, int k7, + int k8, int k9, int k10) { + int* k = malloc(10 * sizeof(int)); + k[0] = k1; + k[1] = k2; + k[2] = k3; + k[3] = k4; + k[4] = k5; + k[5] = k6; + k[6] = k7; + k[7] = k8; + k[8] = k9; + k[9] = k10; + return k; +} + +int initializeGame(int numPlayers, int kingdomCards[10], int randomSeed, + struct gameState *state) { + int i; + int j; + int it; + + //set up random number generator + SelectStream(1); + PutSeed((long)randomSeed); + + //check number of players + if (numPlayers > MAX_PLAYERS || numPlayers < 2) + { + return -1; + } + + //set number of players + state->numPlayers = numPlayers; + + //check selected kingdom cards are different + for (i = 0; i < 10; i++) + { + for (j = 0; j < 10; j++) + { + if (j != i && kingdomCards[j] == kingdomCards[i]) + { + return -1; + } + } + } + + + //initialize supply + /////////////////////////////// + + //set number of Curse cards + if (numPlayers == 2) + { + state->supplyCount[curse] = 10; + } + else if (numPlayers == 3) + { + state->supplyCount[curse] = 20; + } + else + { + state->supplyCount[curse] = 30; + } + + //set number of Victory cards + if (numPlayers == 2) + { + state->supplyCount[estate] = 8; + state->supplyCount[duchy] = 8; + state->supplyCount[province] = 8; + } + else + { + state->supplyCount[estate] = 12; + state->supplyCount[duchy] = 12; + state->supplyCount[province] = 12; + } + + //set number of Treasure cards + state->supplyCount[copper] = 60 - (7 * numPlayers); + state->supplyCount[silver] = 40; + state->supplyCount[gold] = 30; + + //set number of Kingdom cards + for (i = adventurer; i <= treasure_map; i++) //loop all cards + { + for (j = 0; j < 10; j++) //loop chosen cards + { + if (kingdomCards[j] == i) + { + //check if card is a 'Victory' Kingdom card + if (kingdomCards[j] == great_hall || kingdomCards[j] == gardens) + { + if (numPlayers == 2) { + state->supplyCount[i] = 8; + } + else { + state->supplyCount[i] = 12; + } + } + else + { + state->supplyCount[i] = 10; + } + break; + } + else //card is not in the set choosen for the game + { + state->supplyCount[i] = -1; + } + } + + } + + //////////////////////// + //supply intilization complete + + //set player decks + for (i = 0; i < numPlayers; i++) + { + state->deckCount[i] = 0; + for (j = 0; j < 3; j++) + { + state->deck[i][j] = estate; + state->deckCount[i]++; + } + for (j = 3; j < 10; j++) + { + state->deck[i][j] = copper; + state->deckCount[i]++; + } + } + + //shuffle player decks + for (i = 0; i < numPlayers; i++) + { + if ( shuffle(i, state) < 0 ) + { + return -1; + } + } + + //draw player hands + for (i = 0; i < numPlayers; i++) + { + //initialize hand size to zero + state->handCount[i] = 0; + state->discardCount[i] = 0; + //draw 5 cards + // for (j = 0; j < 5; j++) + // { + // drawCard(i, state); + // } + } + + //set embargo tokens to 0 for all supply piles + for (i = 0; i <= treasure_map; i++) + { + state->embargoTokens[i] = 0; + } + + //initialize first player's turn + state->outpostPlayed = 0; + state->phase = 0; + state->numActions = 1; + state->numBuys = 1; + state->playedCardCount = 0; + state->whoseTurn = 0; + state->handCount[state->whoseTurn] = 0; + //int it; move to top + + //Moved draw cards to here, only drawing at the start of a turn + for (it = 0; it < 5; it++) { + drawCard(state->whoseTurn, state); + } + + updateCoins(state->whoseTurn, state, 0); + + return 0; +} + +int shuffle(int player, struct gameState *state) { + + + int newDeck[MAX_DECK]; + int newDeckPos = 0; + int card; + int i; + + if (state->deckCount[player] < 1) + return -1; + qsort ((void*)(state->deck[player]), state->deckCount[player], sizeof(int), compare); + /* SORT CARDS IN DECK TO ENSURE DETERMINISM! */ + + while (state->deckCount[player] > 0) { + card = floor(Random() * state->deckCount[player]); + newDeck[newDeckPos] = state->deck[player][card]; + newDeckPos++; + for (i = card; i < state->deckCount[player]-1; i++) { + state->deck[player][i] = state->deck[player][i+1]; + } + state->deckCount[player]--; + } + for (i = 0; i < newDeckPos; i++) { + state->deck[player][i] = newDeck[i]; + state->deckCount[player]++; + } + + return 0; +} + +int playCard(int handPos, int choice1, int choice2, int choice3, struct gameState *state) +{ + int card; + int coin_bonus = 0; //tracks coins gain from actions + + //check if it is the right phase + if (state->phase != 0) + { + return -1; + } + + //check if player has enough actions + if ( state->numActions < 1 ) + { + return -1; + } + + //get card played + card = handCard(handPos, state); + + //check if selected card is an action + if ( card < adventurer || card > treasure_map ) + { + return -1; + } + + //play card + if ( cardEffect(card, choice1, choice2, choice3, state, handPos, &coin_bonus) < 0 ) + { + return -1; + } + + //reduce number of actions + state->numActions--; + + //update coins (Treasure cards may be added with card draws) + updateCoins(state->whoseTurn, state, coin_bonus); + + return 0; +} + +int buyCard(int supplyPos, struct gameState *state) { + int who; + if (DEBUG) { + printf("Entering buyCard...\n"); + } + + // I don't know what to do about the phase thing. + + who = state->whoseTurn; + + if (state->numBuys < 1) { + if (DEBUG) + printf("You do not have any buys left\n"); + return -1; + } else if (supplyCount(supplyPos, state) <1) { + if (DEBUG) + printf("There are not any of that type of card left\n"); + return -1; + } else if (state->coins < getCost(supplyPos)) { + if (DEBUG) + printf("You do not have enough money to buy that. You have %d coins.\n", state->coins); + return -1; + } else { + state->phase=1; + //state->supplyCount[supplyPos]--; + gainCard(supplyPos, state, 0, who); //card goes in discard, this might be wrong.. (2 means goes into hand, 0 goes into discard) + + state->coins = (state->coins) - (getCost(supplyPos)); + state->numBuys--; + if (DEBUG) + printf("You bought card number %d for %d coins. You now have %d buys and %d coins.\n", supplyPos, getCost(supplyPos), state->numBuys, state->coins); + } + + //state->discard[who][state->discardCount[who]] = supplyPos; + //state->discardCount[who]++; + + return 0; +} + +int numHandCards(struct gameState *state) { + return state->handCount[ whoseTurn(state) ]; +} + +int handCard(int handPos, struct gameState *state) { + int currentPlayer = whoseTurn(state); + return state->hand[currentPlayer][handPos]; +} + +int supplyCount(int card, struct gameState *state) { + return state->supplyCount[card]; +} + +int fullDeckCount(int player, int card, struct gameState *state) { + int i; + int count = 0; + + for (i = 0; i < state->deckCount[player]; i++) + { + if (state->deck[player][i] == card) count++; + } + + for (i = 0; i < state->handCount[player]; i++) + { + if (state->hand[player][i] == card) count++; + } + + for (i = 0; i < state->discardCount[player]; i++) + { + if (state->discard[player][i] == card) count++; + } + + return count; +} + +int whoseTurn(struct gameState *state) { + return state->whoseTurn; +} + +int endTurn(struct gameState *state) { + int k; + int i; + int currentPlayer = whoseTurn(state); + + //Discard hand + for (i = 0; i < state->handCount[currentPlayer]; i++) { + state->discard[currentPlayer][state->discardCount[currentPlayer]++] = state->hand[currentPlayer][i];//Discard + state->hand[currentPlayer][i] = -1;//Set card to -1 + } + state->handCount[currentPlayer] = 0;//Reset hand count + + //Code for determining the player + if (currentPlayer < (state->numPlayers - 1)) { + state->whoseTurn = currentPlayer + 1;//Still safe to increment + } + else { + state->whoseTurn = 0;//Max player has been reached, loop back around to player 1 + } + + state->outpostPlayed = 0; + state->phase = 0; + state->numActions = 1; + state->coins = 0; + state->numBuys = 1; + state->playedCardCount = 0; + state->handCount[state->whoseTurn] = 0; + + //int k; move to top + //Next player draws hand + for (k = 0; k < 5; k++) { + drawCard(state->whoseTurn, state);//Draw a card + } + + //Update money + updateCoins(state->whoseTurn, state, 0); + + return 0; +} + +int isGameOver(struct gameState *state) { + int i; + int j; + + //if stack of Province cards is empty, the game ends + if (state->supplyCount[province] == 0) + { + return 1; + } + + //if three supply pile are at 0, the game ends + j = 0; + for (i = 0; i < 25; i++) + { + if (state->supplyCount[i] == 0) + { + j++; + } + } + if ( j >= 3) + { + return 1; + } + + return 0; +} + +int scoreFor (int player, struct gameState *state) { + + int i; + int score = 0; + //score from hand + for (i = 0; i < state->handCount[player]; i++) + { + if (state->hand[player][i] == curse) { + score = score - 1; + }; + if (state->hand[player][i] == estate) { + score = score + 1; + }; + if (state->hand[player][i] == duchy) { + score = score + 3; + }; + if (state->hand[player][i] == province) { + score = score + 6; + }; + if (state->hand[player][i] == great_hall) { + score = score + 1; + }; + if (state->hand[player][i] == gardens) { + score = score + ( fullDeckCount(player, 0, state) / 10 ); + }; + } + + //score from discard + for (i = 0; i < state->discardCount[player]; i++) + { + if (state->discard[player][i] == curse) { + score = score - 1; + }; + if (state->discard[player][i] == estate) { + score = score + 1; + }; + if (state->discard[player][i] == duchy) { + score = score + 3; + }; + if (state->discard[player][i] == province) { + score = score + 6; + }; + if (state->discard[player][i] == great_hall) { + score = score + 1; + }; + if (state->discard[player][i] == gardens) { + score = score + ( fullDeckCount(player, 0, state) / 10 ); + }; + } + + //score from deck + for (i = 0; i < state->discardCount[player]; i++) + { + if (state->deck[player][i] == curse) { + score = score - 1; + }; + if (state->deck[player][i] == estate) { + score = score + 1; + }; + if (state->deck[player][i] == duchy) { + score = score + 3; + }; + if (state->deck[player][i] == province) { + score = score + 6; + }; + if (state->deck[player][i] == great_hall) { + score = score + 1; + }; + if (state->deck[player][i] == gardens) { + score = score + ( fullDeckCount(player, 0, state) / 10 ); + }; + } + + return score; +} + +int getWinners(int players[MAX_PLAYERS], struct gameState *state) { + int i; + int j; + int highScore; + int currentPlayer; + + //get score for each player + for (i = 0; i < MAX_PLAYERS; i++) + { + //set unused player scores to -9999 + if (i >= state->numPlayers) + { + players[i] = -9999; + } + else + { + players[i] = scoreFor (i, state); + } + } + + //find highest score + j = 0; + for (i = 0; i < MAX_PLAYERS; i++) + { + if (players[i] > players[j]) + { + j = i; + } + } + highScore = players[j]; + + //add 1 to players who had less turns + currentPlayer = whoseTurn(state); + for (i = 0; i < MAX_PLAYERS; i++) + { + if ( players[i] == highScore && i > currentPlayer ) + { + players[i]++; + } + } + + //find new highest score + j = 0; + for (i = 0; i < MAX_PLAYERS; i++) + { + if ( players[i] > players[j] ) + { + j = i; + } + } + highScore = players[j]; + + //set winners in array to 1 and rest to 0 + for (i = 0; i < MAX_PLAYERS; i++) + { + if ( players[i] == highScore ) + { + players[i] = 1; + } + else + { + players[i] = 0; + } + } + + return 0; +} + +int drawCard(int player, struct gameState *state) +{ int count; + int deckCounter; + if (state->deckCount[player] <= 0) { //Deck is empty + + //Step 1 Shuffle the discard pile back into a deck + int i; + //Move discard to deck + for (i = 0; i < state->discardCount[player]; i++) { + state->deck[player][i] = state->discard[player][i]; + state->discard[player][i] = -1; + } + + state->deckCount[player] = state->discardCount[player]; + state->discardCount[player] = 0;//Reset discard + + //Shufffle the deck + shuffle(player, state);//Shuffle the deck up and make it so that we can draw + + if (DEBUG) { //Debug statements + printf("Deck count now: %d\n", state->deckCount[player]); + } + + state->discardCount[player] = 0; + + //Step 2 Draw Card + count = state->handCount[player];//Get current player's hand count + + if (DEBUG) { //Debug statements + printf("Current hand count: %d\n", count); + } + + deckCounter = state->deckCount[player];//Create a holder for the deck count + + if (deckCounter == 0) + return -1; + + state->hand[player][count] = state->deck[player][deckCounter - 1];//Add card to hand + state->deckCount[player]--; + state->handCount[player]++;//Increment hand count + } + + else { + int count = state->handCount[player];//Get current hand count for player + int deckCounter; + if (DEBUG) { //Debug statements + printf("Current hand count: %d\n", count); + } + + deckCounter = state->deckCount[player];//Create holder for the deck count + state->hand[player][count] = state->deck[player][deckCounter - 1];//Add card to the hand + state->deckCount[player]--; + state->handCount[player]++;//Increment hand count + } + + return 0; +} + +int getCost(int cardNumber) +{ + switch( cardNumber ) + { + case curse: + return 0; + case estate: + return 2; + case duchy: + return 5; + case province: + return 8; + case copper: + return 0; + case silver: + return 3; + case gold: + return 6; + case adventurer: + return 6; + case council_room: + return 5; + case feast: + return 4; + case gardens: + return 4; + case mine: + return 5; + case remodel: + return 4; + case smithy: + return 4; + case village: + return 3; + case baron: + return 4; + case great_hall: + return 3; + case minion: + return 5; + case steward: + return 3; + case tribute: + return 5; + case ambassador: + return 3; + case cutpurse: + return 4; + case embargo: + return 2; + case outpost: + return 5; + case salvager: + return 4; + case sea_hag: + return 4; + case treasure_map: + return 4; + } + + return -1; +} + +int do_mine(struct gameState* state, int currentPlayer, int nextPlayer, int choice1, int choice2, int handPos) { //state,currentPlayer,choice1,choice2, handPos + int j = state->hand[currentPlayer][choice1]; //store card we will trash + + if (state->hand[currentPlayer][choice1] < copper || state->hand[currentPlayer][choice1] > gold || choice2 > treasure_map || choice2 < curse || (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 + int i; + for (i = 1; i < state->handCount[currentPlayer]; i++){ + if (state->hand[currentPlayer][i] == j){ + discardCard(i, currentPlayer, state, 1); + break; + } + } + + return 0; +} + +int do_baron(struct gameState* state, int currentPlayer, int nextPlayer, int choice1, int choice2, int handPos) { //state,currentPlayer,choice1,choice2, handPos + state->numBuys++;//Increase buys by 1! + if (choice1 > 0) { //Boolean true or going to discard an estate + int p = 1;//Iterator for hand! + int card_not_discarded = 1;//Flag for discard set! + while (card_not_discarded) { + if (state->hand[currentPlayer][p] == estate) { //Found an estate card! + state->coins += 4;//Add 4 coins to the amount of coins + state->discard[currentPlayer][state->discardCount[currentPlayer]] = state->hand[currentPlayer][p]; + state->discardCount[currentPlayer]++; + + for (; p < state->handCount[currentPlayer]; p++) + state->hand[currentPlayer][p] = state->hand[currentPlayer][p + 1]; + + state->hand[currentPlayer][state->handCount[currentPlayer]] = -1; + state->handCount[currentPlayer]--; + card_not_discarded = 0;//Exit the loop + } + else if (p > state->handCount[currentPlayer]) { + //if (DEBUG) { + // printf("No estate cards in your hand, invalid choice\n"); + // printf("Must gain an estate if there are any\n"); + //} + if (supplyCount(estate, state) > 0) { + gainCard(baron, state, 0, currentPlayer); + + state->supplyCount[estate]--;//Decrement estates + if (supplyCount(estate, state) == 0) + isGameOver(state); + } + card_not_discarded = 0;//Exit the loop + } + + else + p++;//Next card + } + } + + else { + if (supplyCount(estate, state) > 0) { + gainCard(estate, state, 0, currentPlayer);//Gain an estate + + state->supplyCount[estate]--;//Decrement Estates + if (supplyCount(estate, state) == 0) { + isGameOver(state); + } + } + } + + + return 0; +} + +int do_ambassador(struct gameState* state, int currentPlayer, int nextPlayer, int choice1, int choice2, int handPos) {//state,currentPlayer,choice1,choice2, handPos + int j = 0; //used to check if player has enough cards to discard + int i; + + if (choice2 > 2 || choice2 < 0 || 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 = 1; 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 = 1; 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; +} + +int do_minion(struct gameState* state, int currentPlayer, int nextPlayer, int choice1, int choice2, int handPos) {//state,currentPlayer,choice1,choice2, handPos + //+1 action + state->numActions++; + + //discard card from hand + discardCard(handPos, currentPlayer, state, 0); + + if (choice1) + 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 + int i; + int j; + for (i = 1; i < 3; 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; +} + +int do_tribute(struct gameState* state, int currentPlayer, int nextPlayer, int choice1, int choice2, int handPos) {//state, currentPlayer, nextPlayer, choice1, choice2, handPos + int tributeRevealedCards[2] = { -1, -1 }; + int i; + int j; + if ((state->discardCount[currentPlayer] + state->deckCount[currentPlayer]) <= 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 (j = 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; + j++; + } + return 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 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: + while(drawntreasure<2) { + if (state->deckCount[currentPlayer] <1) { //if the deck is empty we need to shuffle discard and add to deck + shuffle(currentPlayer, state); + } + drawCard(currentPlayer, state); + cardDrawn = state->hand[currentPlayer][state->handCount[currentPlayer]-1];//top card of hand is most recently drawn card. + if (cardDrawn == copper || cardDrawn == silver || cardDrawn == gold) + drawntreasure++; + else { + temphand[z]=cardDrawn; + state->handCount[currentPlayer]--; //this should just remove the top card (the most recently drawn one). + z++; + } + } + while(z-1>=0) { + state->discard[currentPlayer][state->discardCount[currentPlayer]++]=temphand[z-1]; // discard all cards in play that have been drawn + z=z-1; + } + return 0; + + case council_room: + //+4 Cards + for (i = 0; i < 4; i++) + { + drawCard(currentPlayer, state); + } + + //+1 Buy + state->numBuys++; + + //Each other player draws a card + for (i = 0; i < state->numPlayers; i++) + { + if ( i != currentPlayer ) + { + drawCard(i, state); + } + } + + //put played card in played card pile + discardCard(handPos, currentPlayer, state, 0); + + 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; + ///state, currentPlayer, nextPlayer, choice1, choice2, handPos + case mine: + return do_mine(state, currentPlayer, nextPlayer, choice1, choice2, handPos); + + 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: + //+3 Cards + for (i = 0; i < 3; i++) + { + drawCard(currentPlayer, state); + } + + //discard card from hand + discardCard(handPos, currentPlayer, state, 0); + return 0; + + case village: + //+1 Card + drawCard(currentPlayer, state); + + //+2 Actions + state->numActions = state->numActions + 2; + + //discard played card from hand + discardCard(handPos, currentPlayer, state, 0); + return 0; + + case baron: + return do_baron(state, currentPlayer, nextPlayer, choice1, choice2, handPos); + + 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: + return do_minion(state, currentPlayer, nextPlayer, choice1, choice2, handPos); + + 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: + return do_tribute(state, currentPlayer, nextPlayer, choice1, choice2, handPos); + + case ambassador: + return do_ambassador(state, currentPlayer, nextPlayer, choice1, choice2, handPos); + + 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; +} + +int discardCard(int handPos, int currentPlayer, struct gameState *state, int trashFlag) +{ + + //if card is not trashed, added to Played pile + if (trashFlag < 1) + { + //add card to played pile + state->playedCards[state->playedCardCount] = state->hand[currentPlayer][handPos]; + state->playedCardCount++; + } + + //set played card to -1 + state->hand[currentPlayer][handPos] = -1; + + //remove card from player's hand + if ( handPos == (state->handCount[currentPlayer] - 1) ) //last card in hand array is played + { + //reduce number of cards in hand + state->handCount[currentPlayer]--; + } + else if ( state->handCount[currentPlayer] == 1 ) //only one card in hand + { + //reduce number of cards in hand + state->handCount[currentPlayer]--; + } + else + { + //replace discarded card with last card in hand + state->hand[currentPlayer][handPos] = state->hand[currentPlayer][ (state->handCount[currentPlayer] - 1)]; + //set last card to -1 + state->hand[currentPlayer][state->handCount[currentPlayer] - 1] = -1; + //reduce number of cards in hand + state->handCount[currentPlayer]--; + } + + return 0; +} + +int gainCard(int supplyPos, struct gameState *state, int toFlag, int player) +{ + //Note: supplyPos is enum of choosen card + + //check if supply pile is empty (0) or card is not used in game (-1) + if ( supplyCount(supplyPos, state) < 1 ) + { + return -1; + } + + //added card for [whoseTurn] current player: + // toFlag = 0 : add to discard + // toFlag = 1 : add to deck + // toFlag = 2 : add to hand + + if (toFlag == 1) + { + state->deck[ player ][ state->deckCount[player] ] = supplyPos; + state->deckCount[player]++; + } + else if (toFlag == 2) + { + state->hand[ player ][ state->handCount[player] ] = supplyPos; + state->handCount[player]++; + } + else + { + state->discard[player][ state->discardCount[player] ] = supplyPos; + state->discardCount[player]++; + } + + //decrease number in supply pile + state->supplyCount[supplyPos]--; + + return 0; +} + +int updateCoins(int player, struct gameState *state, int bonus) +{ + int i; + + //reset coin count + state->coins = 0; + + //add coins for each Treasure card in player's hand + for (i = 0; i < state->handCount[player]; i++) + { + if (state->hand[player][i] == copper) + { + state->coins += 1; + } + else if (state->hand[player][i] == silver) + { + state->coins += 2; + } + else if (state->hand[player][i] == gold) + { + state->coins += 3; + } + } + + //add bonus + state->coins += bonus; + + return 0; +} + + + +//end of dominion.c + From 356cb72c506dc353b1b099689b1cc706fa194ca3 Mon Sep 17 00:00:00 2001 From: NickJohansen <50577890+NickJohansen@users.noreply.github.com> Date: Tue, 8 Oct 2019 22:01:01 -0700 Subject: [PATCH 5/6] fixing --- dominion.c | 1350 ---------------------------------------------------- 1 file changed, 1350 deletions(-) delete mode 100644 dominion.c diff --git a/dominion.c b/dominion.c deleted file mode 100644 index 615150322..000000000 --- a/dominion.c +++ /dev/null @@ -1,1350 +0,0 @@ -#include "dominion.h" -#include "dominion_helpers.h" -#include "rngs.h" -#include -#include -#include - -int compare(const void* a, const void* b) { - if (*(int*)a > *(int*)b) - return 1; - if (*(int*)a < *(int*)b) - return -1; - return 0; -} - -struct gameState* newGame() { - struct gameState* g = malloc(sizeof(struct gameState)); - return g; -} - -int* kingdomCards(int k1, int k2, int k3, int k4, int k5, int k6, int k7, - int k8, int k9, int k10) { - int* k = malloc(10 * sizeof(int)); - k[0] = k1; - k[1] = k2; - k[2] = k3; - k[3] = k4; - k[4] = k5; - k[5] = k6; - k[6] = k7; - k[7] = k8; - k[8] = k9; - k[9] = k10; - return k; -} - -int initializeGame(int numPlayers, int kingdomCards[10], int randomSeed, - struct gameState *state) { - int i; - int j; - int it; - - //set up random number generator - SelectStream(1); - PutSeed((long)randomSeed); - - //check number of players - if (numPlayers > MAX_PLAYERS || numPlayers < 2) - { - return -1; - } - - //set number of players - state->numPlayers = numPlayers; - - //check selected kingdom cards are different - for (i = 0; i < 10; i++) - { - for (j = 0; j < 10; j++) - { - if (j != i && kingdomCards[j] == kingdomCards[i]) - { - return -1; - } - } - } - - - //initialize supply - /////////////////////////////// - - //set number of Curse cards - if (numPlayers == 2) - { - state->supplyCount[curse] = 10; - } - else if (numPlayers == 3) - { - state->supplyCount[curse] = 20; - } - else - { - state->supplyCount[curse] = 30; - } - - //set number of Victory cards - if (numPlayers == 2) - { - state->supplyCount[estate] = 8; - state->supplyCount[duchy] = 8; - state->supplyCount[province] = 8; - } - else - { - state->supplyCount[estate] = 12; - state->supplyCount[duchy] = 12; - state->supplyCount[province] = 12; - } - - //set number of Treasure cards - state->supplyCount[copper] = 60 - (7 * numPlayers); - state->supplyCount[silver] = 40; - state->supplyCount[gold] = 30; - - //set number of Kingdom cards - for (i = adventurer; i <= treasure_map; i++) //loop all cards - { - for (j = 0; j < 10; j++) //loop chosen cards - { - if (kingdomCards[j] == i) - { - //check if card is a 'Victory' Kingdom card - if (kingdomCards[j] == great_hall || kingdomCards[j] == gardens) - { - if (numPlayers == 2) { - state->supplyCount[i] = 8; - } - else { - state->supplyCount[i] = 12; - } - } - else - { - state->supplyCount[i] = 10; - } - break; - } - else //card is not in the set choosen for the game - { - state->supplyCount[i] = -1; - } - } - - } - - //////////////////////// - //supply intilization complete - - //set player decks - for (i = 0; i < numPlayers; i++) - { - state->deckCount[i] = 0; - for (j = 0; j < 3; j++) - { - state->deck[i][j] = estate; - state->deckCount[i]++; - } - for (j = 3; j < 10; j++) - { - state->deck[i][j] = copper; - state->deckCount[i]++; - } - } - - //shuffle player decks - for (i = 0; i < numPlayers; i++) - { - if ( shuffle(i, state) < 0 ) - { - return -1; - } - } - - //draw player hands - for (i = 0; i < numPlayers; i++) - { - //initialize hand size to zero - state->handCount[i] = 0; - state->discardCount[i] = 0; - //draw 5 cards - // for (j = 0; j < 5; j++) - // { - // drawCard(i, state); - // } - } - - //set embargo tokens to 0 for all supply piles - for (i = 0; i <= treasure_map; i++) - { - state->embargoTokens[i] = 0; - } - - //initialize first player's turn - state->outpostPlayed = 0; - state->phase = 0; - state->numActions = 1; - state->numBuys = 1; - state->playedCardCount = 0; - state->whoseTurn = 0; - state->handCount[state->whoseTurn] = 0; - //int it; move to top - - //Moved draw cards to here, only drawing at the start of a turn - for (it = 0; it < 5; it++) { - drawCard(state->whoseTurn, state); - } - - updateCoins(state->whoseTurn, state, 0); - - return 0; -} - -int shuffle(int player, struct gameState *state) { - - - int newDeck[MAX_DECK]; - int newDeckPos = 0; - int card; - int i; - - if (state->deckCount[player] < 1) - return -1; - qsort ((void*)(state->deck[player]), state->deckCount[player], sizeof(int), compare); - /* SORT CARDS IN DECK TO ENSURE DETERMINISM! */ - - while (state->deckCount[player] > 0) { - card = floor(Random() * state->deckCount[player]); - newDeck[newDeckPos] = state->deck[player][card]; - newDeckPos++; - for (i = card; i < state->deckCount[player]-1; i++) { - state->deck[player][i] = state->deck[player][i+1]; - } - state->deckCount[player]--; - } - for (i = 0; i < newDeckPos; i++) { - state->deck[player][i] = newDeck[i]; - state->deckCount[player]++; - } - - return 0; -} - -int playCard(int handPos, int choice1, int choice2, int choice3, struct gameState *state) -{ - int card; - int coin_bonus = 0; //tracks coins gain from actions - - //check if it is the right phase - if (state->phase != 0) - { - return -1; - } - - //check if player has enough actions - if ( state->numActions < 1 ) - { - return -1; - } - - //get card played - card = handCard(handPos, state); - - //check if selected card is an action - if ( card < adventurer || card > treasure_map ) - { - return -1; - } - - //play card - if ( cardEffect(card, choice1, choice2, choice3, state, handPos, &coin_bonus) < 0 ) - { - return -1; - } - - //reduce number of actions - state->numActions--; - - //update coins (Treasure cards may be added with card draws) - updateCoins(state->whoseTurn, state, coin_bonus); - - return 0; -} - -int buyCard(int supplyPos, struct gameState *state) { - int who; - if (DEBUG) { - printf("Entering buyCard...\n"); - } - - // I don't know what to do about the phase thing. - - who = state->whoseTurn; - - if (state->numBuys < 1) { - if (DEBUG) - printf("You do not have any buys left\n"); - return -1; - } else if (supplyCount(supplyPos, state) <1) { - if (DEBUG) - printf("There are not any of that type of card left\n"); - return -1; - } else if (state->coins < getCost(supplyPos)) { - if (DEBUG) - printf("You do not have enough money to buy that. You have %d coins.\n", state->coins); - return -1; - } else { - state->phase=1; - //state->supplyCount[supplyPos]--; - gainCard(supplyPos, state, 0, who); //card goes in discard, this might be wrong.. (2 means goes into hand, 0 goes into discard) - - state->coins = (state->coins) - (getCost(supplyPos)); - state->numBuys--; - if (DEBUG) - printf("You bought card number %d for %d coins. You now have %d buys and %d coins.\n", supplyPos, getCost(supplyPos), state->numBuys, state->coins); - } - - //state->discard[who][state->discardCount[who]] = supplyPos; - //state->discardCount[who]++; - - return 0; -} - -int numHandCards(struct gameState *state) { - return state->handCount[ whoseTurn(state) ]; -} - -int handCard(int handPos, struct gameState *state) { - int currentPlayer = whoseTurn(state); - return state->hand[currentPlayer][handPos]; -} - -int supplyCount(int card, struct gameState *state) { - return state->supplyCount[card]; -} - -int fullDeckCount(int player, int card, struct gameState *state) { - int i; - int count = 0; - - for (i = 0; i < state->deckCount[player]; i++) - { - if (state->deck[player][i] == card) count++; - } - - for (i = 0; i < state->handCount[player]; i++) - { - if (state->hand[player][i] == card) count++; - } - - for (i = 0; i < state->discardCount[player]; i++) - { - if (state->discard[player][i] == card) count++; - } - - return count; -} - -int whoseTurn(struct gameState *state) { - return state->whoseTurn; -} - -int endTurn(struct gameState *state) { - int k; - int i; - int currentPlayer = whoseTurn(state); - - //Discard hand - for (i = 0; i < state->handCount[currentPlayer]; i++) { - state->discard[currentPlayer][state->discardCount[currentPlayer]++] = state->hand[currentPlayer][i];//Discard - state->hand[currentPlayer][i] = -1;//Set card to -1 - } - state->handCount[currentPlayer] = 0;//Reset hand count - - //Code for determining the player - if (currentPlayer < (state->numPlayers - 1)) { - state->whoseTurn = currentPlayer + 1;//Still safe to increment - } - else { - state->whoseTurn = 0;//Max player has been reached, loop back around to player 1 - } - - state->outpostPlayed = 0; - state->phase = 0; - state->numActions = 1; - state->coins = 0; - state->numBuys = 1; - state->playedCardCount = 0; - state->handCount[state->whoseTurn] = 0; - - //int k; move to top - //Next player draws hand - for (k = 0; k < 5; k++) { - drawCard(state->whoseTurn, state);//Draw a card - } - - //Update money - updateCoins(state->whoseTurn, state, 0); - - return 0; -} - -int isGameOver(struct gameState *state) { - int i; - int j; - - //if stack of Province cards is empty, the game ends - if (state->supplyCount[province] == 0) - { - return 1; - } - - //if three supply pile are at 0, the game ends - j = 0; - for (i = 0; i < 25; i++) - { - if (state->supplyCount[i] == 0) - { - j++; - } - } - if ( j >= 3) - { - return 1; - } - - return 0; -} - -int scoreFor (int player, struct gameState *state) { - - int i; - int score = 0; - //score from hand - for (i = 0; i < state->handCount[player]; i++) - { - if (state->hand[player][i] == curse) { - score = score - 1; - }; - if (state->hand[player][i] == estate) { - score = score + 1; - }; - if (state->hand[player][i] == duchy) { - score = score + 3; - }; - if (state->hand[player][i] == province) { - score = score + 6; - }; - if (state->hand[player][i] == great_hall) { - score = score + 1; - }; - if (state->hand[player][i] == gardens) { - score = score + ( fullDeckCount(player, 0, state) / 10 ); - }; - } - - //score from discard - for (i = 0; i < state->discardCount[player]; i++) - { - if (state->discard[player][i] == curse) { - score = score - 1; - }; - if (state->discard[player][i] == estate) { - score = score + 1; - }; - if (state->discard[player][i] == duchy) { - score = score + 3; - }; - if (state->discard[player][i] == province) { - score = score + 6; - }; - if (state->discard[player][i] == great_hall) { - score = score + 1; - }; - if (state->discard[player][i] == gardens) { - score = score + ( fullDeckCount(player, 0, state) / 10 ); - }; - } - - //score from deck - for (i = 0; i < state->discardCount[player]; i++) - { - if (state->deck[player][i] == curse) { - score = score - 1; - }; - if (state->deck[player][i] == estate) { - score = score + 1; - }; - if (state->deck[player][i] == duchy) { - score = score + 3; - }; - if (state->deck[player][i] == province) { - score = score + 6; - }; - if (state->deck[player][i] == great_hall) { - score = score + 1; - }; - if (state->deck[player][i] == gardens) { - score = score + ( fullDeckCount(player, 0, state) / 10 ); - }; - } - - return score; -} - -int getWinners(int players[MAX_PLAYERS], struct gameState *state) { - int i; - int j; - int highScore; - int currentPlayer; - - //get score for each player - for (i = 0; i < MAX_PLAYERS; i++) - { - //set unused player scores to -9999 - if (i >= state->numPlayers) - { - players[i] = -9999; - } - else - { - players[i] = scoreFor (i, state); - } - } - - //find highest score - j = 0; - for (i = 0; i < MAX_PLAYERS; i++) - { - if (players[i] > players[j]) - { - j = i; - } - } - highScore = players[j]; - - //add 1 to players who had less turns - currentPlayer = whoseTurn(state); - for (i = 0; i < MAX_PLAYERS; i++) - { - if ( players[i] == highScore && i > currentPlayer ) - { - players[i]++; - } - } - - //find new highest score - j = 0; - for (i = 0; i < MAX_PLAYERS; i++) - { - if ( players[i] > players[j] ) - { - j = i; - } - } - highScore = players[j]; - - //set winners in array to 1 and rest to 0 - for (i = 0; i < MAX_PLAYERS; i++) - { - if ( players[i] == highScore ) - { - players[i] = 1; - } - else - { - players[i] = 0; - } - } - - return 0; -} - -int drawCard(int player, struct gameState *state) -{ int count; - int deckCounter; - if (state->deckCount[player] <= 0) { //Deck is empty - - //Step 1 Shuffle the discard pile back into a deck - int i; - //Move discard to deck - for (i = 0; i < state->discardCount[player]; i++) { - state->deck[player][i] = state->discard[player][i]; - state->discard[player][i] = -1; - } - - state->deckCount[player] = state->discardCount[player]; - state->discardCount[player] = 0;//Reset discard - - //Shufffle the deck - shuffle(player, state);//Shuffle the deck up and make it so that we can draw - - if (DEBUG) { //Debug statements - printf("Deck count now: %d\n", state->deckCount[player]); - } - - state->discardCount[player] = 0; - - //Step 2 Draw Card - count = state->handCount[player];//Get current player's hand count - - if (DEBUG) { //Debug statements - printf("Current hand count: %d\n", count); - } - - deckCounter = state->deckCount[player];//Create a holder for the deck count - - if (deckCounter == 0) - return -1; - - state->hand[player][count] = state->deck[player][deckCounter - 1];//Add card to hand - state->deckCount[player]--; - state->handCount[player]++;//Increment hand count - } - - else { - int count = state->handCount[player];//Get current hand count for player - int deckCounter; - if (DEBUG) { //Debug statements - printf("Current hand count: %d\n", count); - } - - deckCounter = state->deckCount[player];//Create holder for the deck count - state->hand[player][count] = state->deck[player][deckCounter - 1];//Add card to the hand - state->deckCount[player]--; - state->handCount[player]++;//Increment hand count - } - - return 0; -} - -int getCost(int cardNumber) -{ - switch( cardNumber ) - { - case curse: - return 0; - case estate: - return 2; - case duchy: - return 5; - case province: - return 8; - case copper: - return 0; - case silver: - return 3; - case gold: - return 6; - case adventurer: - return 6; - case council_room: - return 5; - case feast: - return 4; - case gardens: - return 4; - case mine: - return 5; - case remodel: - return 4; - case smithy: - return 4; - case village: - return 3; - case baron: - return 4; - case great_hall: - return 3; - case minion: - return 5; - case steward: - return 3; - case tribute: - return 5; - case ambassador: - return 3; - case cutpurse: - return 4; - case embargo: - return 2; - case outpost: - return 5; - case salvager: - return 4; - case sea_hag: - return 4; - case treasure_map: - return 4; - } - - return -1; -} - -int do_mine(struct gameState* state, int currentPlayer, int nextPlayer, int choice1, int choice2, int handPos) { //state,currentPlayer,choice1,choice2, handPos - int j = state->hand[currentPlayer][choice1]; //store card we will trash - - if (state->hand[currentPlayer][choice1] < copper || state->hand[currentPlayer][choice1] > gold || choice2 > treasure_map || choice2 < curse || (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 - int i; - for (i = 1; i < state->handCount[currentPlayer]; i++){ - if (state->hand[currentPlayer][i] == j){ - discardCard(i, currentPlayer, state, 1); - break; - } - } - - return 0; -} - -int do_baron(struct gameState* state, int currentPlayer, int nextPlayer, int choice1, int choice2, int handPos) { //state,currentPlayer,choice1,choice2, handPos - state->numBuys++;//Increase buys by 1! - if (choice1 > 0) { //Boolean true or going to discard an estate - int p = 1;//Iterator for hand! - int card_not_discarded = 1;//Flag for discard set! - while (card_not_discarded) { - if (state->hand[currentPlayer][p] == estate) { //Found an estate card! - state->coins += 4;//Add 4 coins to the amount of coins - state->discard[currentPlayer][state->discardCount[currentPlayer]] = state->hand[currentPlayer][p]; - state->discardCount[currentPlayer]++; - - for (; p < state->handCount[currentPlayer]; p++) - state->hand[currentPlayer][p] = state->hand[currentPlayer][p + 1]; - - state->hand[currentPlayer][state->handCount[currentPlayer]] = -1; - state->handCount[currentPlayer]--; - card_not_discarded = 0;//Exit the loop - } - else if (p > state->handCount[currentPlayer]) { - //if (DEBUG) { - // printf("No estate cards in your hand, invalid choice\n"); - // printf("Must gain an estate if there are any\n"); - //} - if (supplyCount(estate, state) > 0) { - gainCard(baron, state, 0, currentPlayer); - - state->supplyCount[estate]--;//Decrement estates - if (supplyCount(estate, state) == 0) - isGameOver(state); - } - card_not_discarded = 0;//Exit the loop - } - - else - p++;//Next card - } - } - - else { - if (supplyCount(estate, state) > 0) { - gainCard(estate, state, 0, currentPlayer);//Gain an estate - - state->supplyCount[estate]--;//Decrement Estates - if (supplyCount(estate, state) == 0) { - isGameOver(state); - } - } - } - - - return 0; -} - -int do_ambassador(struct gameState* state, int currentPlayer, int nextPlayer, int choice1, int choice2, int handPos) {//state,currentPlayer,choice1,choice2, handPos - int j = 0; //used to check if player has enough cards to discard - int i; - - if (choice2 > 2 || choice2 < 0 || 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 = 1; 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 = 1; 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; -} - -int do_minion(struct gameState* state, int currentPlayer, int nextPlayer, int choice1, int choice2, int handPos) {//state,currentPlayer,choice1,choice2, handPos - //+1 action - state->numActions++; - - //discard card from hand - discardCard(handPos, currentPlayer, state, 0); - - if (choice1) - 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 - int i; - int j; - for (i = 1; i < 3; 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; -} - -int do_tribute(struct gameState* state, int currentPlayer, int nextPlayer, int choice1, int choice2, int handPos) {//state, currentPlayer, nextPlayer, choice1, choice2, handPos - int tributeRevealedCards[2] = { -1, -1 }; - int i; - int j; - if ((state->discardCount[currentPlayer] + state->deckCount[currentPlayer]) <= 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 (j = 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; - j++; - } - return 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 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: - while(drawntreasure<2) { - if (state->deckCount[currentPlayer] <1) { //if the deck is empty we need to shuffle discard and add to deck - shuffle(currentPlayer, state); - } - drawCard(currentPlayer, state); - cardDrawn = state->hand[currentPlayer][state->handCount[currentPlayer]-1];//top card of hand is most recently drawn card. - if (cardDrawn == copper || cardDrawn == silver || cardDrawn == gold) - drawntreasure++; - else { - temphand[z]=cardDrawn; - state->handCount[currentPlayer]--; //this should just remove the top card (the most recently drawn one). - z++; - } - } - while(z-1>=0) { - state->discard[currentPlayer][state->discardCount[currentPlayer]++]=temphand[z-1]; // discard all cards in play that have been drawn - z=z-1; - } - return 0; - - case council_room: - //+4 Cards - for (i = 0; i < 4; i++) - { - drawCard(currentPlayer, state); - } - - //+1 Buy - state->numBuys++; - - //Each other player draws a card - for (i = 0; i < state->numPlayers; i++) - { - if ( i != currentPlayer ) - { - drawCard(i, state); - } - } - - //put played card in played card pile - discardCard(handPos, currentPlayer, state, 0); - - 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; - ///state, currentPlayer, nextPlayer, choice1, choice2, handPos - case mine: - return do_mine(state, currentPlayer, nextPlayer, choice1, choice2, handPos); - - 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: - //+3 Cards - for (i = 0; i < 3; i++) - { - drawCard(currentPlayer, state); - } - - //discard card from hand - discardCard(handPos, currentPlayer, state, 0); - return 0; - - case village: - //+1 Card - drawCard(currentPlayer, state); - - //+2 Actions - state->numActions = state->numActions + 2; - - //discard played card from hand - discardCard(handPos, currentPlayer, state, 0); - return 0; - - case baron: - return do_baron(state, currentPlayer, nextPlayer, choice1, choice2, handPos); - - 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: - return do_minion(state, currentPlayer, nextPlayer, choice1, choice2, handPos); - - 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: - return do_tribute(state, currentPlayer, nextPlayer, choice1, choice2, handPos); - - case ambassador: - return do_ambassador(state, currentPlayer, nextPlayer, choice1, choice2, handPos); - - 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; -} - -int discardCard(int handPos, int currentPlayer, struct gameState *state, int trashFlag) -{ - - //if card is not trashed, added to Played pile - if (trashFlag < 1) - { - //add card to played pile - state->playedCards[state->playedCardCount] = state->hand[currentPlayer][handPos]; - state->playedCardCount++; - } - - //set played card to -1 - state->hand[currentPlayer][handPos] = -1; - - //remove card from player's hand - if ( handPos == (state->handCount[currentPlayer] - 1) ) //last card in hand array is played - { - //reduce number of cards in hand - state->handCount[currentPlayer]--; - } - else if ( state->handCount[currentPlayer] == 1 ) //only one card in hand - { - //reduce number of cards in hand - state->handCount[currentPlayer]--; - } - else - { - //replace discarded card with last card in hand - state->hand[currentPlayer][handPos] = state->hand[currentPlayer][ (state->handCount[currentPlayer] - 1)]; - //set last card to -1 - state->hand[currentPlayer][state->handCount[currentPlayer] - 1] = -1; - //reduce number of cards in hand - state->handCount[currentPlayer]--; - } - - return 0; -} - -int gainCard(int supplyPos, struct gameState *state, int toFlag, int player) -{ - //Note: supplyPos is enum of choosen card - - //check if supply pile is empty (0) or card is not used in game (-1) - if ( supplyCount(supplyPos, state) < 1 ) - { - return -1; - } - - //added card for [whoseTurn] current player: - // toFlag = 0 : add to discard - // toFlag = 1 : add to deck - // toFlag = 2 : add to hand - - if (toFlag == 1) - { - state->deck[ player ][ state->deckCount[player] ] = supplyPos; - state->deckCount[player]++; - } - else if (toFlag == 2) - { - state->hand[ player ][ state->handCount[player] ] = supplyPos; - state->handCount[player]++; - } - else - { - state->discard[player][ state->discardCount[player] ] = supplyPos; - state->discardCount[player]++; - } - - //decrease number in supply pile - state->supplyCount[supplyPos]--; - - return 0; -} - -int updateCoins(int player, struct gameState *state, int bonus) -{ - int i; - - //reset coin count - state->coins = 0; - - //add coins for each Treasure card in player's hand - for (i = 0; i < state->handCount[player]; i++) - { - if (state->hand[player][i] == copper) - { - state->coins += 1; - } - else if (state->hand[player][i] == silver) - { - state->coins += 2; - } - else if (state->hand[player][i] == gold) - { - state->coins += 3; - } - } - - //add bonus - state->coins += bonus; - - return 0; -} - - - -//end of dominion.c - From 53b30b34f1c3a944ee41864ca71ffb8d3f5bc498 Mon Sep 17 00:00:00 2001 From: NickJohansen <50577890+NickJohansen@users.noreply.github.com> Date: Tue, 8 Oct 2019 22:02:49 -0700 Subject: [PATCH 6/6] Added changes --- dominion/dominion.gcno | Bin 0 -> 39940 bytes dominion/dominion.o | Bin 0 -> 62656 bytes dominion/interface.gcno | Bin 0 -> 14676 bytes dominion/interface.o | Bin 0 -> 35600 bytes dominion/playdom | Bin 0 -> 70744 bytes dominion/playdom.gcno | Bin 0 -> 6876 bytes dominion/player | Bin 0 -> 88320 bytes dominion/player.gcno | Bin 0 -> 7544 bytes dominion/rngs.gcno | Bin 0 -> 4032 bytes dominion/rngs.o | Bin 0 -> 15184 bytes projects/johansen/dominion/dominion.c | 471 ++++++++++------------ projects/johansen/dominion/dominion.gcda | Bin 0 -> 4332 bytes projects/johansen/dominion/dominion.gcno | Bin 0 -> 40924 bytes projects/johansen/dominion/dominion.o | Bin 0 -> 66760 bytes projects/johansen/dominion/interface.gcno | Bin 0 -> 14676 bytes projects/johansen/dominion/interface.o | Bin 0 -> 35624 bytes projects/johansen/dominion/playdom | Bin 0 -> 72432 bytes projects/johansen/dominion/playdom.gcda | Bin 0 -> 1444 bytes projects/johansen/dominion/playdom.gcno | Bin 0 -> 6876 bytes projects/johansen/dominion/player | Bin 0 -> 94272 bytes projects/johansen/dominion/player.gcno | Bin 0 -> 7544 bytes projects/johansen/dominion/rngs.gcda | Bin 0 -> 4840 bytes projects/johansen/dominion/rngs.gcno | Bin 0 -> 4032 bytes projects/johansen/dominion/rngs.o | Bin 0 -> 15232 bytes 24 files changed, 224 insertions(+), 247 deletions(-) create mode 100644 dominion/dominion.gcno create mode 100644 dominion/dominion.o create mode 100644 dominion/interface.gcno create mode 100644 dominion/interface.o create mode 100644 dominion/playdom create mode 100644 dominion/playdom.gcno create mode 100644 dominion/player create mode 100644 dominion/player.gcno create mode 100644 dominion/rngs.gcno create mode 100644 dominion/rngs.o create mode 100644 projects/johansen/dominion/dominion.gcda create mode 100644 projects/johansen/dominion/dominion.gcno create mode 100644 projects/johansen/dominion/dominion.o create mode 100644 projects/johansen/dominion/interface.gcno create mode 100644 projects/johansen/dominion/interface.o create mode 100644 projects/johansen/dominion/playdom create mode 100644 projects/johansen/dominion/playdom.gcda create mode 100644 projects/johansen/dominion/playdom.gcno create mode 100644 projects/johansen/dominion/player create mode 100644 projects/johansen/dominion/player.gcno create mode 100644 projects/johansen/dominion/rngs.gcda create mode 100644 projects/johansen/dominion/rngs.gcno create mode 100644 projects/johansen/dominion/rngs.o diff --git a/dominion/dominion.gcno b/dominion/dominion.gcno new file mode 100644 index 0000000000000000000000000000000000000000..e106a7e4a2f07a01c6d262a4cb00a21399a537b1 GIT binary patch literal 39940 zcmeI537nqO)xc*`2~jG73JF<-NRSX)2$?MQwTOKg$s`$)8ObDKD{7}|tG%e!z7(|- zvBy&T7O|JwipobVr6|7hf9`X<_dV}9!`J2O_xpa%uVG01v49Yu=ABR()FTsC6B$csQTcEb}FCq z%QH#xj~$+J_<)63K$Lg#a{t(Ko>)lR7)fiJzAx|i(iln8$66;GY3fOJjj4yB?Fjj{ zzekG0G0ADcNUEMVv`$-QLx)ZE*ZSYsVbx^)ZmJnY6e$M!6tV2)4y)r~*)1KGzDF#( zwZqaEh-Gb`F;4U~V%f3ccZVw9X>BYa>Ffly4~3 z6#4%%sa_X4UvSCXpl;roGra5ky)AsP#Xe zW)yt;`*VfKWEA79v=N8*Z+RIZO@33rFXny9X zU40EKnN9-1>6ym4OuA?J99%w!l+V%fM79=%+n$8TPNJmSNQms49(5*{ zN1n(VqU66#LgbzFsC!?Y*gq+sdbcFbMMTq&z*M9G1Z1{q~j`R^# zALNnlE9%vWo%NUV{Up6yX_IiO<|%e~?EOXaa-^3Rwe^t3zJe(H0MR6A&0xo;R}OYX zCy&0tZeu4+{Kz0td}_auURgA^tz>NE!C*&L5zTqhc8u7UavS^*(bYuhr&UGsej-gC z+)z;%jS;)`1+#`I-0GsaFVf`UYfaH4Y0t)PeZj0HiVytJkJL?h>}!kiZu77YEA!To zXOdJ8c3Th3x}sh^*oTYSdWZ%4$TCmkT2IpJm$n9Z5}W2>A0g`b!ahn=`wRb+$G_Sr zN18eicx?EGCvDp{T5MxPy|!WBKolRg53z4p=4~X;B&ieA4O4}Cl%=-}g=4D&e!@j$y^7P$q#zr0tc4QCHoF{GTq@F!RX>YTr z)=4?+<3zo_z&^grn@8&;34rVMhJsQQ8@ z{WH;=KU~sBl(ysLNgcW-upcRkk30`w*pDvrls_u7<*`y8mVD$GQEb|7(mxf=<2qK- z$BDw_zNj0!jo*bDp%FYbT2BBvE2KMKtdx>?fCbd93)vetM9H zpP!4uohq6n?Zeo$oc1rwX`;kn>%p$P&BK0%DD~ud^d)xN)-%O+mMHwWqDj&@js0v< z@_r$TKOINx7l`KL2y>1oJb5{f-SX6To+$jUMROke`J&`$oxhZ~^F`IhlQeeZSE6}5 zr11-fZ~8!eVYl&+zEBkYBGEh^?AX*lzDQpu3a{gKvAkU-O4&<9m4_j%d6$|z(&WKi zE}GYk{aVr77tGZqcZJC#t$A0PJkpx?8E{q_JNkN_^P0pUJ~c z?7ZiBF!;&ag^e_QnzxlS{fb;KiZ2~U(soYYAhsJtsqc59xi8Y>;o~MzZ3lH@x4vL* z7KNWBn)BFm9v?7wifW8JZxOv!lsN7XRUhPGzfIK3!+yIcTwacPuw&DPPMp&GSglE^T+qQ{%!HcH1_X-;3rx?veDpqQr5ZsQQ4xj*WNh_|YsGp|K!aPeM;2p1MIJsdH8^tEBbV4dqtkwUd93YA4T(co{{vk zqLh7JRC&_apA+@!#*TmTv~J43Ad2l}QT0XL*#97^Jhm5&jXW6a$V;L*PntS4etb~R zA2S;~Y1)P4F~XCk&(sGzY5EO$O*GFV{kkX|?ZJnR7xwwZnDcLl?N6fcZ;B>KXFhhz z!@MQx`NwYgx5f77fX8n6cf>YNlo;O=r42e>*#AqEyu5A1g8khf4?DiRa@hYO>a_=Z z9v^-AzUW^|UgP>e(jS(#kL0N_!(+#$eU6Q^^+6gx$j73@qvJ-}#_@^R{w}H<&%cR& zDoS0Si)tL?VgF2&_dJhyuzykJX`L|m*SIN1nmUl2Cy(@(qVOH1;=FF`UzK^-sZ;w7 zJ1{=-yn+$K_sTrw>m}Wxw8`UZU+~!B^O#9f2ANNu)T3=AZTpqjt&P94SR3gDM71vJ zCoTUg+n)Yj-+}5x$j`q+!rzsz)69YxQ+z+JXt%>(FYNC`ZxWp)dW&d9+W&6Ltqz;| zp*F6&9JW(gk!{004m*Fq-s`Xn1nhkd+c{wGH|&DKp@@z50bw6BJbo80=vw|E!+u}5 z9|Y_p!agecm??w*MS?P3|8)u2Cyig)xM;x65%wv=6Gzv8x4vN)3)rU}zl#U#^A5X2 zz`p3PKMYvwm%iv0uzwW4uQ|S#3ivl1cIkk9(_y;@tQW&F0Xxs}yKKO|>##io_Cv!m zpL+%DN5cM9)Rtjx^a;v*X8bcQeFOG$VgGJ;eD@3ZFC4aiz;@J4w8&3;;|c-W$zcZs zY*&X}F<=*S*nt7-^~0cmUB>uj3|9)+Wrgi2YRk~is|02G8vn3^1Gc|m8SfzhJ3!ch zhR6460l$*N4h`7B4!cIc7GG8`^YlA!YXyG_7)ezyzQ zDURQ<0o&rR+Xw74!!n0=2-q3I?q_)B@Qwk$zhUvcQ@|c1?2ir4IkI!WA1v%4qKBF? z#Is9K<|l?-NVr`C_Ap@&7d=AsNK=k>>=u+e%He6p9sz%h@W+ZCCt8toKWGff9PhAu z2JFcWJ3e4fF)ZzD3fNPHJelXjuBKHDE6m_7cO>Z&L&QQiq)uuva;3TfkmxSYn{~X0qglaIA9-h{2mgpPdMzM z0qglaEMVt4eh&}WXB_s3fPKzkj||us9rmbzeaT^u4p`6cF#-Fkur60jdR?9T)C6Nf!DVE^v0rv>a64tsjQ z*3VaF6pwV4pAoPf9QMqB?dY&)1#Bn7vIn0Xu=5MMfZ^GLe-ZEt8W!K@1nl>PUC8kG zJ~!Z(blCF(wwq!3o#`(Fb}3<(7VR$DL)4Zfre6hRdkSBXG4=eu_1C3=X_5a9y|=J^ zMEi>N6J1WUzi36$e7K-A*zyAm%iZz9fL&48fue&<8QOADP-Yc}y*OY8JM3ivJH%lx z57?m&dv(CB?y%Pc>>3XH+kjo$VXqBXug|Uz*x|-6YvYE19U<&U!!vd_2K;D;y(wTf zbl95%c4LQ~6|kE*>@5Mig~Q$+uvIyJ}K-R!xP8f0)DPx@%>rAJ|pb2hR65k0q@1}MZmt``28|qUvk*50`_HxEx-6v zXFq4W>ahBqB+I_;uzarxv8?Bp?=*SrTaI78>*TTX9G34udF*>tY+XH{p}LAb{Pb7D zjvBG|ogL(TV$<|dt!>k5;-5mM{JUVic>KpDedm!d2&-ceyf%k;AHqzf1Wo-~^$ z9M4YWbN=$VK>1`Ilh6F;N&oOUZL3Ur*6Atf^0Uw>H{sZS;Y)(I3`E-&h;{WNq}B zwb6gpMqgSR{c3IWv9;0P)<)l38{=SYjES`|KGw!qSsUYKZH%F{F`m}O*jgLoY;BCW zwK4wI#$2#A=7qJf2CR)V^AhE6O^jKwtmSFPmOaN|*@F~@A{T%z-7tYK+$bUy7M z?2e*4nKJmM9Af)vH^VZ{(K$6<*e1~lq7zLy>WI#)y{g!>jyYQvxp(wpckFOg@znzP z9J76MOH0$Vw%QoqD=t6{^?jtw{~hu71p1fe+I5MYxyqVC)19ueC+Hg2bqvEiRhII) zj&)DS*P`wPYNH%6q;i!#L4D|W!D*e$E9MC{=0F}Jc5Lb&zohfMgL0&Ge&%}vd8FBk zdB=C&ChVNwHNn8J<^^U`RKYqCGGlklCaz1nJ@@_v*V(08s9v?8+@;LOfg>pRk zY@ug=FL~EIe30%fn)@Kln4#bFS%mfaaRLkan?8$t>aeNq+P&a&hfT59vR^rDw2#|( znZwbZJfAG^j#YbFI=6J*(}($4G{3_}`*CN7jrL<31NF1U5F5in;&&0px898`-^F2d ztys3J!$x=f#T}NliCDij2HF?h+m{l*OFO=Gty$ka95%YUFYB<;-QC7O%+Y-_zJiSEKKk58Ffj#wOnv2{kdWotp@<{j2Z1^Cp`+gsJ z$EN*HdWfjnc=i?TSK5}7XT7NM*s*Dy@TB{T^1i%i&SS@x^Q2c0g&!cA^VqTFJn0oh z;RlN5Ja%k3PkN9j{7RxZj~!dilU`XAez2(Wq_M9e$~*SF|FOfXFY-v!pK7BVY5Ejd zRTP`{C+XEhmB$BZ>Pm66|NoJ~zJ0Oir3sc&Nc*4dFL&5ff9<()g~O)!YuVp8Ec+iq zyYhS5RSwI(h*^%ifGw)|)%*%ZO#~aQy1tV%fVKmi-&C>}-dP?w|KKY;^a$*I}c(=kFah zx_jR5u$&W!ZQFwm8{JbMa@gpO`iR3uchpB6HoBue?y%7v^$CaVRrEq_KX`M8^9Qkg z_O#=-Z$fL>XC1a*z&_`&%LVKU4$FCl*mz%bSk5`bvM)I-=N@9&mmQY#5V7nl4$Jw7 zSoT$i<=jLp`?|w&jv|(Q!(lmJ5zD^mu$;GuW#4jG&RWE>-rV7wMJzk7%5VDI#Gd-$ zsRJLrx^diB@Xc)-Hcn~Ua^I$DwdIc~%Kz*CKjAoI`AA3oymLOMP}AKHJ7-FMZ{VGC zF`dupZxp<92J_^6&3$0Umir)WeN@ubzuUwoXDeqW@0^FZf9y6!7;7U2LO6{#3%byE-s^MuLZA0wbIo)BS`_7pTOJ5__uNOmfhxvu$mo_5S z@3{^e-C@qJV$=7bxR-2v=PfsN8??%L%+02j@!QUr)>2c?9!1%PdcAKD%ResFpWSt? zGA8-@pi0`S_iEl@(%4mhc2}F`>wM64f)Da^eelj2NL`YAF?N-?k!G)7_|&HT>m zWPIp%Y&LGYK42)XW6Bt)fAUDPUwOW;^E)8riH9_Grna=d*7gu+Tmq#8(*9bTU|8Cs zeM{Z>{ePmclSFM9+8M2(y@a1)>Y#t4b=2apj1gkvnQB<(F1``VP8W8D=)R&eMfVfk zU-SUcgGDRS{_m;}aoA`*dVU#u#Kw2HZOCrjCkKuU+P-u1{UN`P`%~+@+A(pPSUXYXWhK6#woV{WtgVu^)YW z<+aD*d%}##lSem=+j~^&jF#z=w(Z}b@X=7OpJ4>~7fJhVw|fn75ifnDYgzkB?Rj6p zSRbVEgRmy@{w7V|sEw!YSG=?CQg^1fnfuuCI!Rj}q;*Z@`y6qQW*y~q=KGcIMcU42 zzp_3^>)hvejq0B|N%Pq?kDD}YOYLj__bJSWjYKy|u#`gD-}g3i*c4OkeDnN9``4C^ zU+rt!n(wDuJ1pacSl08)SRt0(*72)-Z`rX9%NQe;_53n+h-G)I@|*T3+Sc6V=_7QH zYMZgoK9l!PtK60!S(N|Z-=nB^loLB^Yu@ZV>p$J(I{pcpx=D>K>Hl=pY5VXpcAZax z7^&W8bl$`39?Ls!s7u!x@36{i8ZL$0{{Bl`>m^W1AnmV_^{d#lS2LHp&$@ID{XiTo zGp1}*c10T=i7B7sYZpEmin|&4wep|o3*s7P+Q+`gx}I|97DJj3ANed}vFD8ai?7ew zc6BY=#lH5>OLZTld6R7Ud|)1sr{m6hVu>K}j7fffR7TGo!lu0X!mj6z?o;XuyY&Ub zTEMUMrRNWM^ktG17i-`8f?*FMX6p+(dzP(-*z@y9V~x%s{GvM7=}*KT&y)vCys4jR z*`>u{kL0v0kk(OJm$iIPhoxPJjiZ;tMrTc5ht)B(e)~CWbk;0ySU4R|>vw>#0}anS zh|Z>!95yk|h7w?7GU=G~I$vUGK~##s@odCC%AXPrkNw zZfIPTvGwS@AO>5Hu5I#keAO3o!}`kCbnc7TqqWW6tMS8;rYy=DCWdIeGv4z=-xIA! z`{&{N6;R&VU-N%;So#7X*8Gh8q_FCbiL}Uuaj@T=2M-CryrQRX@1nMd725M>j#dxo%7L}r<|^N<+0^! zUH1n1TF(#0Dd%;q>w41|be=N)IZv8#%We4@*E(TzKCma`JZW!@vqx(jw1qT%l%_-b z>z;9cOmvQDMbaEjeO$XXo~nTIme^E(Ej!m?Q=4kpXB}4ilUVXS;yJ@I{?WRBUh-ZL zebJO*40U|1|35f9^MNvmpJ^<0eptV+3iX<(EkoSQ z9mJOTQ!?w%;`dLC<&tk*xz@HdXv9`C(H^K#hvZUlMy-wULV6z4>pa1 zwv%2?l)BU(?Vz2?kw;p;Ut)REd0)Yk*6*$?FYnmYKj~FObK44%UeVYF7#lncc4VMv z?t}D7#x}^<;9;;MD~sknNawMUN1FJM!J;`&diBgk-Vo7MOB>@#Kht*du&*Y{`%qCG zcNpxfPwjVXF!)y+ zlMu^pnat(S#Bx?4mfa?q%b$tm3_~oteKMCn)BTgP4zcWxV%te{XEMK*RE9GTv1N7_ z+a98gq7@la&lqwhBDPGE*d~Zh6x~a-BB?D)l?GdGas`yP#OfJi*%pWG9{8Q=u$-xg z_1l)r<B(IFOl;3GW!aey+bdwb7Fw_IfV!Pk>-@1?Up@HvErH7)k>RX&v)3N0qe!Ud4gEK z7bSD~Gxgn?Wy-Rbiv2QCTZaD7{oIzhw)B-AX|CuU!?M>4WO>d6?jDHcZxY+hqO(MA z5xrIPHqqNfXNy)O^{t+J*3aD)P~H-|UTL$e=XXTF-dEbwBl&Fz*!!#4^tVsyUgnw} zTk-d6?n-+%w@j4#1b-hawip{*I%EDlf5XOihcZU5Ud|uR6V3+qeD?AlqU_Vlin6cv z5@jFkBbv$Azc)Xy|27-YR_bYKnpylZ#MYJW2>+fovM)t#q+aeEdY6z_q=>yPvf-O-vOt)TSI+%QoKE>{@q5$0!^PesDpmN#=M|@{k(vkJ7s>i z<{cL0ZkqGha-Q-q)<&9gscc%uQD4zM_JoS0xsPvzXMQi{9IHrTQ~b3oV^opE(gwu( UT_~B$pNXYyh-DW}=Hlmn1I1dU(*OVf literal 0 HcmV?d00001 diff --git a/dominion/dominion.o b/dominion/dominion.o new file mode 100644 index 0000000000000000000000000000000000000000..76f5c8f525289f62f2dde1d991c430707c1cc048 GIT binary patch literal 62656 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 literal 0 HcmV?d00001 diff --git a/dominion/playdom b/dominion/playdom new file mode 100644 index 0000000000000000000000000000000000000000..81bcff0de52008133a90c40cba9756351179ebf9 GIT binary patch literal 70744 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 FKLM1b{)+$r literal 0 HcmV?d00001 diff --git a/dominion/playdom.gcno b/dominion/playdom.gcno new file mode 100644 index 0000000000000000000000000000000000000000..3cd873950d75c621c11563ae949d70a3a8f0c3ea GIT binary patch literal 6876 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 literal 0 HcmV?d00001 diff --git a/dominion/player.gcno b/dominion/player.gcno new file mode 100644 index 0000000000000000000000000000000000000000..640bca40010cc81bc4fb48249af0337314bb8d6b GIT binary patch literal 7544 zcmeI1>5r5}5Qk@w`;bfISgz$1P*@HX5QSwOZj?g>1Z0<4E=52RV~|8mJU|WcOuS7L z(V(J&iMNTjF@E)ne~15o^-NVWZBgxKKUhii`}VJ%uCDI)n3>(fhwA$_Eo@uRa^}5r zl}e>LK$;%n7ycO0dg}by)12Sib>NU3Dwl~LIoNe<&(Ya+`mHpT_Uit|@&D$(y#pOp zt{=uV?b$f%sP?ixG0v;v%4v*qSiHA5@k&KwXpHgWQm(xgOFZNIh%>IAxSHld?<*eV zLMIpFQZB~#7f16oqjMieG4z3j82TV_Uju#g%f-n#K|J3F^udJ~`VfoxI?;y~V(7!f zeJ$)Q`jr+-`!QVlSBO*J2=Tl=bhIcJI=L8^a?vLrHd35%#F(4@IPs)$93?(lJlb#c zF@+dw;Nq+6{6{JoBNa z{OIIJ`v$v29Ihsw#=)T9Bu)$-?MCrjBSs$`TPmK{MSq!Tes1*kLJWPm#cq~ks*Cy1 zJ1pjNqQk@GF=|Ke63^?aNq>cDtK^u^gTB&Yc`kCJr(8Zpp4B#PgBSuJQwq# z?-q}0AkS?U+bYLAC;IIcyF-p@dLN>9i|5x8W{YXQ2K25%jCr?-Q{N8pyax0;Ew){b zYFY!juK}hs54m@WQ}bQoYI>c}OXFa7i8Br+uMfRboESRSE?uuqIg4__pzjf9&FR_Z z8r8+gl{ET$#dED&`i#vr`U9NCxP4BePo22DajGrS_Gp}I?f&<}B#BKHpCUe0e46-l z@$^}hK705qNuL?KYtws;_Y&`*rq!wgrNbUz9P>GsOTQ-0^Ubr`v|6>Fbac&^j^o*F znzFr2@N@7iH%-~zCU~~_JOe1(r@->eHci>SCiuKO%S}_3^veBQfNwpQ~Fvz}+~3E1HU_F%w{D6mo9kp=cpkatvpJshy33+$1A9aCWM z3s~MCnBTLbDqE}jJJx!hjn+24z}_F^olszp1?@YkNp#Yjqzc zThFr(JCb~v%o$Xu(Jy6Qvu6o7v^htT4igsUOwY6&z@4*T4m>0&$G`2Y+HeS zHelx#*yjRvet~^HVEO%o`FdYa*;-v2pYfPyUsTyzW%(_IdG;lhtyPxaR+wjBR@qu* z7g^7(cyOZbN zBFRP5{a9vw&%S+;<3!o^0(;uAtdZ|zn9uu;XlELc)M)Mw>w5m(gf))J)(Y&|fL&2w z-w)W81@?o0T~%N|4A|8L_FTZODX<>}?AikRalo!Cu%86%`T~1CVAFS9f89O}*bRle zp9Sp30{eNu@>>=2HGHA6wR-Ptww`Cd3Rr&2VxIk4WotEW`mO8PZvu9UX`cNyV7C_7 z?*evPf&D&Uw-?wS0(M7%{V`y77TBKxmfsGT--n-7wpRCdm-RgROTcy(*k1#7cY*!V zvAomj1(xrZzdN4yaCd<}9~H^I^?!L)(f(|^aPol@+yCkz=lm~ko*ez&jBJc; zul8vi|Ea5zb&VEp5pSB_C$N|wGgf75mDTw#Wyb|9HDf++`prS?ZzcfpF8}}l literal 0 HcmV?d00001 diff --git a/dominion/rngs.gcno b/dominion/rngs.gcno new file mode 100644 index 0000000000000000000000000000000000000000..f24b292a8acd77db08b8696041495dcd560da557 GIT binary patch literal 4032 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 literal 0 HcmV?d00001 diff --git a/projects/johansen/dominion/dominion.c b/projects/johansen/dominion/dominion.c index 74200d0d3..615150322 100644 --- a/projects/johansen/dominion/dominion.c +++ b/projects/johansen/dominion/dominion.c @@ -681,6 +681,223 @@ int getCost(int cardNumber) return -1; } +int do_mine(struct gameState* state, int currentPlayer, int nextPlayer, int choice1, int choice2, int handPos) { //state,currentPlayer,choice1,choice2, handPos + int j = state->hand[currentPlayer][choice1]; //store card we will trash + + if (state->hand[currentPlayer][choice1] < copper || state->hand[currentPlayer][choice1] > gold || choice2 > treasure_map || choice2 < curse || (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 + int i; + for (i = 1; i < state->handCount[currentPlayer]; i++){ + if (state->hand[currentPlayer][i] == j){ + discardCard(i, currentPlayer, state, 1); + break; + } + } + + return 0; +} + +int do_baron(struct gameState* state, int currentPlayer, int nextPlayer, int choice1, int choice2, int handPos) { //state,currentPlayer,choice1,choice2, handPos + state->numBuys++;//Increase buys by 1! + if (choice1 > 0) { //Boolean true or going to discard an estate + int p = 1;//Iterator for hand! + int card_not_discarded = 1;//Flag for discard set! + while (card_not_discarded) { + if (state->hand[currentPlayer][p] == estate) { //Found an estate card! + state->coins += 4;//Add 4 coins to the amount of coins + state->discard[currentPlayer][state->discardCount[currentPlayer]] = state->hand[currentPlayer][p]; + state->discardCount[currentPlayer]++; + + for (; p < state->handCount[currentPlayer]; p++) + state->hand[currentPlayer][p] = state->hand[currentPlayer][p + 1]; + + state->hand[currentPlayer][state->handCount[currentPlayer]] = -1; + state->handCount[currentPlayer]--; + card_not_discarded = 0;//Exit the loop + } + else if (p > state->handCount[currentPlayer]) { + //if (DEBUG) { + // printf("No estate cards in your hand, invalid choice\n"); + // printf("Must gain an estate if there are any\n"); + //} + if (supplyCount(estate, state) > 0) { + gainCard(baron, state, 0, currentPlayer); + + state->supplyCount[estate]--;//Decrement estates + if (supplyCount(estate, state) == 0) + isGameOver(state); + } + card_not_discarded = 0;//Exit the loop + } + + else + p++;//Next card + } + } + + else { + if (supplyCount(estate, state) > 0) { + gainCard(estate, state, 0, currentPlayer);//Gain an estate + + state->supplyCount[estate]--;//Decrement Estates + if (supplyCount(estate, state) == 0) { + isGameOver(state); + } + } + } + + + return 0; +} + +int do_ambassador(struct gameState* state, int currentPlayer, int nextPlayer, int choice1, int choice2, int handPos) {//state,currentPlayer,choice1,choice2, handPos + int j = 0; //used to check if player has enough cards to discard + int i; + + if (choice2 > 2 || choice2 < 0 || 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 = 1; 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 = 1; 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; +} + +int do_minion(struct gameState* state, int currentPlayer, int nextPlayer, int choice1, int choice2, int handPos) {//state,currentPlayer,choice1,choice2, handPos + //+1 action + state->numActions++; + + //discard card from hand + discardCard(handPos, currentPlayer, state, 0); + + if (choice1) + 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 + int i; + int j; + for (i = 1; i < 3; 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; +} + +int do_tribute(struct gameState* state, int currentPlayer, int nextPlayer, int choice1, int choice2, int handPos) {//state, currentPlayer, nextPlayer, choice1, choice2, handPos + int tributeRevealedCards[2] = { -1, -1 }; + int i; + int j; + if ((state->discardCount[currentPlayer] + state->deckCount[currentPlayer]) <= 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 (j = 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; + j++; + } + return 0; +} + int cardEffect(int card, int choice1, int choice2, int choice3, struct gameState *state, int handPos, int *bonus) { int i; @@ -691,7 +908,6 @@ int cardEffect(int card, int choice1, int choice2, int choice3, struct gameState 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; @@ -804,41 +1020,9 @@ int cardEffect(int card, int choice1, int choice2, int choice3, struct gameState case gardens: return -1; - + ///state, currentPlayer, nextPlayer, choice1, choice2, handPos 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; + return do_mine(state, currentPlayer, nextPlayer, choice1, choice2, handPos); case remodel: j = state->hand[currentPlayer][choice1]; //store card we will trash @@ -889,57 +1073,7 @@ int cardEffect(int card, int choice1, int choice2, int choice3, struct gameState return 0; case baron: - state->numBuys++;//Increase buys by 1! - if (choice1 > 0) { //Boolean true or going to discard an estate - int p = 0;//Iterator for hand! - int card_not_discarded = 1;//Flag for discard set! - while(card_not_discarded) { - if (state->hand[currentPlayer][p] == estate) { //Found an estate card! - state->coins += 4;//Add 4 coins to the amount of coins - state->discard[currentPlayer][state->discardCount[currentPlayer]] = state->hand[currentPlayer][p]; - state->discardCount[currentPlayer]++; - for (; p < state->handCount[currentPlayer]; p++) { - state->hand[currentPlayer][p] = state->hand[currentPlayer][p+1]; - } - state->hand[currentPlayer][state->handCount[currentPlayer]] = -1; - state->handCount[currentPlayer]--; - card_not_discarded = 0;//Exit the loop - } - else if (p > state->handCount[currentPlayer]) { - if(DEBUG) { - printf("No estate cards in your hand, invalid choice\n"); - printf("Must gain an estate if there are any\n"); - } - if (supplyCount(estate, state) > 0) { - gainCard(estate, state, 0, currentPlayer); - - state->supplyCount[estate]--;//Decrement estates - if (supplyCount(estate, state) == 0) { - isGameOver(state); - } - } - card_not_discarded = 0;//Exit the loop - } - - else { - p++;//Next card - } - } - } - - else { - if (supplyCount(estate, state) > 0) { - gainCard(estate, state, 0, currentPlayer);//Gain an estate - - state->supplyCount[estate]--;//Decrement Estates - if (supplyCount(estate, state) == 0) { - isGameOver(state); - } - } - } - - - return 0; + return do_baron(state, currentPlayer, nextPlayer, choice1, choice2, handPos); case great_hall: //+1 Card @@ -953,54 +1087,7 @@ int cardEffect(int card, int choice1, int choice2, int choice3, struct gameState return 0; case minion: - //+1 action - state->numActions++; - - //discard card from hand - discardCard(handPos, currentPlayer, state, 0); - - if (choice1) - { - 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; + return do_minion(state, currentPlayer, nextPlayer, choice1, choice2, handPos); case steward: if (choice1 == 1) @@ -1026,121 +1113,10 @@ int cardEffect(int card, int choice1, int choice2, int choice3, struct gameState 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; + return do_tribute(state, currentPlayer, nextPlayer, choice1, choice2, handPos); 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; + return do_ambassador(state, currentPlayer, nextPlayer, choice1, choice2, handPos); case cutpurse: @@ -1369,5 +1345,6 @@ int updateCoins(int player, struct gameState *state, int bonus) } + //end of dominion.c diff --git a/projects/johansen/dominion/dominion.gcda b/projects/johansen/dominion/dominion.gcda new file mode 100644 index 0000000000000000000000000000000000000000..df13e1b5ad6821ee6c9502eaaf8304f1405b5aeb GIT binary patch literal 4332 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 B77hRa literal 0 HcmV?d00001 diff --git a/projects/johansen/dominion/dominion.o b/projects/johansen/dominion/dominion.o new file mode 100644 index 0000000000000000000000000000000000000000..4937e733e606a4d0ec845a62cca3af14c67399cc GIT binary patch literal 66760 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 BC4&F} literal 0 HcmV?d00001 diff --git a/projects/johansen/dominion/interface.gcno b/projects/johansen/dominion/interface.gcno new file mode 100644 index 0000000000000000000000000000000000000000..a4d2610a768a179aacae5e779b4da6c020488c27 GIT binary patch literal 14676 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 CcdknS literal 0 HcmV?d00001 diff --git a/projects/johansen/dominion/playdom b/projects/johansen/dominion/playdom new file mode 100644 index 0000000000000000000000000000000000000000..4d31c214faf51031729c61c31078a4e59cdc060c GIT binary patch literal 72432 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� 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 literal 0 HcmV?d00001 diff --git a/projects/johansen/dominion/playdom.gcda b/projects/johansen/dominion/playdom.gcda new file mode 100644 index 0000000000000000000000000000000000000000..3b23f721517c4f92023e4703565d233bf9f69afc GIT binary patch literal 1444 zcmai!JxE+Z5Xbk7Uw9Fd^Alqs3X)3X44P6>D+EC~>_p)#Y_toJbQX%85F}j?W2K-) zK!Q!Mva*l_f}N$1GG`Ow{@vgIkQc=%-fw2!?9A@$yf-^PSDt)5^y>HJkNptB_Sg96 zKHX@!$c0c7_2E){L>a10ylP1N`>#^jOzOSQLR_Df&gf81$zVcI*b{WKJKB^B3%pa= zI`n?1_Q zZqLwz{t>EXFZvOEQ=eYqn}K>Yf^O>EWBA_CAocDozB2jLgIRo|cWNx*yN0T}hF&C2 zIKX!ZmG1<7nM)P=SX08My{xz%m!-99_fd*K$Ia1*qPRSHrdX?xb$q7G_vHD* zMQiO0gK*RljU+kwmE)}SXVYqFYbS)yxi8Ts<%2v=>%#{)4Hu#3uZ-3mtfAg&1Y u?~vG^wS9hbB83NjU%|G&`7B-kq4O|G;W>G2oAzhvbDF;I$L7uNRqh6Cur%!e literal 0 HcmV?d00001 diff --git a/projects/johansen/dominion/playdom.gcno b/projects/johansen/dominion/playdom.gcno new file mode 100644 index 0000000000000000000000000000000000000000..33dd936fab4bdb2abda91bd10a7974018f4e904d GIT binary patch literal 6876 zcmeH~*^(7S5QfhIWs`jb*&TLJ1Y{FrXB-ek!9f%RbcSIOL%`iY!|=l88GHe6eHO3u z0lfDa%x^N&>i8r30gNysvb*cgFRQAnvS#``dN_S=;_%)BfB*HzZ-c>L_!JlO-$(vj z@YB^_ew}5{52o%vwA)~|`6nMwJ-+?u!R~2$o`X0zJ^X0q{{Q8_u>xa5_7P)mpO|?X z8$KCrVrbNWa~?~*ilLE@ck{?WyJeo^piwu^m=hZey#KlOG|yc7pp8C1Vhil<=I?>N z(!ARj40T-fg}yLii|p>^eWBA=&Xs(a#pYFC=u0BD)b4KH7rOQZv&_8e3w?RSM(pn9 zeW7b#Fi)FT`+>f~oN>rwPgrNx9=+Qa8g2HY``)xynOAc~XTPx3=G{EnYs{-W^tBN? zY4@BLEc!Zg`r2dOjiIlPShv2&L*LL7Lx0v>=fXRqzhK^-`>3@ynk!EmeUmx-7IQbR zUG&Z7n#VZkyCRmgPX5-=^nK8`nKRA~b2lFceY<%z4m#tIm*bGX(;Q95L4Ph{ug1?=>fHpLus)=r2Z0-v|A8PmF%{N9>^8 z-F!{a513c;MDOd9ehx+6%XaV16aA&082aIe={ukwF|XDgJ?D~Z#kfb!nLDxW9MF$N zOvgdbzBGn@q9+eM|CVbW=lN9RP1wCV7xdE+(>(Mu=G8l+Uy8hZ=P_%)Qt;%XkDId| z=gi%FpV7~nSL2{xj989C{;LH~KKglc#(CY`&BsB1&Ab{1opH#^amc@5j;3pa{zk;e zBc6HaZ<<%*pm)dNjMCP%r2Uq8H8whHjj^AMlVj7qY);-4^X|OR-;S8R5Bg+JjDFsU z*n4*G_KE&(PYnHP#B@CLYv$D&p--B3_kwY+hj!EMZoaSRH_WTGLZ9r3(a-x4gXz8( z`UeryxuZ|^#L%aDV(5Km6n)xU*Mm0t9CPfpd3RlC-w93UiGH^yhJLRnhW??s&SiG! z_al#*L!-^uxSjHu-zl?Zp6lNw^DMS7;(i++&bJ5p!nk*T%PgKz^D;hMVvo!XQ+BCo z%gmRXkC?A8UunL|yxI7W@pDbJkJT1iW4_jWoq02#=iCr9Z+!#p$yweDQ+9*Padmb< zw3Ow0sF}05e#(wE(4L%K6q>Rd3zoITl-=ZVT)kh`8dG+&%W-v<{lJvn;&NP_W#2Gm zx4IlxXW3s&*=;Vz)miEQQ?}Y;Y5-Gqr^|8meyI~oS-#bpIh$iC%ePxIXS1G^-PJ&Q zayIKpS-$m}`Ps~RQkHMOJ?48`f<1ZvqoHXI-*(NM&00}*UjyyQ+0CITyT4$wR+K$h zu(|)r9xB-FJ#*lDu$j+yM+n;Qkp|k6v$_Au@@?46+1!6+k2cVroX!1L_ISbO{wrJU zF?)|Gd)no=`W!M}*)s*3HKOcT!DfvpJ6^C^Bg&pFSbi^H%ARvMuKsRWPs*Mz*sKv{ z`JQa%{qh?EQ?`Al5_LA~N!be^|C+N|Ps;MG+05CjCuJ`-(4L$<7Mik`3N~v`*~3vJ8N56zDb)oo3*X%R0HkF*{p44Zxw9TwzAU&o3*X%or2|e6Q=B4m*eX5 z&DvJ>UcqKh3o995;hXtGGK-otHd!=U%pB8MM8SVG8g3U9d z?B@lWXGYmC3YIg2Df^|%arHgE9xY|RD%ji~Wxp=iJcG(UF4#PS%6?O@c?OmJwqPei xQ}(-p&GV}4_XV5hRayQ0!`~==J7UWI;Bs7jFY>%9`(wfK+YwXtXP0NL{{Y87#LNHy literal 0 HcmV?d00001 diff --git a/projects/johansen/dominion/player b/projects/johansen/dominion/player new file mode 100644 index 0000000000000000000000000000000000000000..80ce0141e942213bd359cd4afdbe6abe2beeda6f GIT binary patch literal 94272 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 NTv0CcFnB=Y{{Y;2uG9bk literal 0 HcmV?d00001 diff --git a/projects/johansen/dominion/player.gcno b/projects/johansen/dominion/player.gcno new file mode 100644 index 0000000000000000000000000000000000000000..d5cd9f04e9d0df4696853cfae5f5fc6b4a3de75d GIT binary patch literal 7544 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 TnArGlwtVEV literal 0 HcmV?d00001 diff --git a/projects/johansen/dominion/rngs.gcno b/projects/johansen/dominion/rngs.gcno new file mode 100644 index 0000000000000000000000000000000000000000..3cc0449388e5e574eb72e945b3dfd97aedcc60c3 GIT binary patch literal 4032 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 literal 0 HcmV?d00001