From 54c20e160688b02044b222f8d533b2f8d78cb2b5 Mon Sep 17 00:00:00 2001 From: zee100100 Date: Sun, 13 Oct 2019 20:12:48 -0700 Subject: [PATCH 01/15] Create p.txt --- projects/alghanmz/p.txt | 1 + 1 file changed, 1 insertion(+) create mode 100644 projects/alghanmz/p.txt diff --git a/projects/alghanmz/p.txt b/projects/alghanmz/p.txt new file mode 100644 index 000000000..44ee501f8 --- /dev/null +++ b/projects/alghanmz/p.txt @@ -0,0 +1 @@ +cout << "H" From 152c02f0da7752fa4bd3d462d18e7a3104add986 Mon Sep 17 00:00:00 2001 From: zee100100 Date: Sun, 17 Nov 2019 22:54:16 -0800 Subject: [PATCH 02/15] Create hw.c --- projects/alghanmz/quiz/hw.c | 1 + 1 file changed, 1 insertion(+) create mode 100644 projects/alghanmz/quiz/hw.c diff --git a/projects/alghanmz/quiz/hw.c b/projects/alghanmz/quiz/hw.c new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/projects/alghanmz/quiz/hw.c @@ -0,0 +1 @@ + From 3da9cafd03ccf1c3021c5bfe7f647bf95b6c70df Mon Sep 17 00:00:00 2001 From: zee100100 Date: Sun, 17 Nov 2019 22:54:38 -0800 Subject: [PATCH 03/15] Add files via upload --- projects/alghanmz/quiz/Makefile | 9 ++++ projects/alghanmz/quiz/testme | Bin 0 -> 28608 bytes projects/alghanmz/quiz/testme.c | 65 +++++++++++++++++++++++++ projects/alghanmz/quiz/testme.c.gcov | 70 +++++++++++++++++++++++++++ projects/alghanmz/quiz/testme.gcda | Bin 0 -> 680 bytes projects/alghanmz/quiz/testme.gcno | Bin 0 -> 3420 bytes 6 files changed, 144 insertions(+) create mode 100644 projects/alghanmz/quiz/Makefile create mode 100644 projects/alghanmz/quiz/testme create mode 100644 projects/alghanmz/quiz/testme.c create mode 100644 projects/alghanmz/quiz/testme.c.gcov create mode 100644 projects/alghanmz/quiz/testme.gcda create mode 100644 projects/alghanmz/quiz/testme.gcno diff --git a/projects/alghanmz/quiz/Makefile b/projects/alghanmz/quiz/Makefile new file mode 100644 index 000000000..05c227e31 --- /dev/null +++ b/projects/alghanmz/quiz/Makefile @@ -0,0 +1,9 @@ +testme: testme.c + gcc -o testme -coverage testme.c + +runtests: testme + ./testme + gcov testme.c + +clean: + rm -f *.o testme *.gcov *.gcda *.gcno diff --git a/projects/alghanmz/quiz/testme b/projects/alghanmz/quiz/testme new file mode 100644 index 0000000000000000000000000000000000000000..8b40b8efcf5e5a8d56ab5052b98b3cdfedc37bdf GIT binary patch literal 28608 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 +#include +#include +#include + +char inputChar() +{ + // TODO: rewrite this function + int c = rand() % 96 + 32; + return (char) c; +} + +char *inputString() +{ + // TODO: rewrite this function + static char str[6]; + int i; + + for (i=0; i < 5; i++) + str[i] = inputChar(); + str[5] = '\0'; + return str; +} + +void testme() +{ + int tcCount = 0; + char *s; + char c; + int state = 0; + time_t start = time(NULL); + while (time(NULL) - start < 5) + { + tcCount++; + c = inputChar(); + s = inputString(); + printf("Iteration %d: c = %c, s = %s, state = %d\n", tcCount, c, s, state); + + if (c == '[' && state == 0) state = 1; + if (c == '(' && state == 1) state = 2; + if (c == '{' && state == 2) state = 3; + if (c == ' '&& state == 3) state = 4; + if (c == 'a' && state == 4) state = 5; + if (c == 'x' && state == 5) state = 6; + if (c == '}' && state == 6) state = 7; + if (c == ')' && state == 7) state = 8; + if (c == ']' && state == 8) state = 9; + if (s[0] == 'r' && s[1] == 'e' + && s[2] == 's' && s[3] == 'e' + && s[4] == 't' && s[5] == '\0' + && state == 9) + { + printf("error "); + exit(200); + } + } +} + + +int main(int argc, char *argv[]) +{ + srand(time(NULL)); + testme(); + return 0; +} diff --git a/projects/alghanmz/quiz/testme.c.gcov b/projects/alghanmz/quiz/testme.c.gcov new file mode 100644 index 000000000..b06c4bb33 --- /dev/null +++ b/projects/alghanmz/quiz/testme.c.gcov @@ -0,0 +1,70 @@ + -: 0:Source:testme.c + -: 0:Graph:testme.gcno + -: 0:Data:testme.gcda + -: 0:Runs:3 + -: 0:Programs:1 + -: 1:#include + -: 2:#include + -: 3:#include + -: 4:#include + -: 5: + 7296396: 6:char inputChar() + -: 7:{ + -: 8: // TODO: rewrite this function + 7296396: 9: int c = rand() % 96 + 32; + 7296396: 10: return (char) c; + -: 11:} + -: 12: + 1216066: 13:char *inputString() + -: 14:{ + -: 15: // TODO: rewrite this function + -: 16: static char str[6]; + -: 17: int i; + -: 18: + 7296396: 19: for (i=0; i < 5; i++) + 6080330: 20: str[i] = inputChar(); + 1216066: 21: str[5] = '\0'; + 1216066: 22: return str; + -: 23:} + -: 24: + 3: 25:void testme() + -: 26:{ + 3: 27: int tcCount = 0; + -: 28: char *s; + -: 29: char c; + 3: 30: int state = 0; + 3: 31: time_t start = time(NULL); + 3: 32: while (time(NULL) - start < 7) + -: 33: { + 1216066: 34: tcCount++; + 1216066: 35: c = inputChar(); + 1216066: 36: s = inputString(); + 1216066: 37: printf("Iteration %d: c = %c, s = %s, state = %d\n", tcCount, c, s, state); + -: 38: + 1216066: 39: if (c == '[' && state == 0) state = 1; + 1216066: 40: if (c == '(' && state == 1) state = 2; + 1216066: 41: if (c == '{' && state == 2) state = 3; + 1216066: 42: if (c == ' '&& state == 3) state = 4; + 1216066: 43: if (c == 'a' && state == 4) state = 5; + 1216066: 44: if (c == 'x' && state == 5) state = 6; + 1216066: 45: if (c == '}' && state == 6) state = 7; + 1216066: 46: if (c == ')' && state == 7) state = 8; + 1216066: 47: if (c == ']' && state == 8) state = 9; + 1216066: 48: if (s[0] == 'r' && s[1] == 'e' + 111: 49: && s[2] == 's' && s[3] == 'e' + #####: 50: && s[4] == 't' && s[5] == '\0' + #####: 51: && state == 9) + -: 52: { + #####: 53: printf("error "); + #####: 54: exit(200); + -: 55: } + -: 56: } + 3: 57:} + -: 58: + -: 59: + 3: 60:int main(int argc, char *argv[]) + -: 61:{ + 3: 62: srand(time(NULL)); + 3: 63: testme(); + 3: 64: return 0; + -: 65:} diff --git a/projects/alghanmz/quiz/testme.gcda b/projects/alghanmz/quiz/testme.gcda new file mode 100644 index 0000000000000000000000000000000000000000..237cfdc55a2b9b5ed8a78f9da2b123b560298754 GIT binary patch literal 680 zcmYdHNlp*4FfiFErya+@z_8c^NHjc)(b59a%s~9><2Obi#n92H38EN!Li52iCxZi! zW?^6uNC5NE2{v>AAYTB8L1u!00fb@z84fWKL307cN}vi-KY*=gUc^!`d z(@a1T#-7r*6D|gGqr~caU@;)U2(lOCrrP4}=JNLF&kPI;899J_n0s*1FufrAH6G37 zNKalV4btm`q!;Ecbh^+Gs0c}&o)Id4Dw_OqG=2mczY&eU2aSIfjcx>qek~ZA4vfEjGe0%QZkBOP*S(fE{<+4ls z-R8&lZ$3Qzy-oV-%WGX}vhCu%mCfGz%4~=DE|;vGj}+~&%VN%0480viZ!zCl#^k_q zaph^w@Twdb<8eQZFq9-d`O`5w747mR#-u6sqsE=&1t>8jo!|Gv?RR=Lap zi`owgbn8;AH{9u8UmL5PZ%yW;a~T|aq8QfBXSas`kDcLr;j%nZtSK?;$ok{H-sHfn zjX7}J3o!@I-eo-X)xDv654<7Hc%Ne);AuZ7pO`&`)~LAG0_VL#%jeJn2V-28sTT2= zIM}$j*8<-sj+W1%1rFx5i1(M+L211f_yKXWd=4#eFt0^?sKky)>$SiSi=*XpXn})y zE#jjkc3fJo1%6B%EuTXR9L#GG^KO7O#l05zNpZA%4lQsnuSI;S#3rQmTHvR}(egR8 zz`?v0@tG2vlGba1Pl}`Eb7+Bsc`f3zB{m~%E^hk;yd@4l=D^R@g@aH>gK4<#K*uaURqlnR1y27P-_UnQ~bh zEOMz)GUalW@Y4 zHHFKoa;M5Da_1_zts3t23a-^X>fWf}THPaezJhCYkK9`oT&sKJE>v)>?vXoL!L|BC z?wvkvR=lgc%gxsKvqxWkeuBT&ef7Hcq_?rwT^*>;STVkxH~MvIqW<3_oFjH7aXt_m zM$5gK3w?k7c-+n%8%qx3eKjpG;t_GM$cQ={tMY|uZKcDyxCsVH8 zdvK3OUFK1D-q^Q1X=}~6|L4*9g+C9!zolQ)Z1KhNhV Date: Sun, 17 Nov 2019 23:04:07 -0800 Subject: [PATCH 04/15] Create hw33.c --- projects/alghanmz/alghanmz-assignment-3/hw33.c | 1 + 1 file changed, 1 insertion(+) create mode 100644 projects/alghanmz/alghanmz-assignment-3/hw33.c diff --git a/projects/alghanmz/alghanmz-assignment-3/hw33.c b/projects/alghanmz/alghanmz-assignment-3/hw33.c new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/projects/alghanmz/alghanmz-assignment-3/hw33.c @@ -0,0 +1 @@ + From c854d01e53f47dd610ae77e4053dc02d1cfd28ab Mon Sep 17 00:00:00 2001 From: zee100100 Date: Sun, 17 Nov 2019 23:07:52 -0800 Subject: [PATCH 05/15] Add files via upload --- .../alghanmz/alghanmz-assignment-3/Makefile | 46 + .../alghanmz/alghanmz-assignment-3/dominion.c | 1420 +++++++++++++++++ .../alghanmz/alghanmz-assignment-3/dominion.h | 131 ++ .../alghanmz-assignment-3/unittest1.c | 98 ++ .../alghanmz-assignment-3/unittest2.c | 73 + .../alghanmz-assignment-3/unittest3.c | 94 ++ .../alghanmz-assignment-3/unittest4.c | 109 ++ .../alghanmz-assignment-3/unittest5.c | 98 ++ .../alghanmz-assignment-3/unittestresults.out | 963 +++++++++++ 9 files changed, 3032 insertions(+) create mode 100644 projects/alghanmz/alghanmz-assignment-3/Makefile create mode 100644 projects/alghanmz/alghanmz-assignment-3/dominion.c create mode 100644 projects/alghanmz/alghanmz-assignment-3/dominion.h create mode 100644 projects/alghanmz/alghanmz-assignment-3/unittest1.c create mode 100644 projects/alghanmz/alghanmz-assignment-3/unittest2.c create mode 100644 projects/alghanmz/alghanmz-assignment-3/unittest3.c create mode 100644 projects/alghanmz/alghanmz-assignment-3/unittest4.c create mode 100644 projects/alghanmz/alghanmz-assignment-3/unittest5.c create mode 100644 projects/alghanmz/alghanmz-assignment-3/unittestresults.out diff --git a/projects/alghanmz/alghanmz-assignment-3/Makefile b/projects/alghanmz/alghanmz-assignment-3/Makefile new file mode 100644 index 000000000..377d44b80 --- /dev/null +++ b/projects/alghanmz/alghanmz-assignment-3/Makefile @@ -0,0 +1,46 @@ +CFLAGS= -Wall -fpic -coverage -lm -std=c99 + +unittestresults: unittest1 unittest2 unittest3 unittest4 unittest5 runtests + +rngs.o: rngs.h rngs.c + gcc -c rngs.c $(CFLAGS) + +dominion.o: dominion.h dominion.c rngs.o + gcc -c dominion.c $(CFLAGS) + +unittest1: dominion.o rngs.o unittest1.c + gcc -o unittest1 unittest1.c dominion.o rngs.o $(CFLAGS) + #./unittest1 + +unittest2: dominion.o rngs.o unittest2.c + gcc -o unittest2 unittest2.c dominion.o rngs.o $(CFLAGS) + #./unittest2 + +unittest3: dominion.o rngs.o unittest3.c + gcc -o unittest3 unittest3.c dominion.o rngs.o $(CFLAGS) + #./unittest3 + +unittest4: dominion.o rngs.o unittest4.c + gcc -o unittest4 unittest4.c dominion.o rngs.o $(CFLAGS) + #./unittest4 + +unittest5: dominion.o rngs.o unittest5.c + gcc -o unittest5 unittest5.c dominion.o rngs.o $(CFLAGS) + #./unittest5 + +#ifeq (0,1) +runtests: unittest1 unittest2 unittest3 unittest4 unittest5 + ./unittest1 > unittestresults.out + gcov -b -f dominion.c >> unittestresults.out + ./unittest2 >> unittestresults.out + gcov -b -f dominion.c >> unittestresults.out + ./unittest3 >> unittestresults.out + gcov -b -f dominion.c >> unittestresults.out + ./unittest4 >> unittestresults.out + gcov -b -f dominion.c >> unittestresults.out + ./unittest5 >> unittestresults.out + gcov -b -f dominion.c >> unittestresults.out +#endif + +clean: + rm -f *.o unittest1 unittest2 unittest3 unittest4 unittest5 *.gcov *.gcda *.gcno *.out diff --git a/projects/alghanmz/alghanmz-assignment-3/dominion.c b/projects/alghanmz/alghanmz-assignment-3/dominion.c new file mode 100644 index 000000000..0c865f97e --- /dev/null +++ b/projects/alghanmz/alghanmz-assignment-3/dominion.c @@ -0,0 +1,1420 @@ +#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 doMine(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) +{ + int i; + int j; + + 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; +} + +void getEstateCard(struct gameState *state, int currentPlayer) +{ + 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); + } + } +} + +void doBaron(int choice1, struct gameState *state, int currentPlayer) +{ + state->numBuys++;//Increase buys by 1! + state->numBuys++;//Increase buys by 1! + if (choice1 > 0) { //Boolean true or going to discard an estate + int p = 1; //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"); + } + getEstateCard(state, currentPlayer); + card_not_discarded = 0;//Exit the loop + } + + else { + p++;//Next card + } + } + } + + else { + getEstateCard(state, currentPlayer); + } +} + +void doMinion(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) +{ + int i; + int j; + + //+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) > 1 /*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); + } + } + } + } + } +} + +void printDeck(struct gameState *state, int p) { + printf("Deck:"); + for (int i=0; i < state->deckCount[p]; i++) + printf(" %d", state->deck[p][i]); + printf("\n"); +} + +void printHand(struct gameState *state, int p) { + printf("Hand:"); + for (int i=0; i < state->handCount[p]; i++) + printf(" %d", state->hand[p][i]); + printf("\n"); +} + +void doTribute(struct gameState *state, int currentPlayer, int nextPlayer, int tributeRevealedCards[2]) +{ + int i; + + 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]; + tributeRevealedCards[1] = state->deck[nextPlayer][state->deckCount[nextPlayer]-2]; + //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->numActions = state->numActions + 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->coins += 2; + } + } +} + +int doAmbassador(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) +{ + int i; + int j; + + j = 0; //used to check if player has enough cards to discard + + if (choice2 > 3 || choice2 < 0) + { + return -1; + } + +/* + if (choice1 == handPos) + { + return -1; + } + */ + + for (i = 0; i < state->handCount[currentPlayer]; i++) + { + if (i != handPos && state->hand[currentPlayer][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; +} + +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: + return doMine(choice1, choice2, state, handPos, currentPlayer); + + 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: + doBaron(choice1, state, currentPlayer); + 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: + doMinion(choice1, choice2, state, handPos, currentPlayer); + 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: + doTribute(state, currentPlayer, nextPlayer, tributeRevealedCards); + return 0; + + case ambassador: + return doAmbassador(choice1, choice2, state, handPos, currentPlayer); + + 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/alghanmz/alghanmz-assignment-3/dominion.h b/projects/alghanmz/alghanmz-assignment-3/dominion.h new file mode 100644 index 000000000..f9d9039b8 --- /dev/null +++ b/projects/alghanmz/alghanmz-assignment-3/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/alghanmz/alghanmz-assignment-3/unittest1.c b/projects/alghanmz/alghanmz-assignment-3/unittest1.c new file mode 100644 index 000000000..de2476384 --- /dev/null +++ b/projects/alghanmz/alghanmz-assignment-3/unittest1.c @@ -0,0 +1,98 @@ +#include +#include +#include +#include "dominion.h" + +void doBaron(int choice1, struct gameState *state, int currentPlayer); + +void assert(int a, char *s) { + if (!a) { + printf("Assert failed: %s\n", s); + } +} + +void assertEqual(int a, int b, char *s) { + if (a != b) { + printf("Assert failed: %s\n", s); + } +} + +int containsCard(int *container, int size, int card) { + for (int i=0; i < size; i++) { + if (container[i] == card) { + return 1; + } + } + return 0; +} + +int cardCount(int *container, int size, int card) { + int count = 0; + + for (int i=0; i < size; i++) { + if (container[i] == card) { + count++; + } + } + return count; +} + +int main() { + int seed = 47; + int p; + int choice1; + + // card array + int k[10] = { adventurer, council_room, feast, gardens, mine + , remodel, smithy, village, baron, great_hall }; + + // declare the game state + struct gameState G, G2; + + printf("\nBegin Testing doBaron():\n\n"); + initializeGame(2, k, seed, &G); + + printf("Test 1\n"); + memcpy(&G2, &G, sizeof(G)); + p = 0; + G2.hand[p][0] = baron; + choice1 = 0; // choose to gain an estate card + doBaron(choice1, &G2, 0); + assertEqual(G2.numBuys, G.numBuys + 1, "Number of buys not increased by 1"); + assert(containsCard(G2.discard[p], G2.discardCount[p], estate), "Estate card not gained"); + assert(containsCard(G2.playedCards, G2.playedCardCount, baron), "Baron card not discarded"); + + printf("Test 2\n"); + memcpy(&G2, &G, sizeof(G)); + p = 0; + G2.hand[p][0] = baron; + G2.hand[p][1] = estate; + choice1 = 1; // choose to discard an estate card + doBaron(choice1, &G2, 0); + assertEqual(G2.numBuys, G.numBuys + 1, "Number of buys not increased by 1"); + assertEqual(G2.coins, G.coins + 4, "Coins not increased by 4"); + assertEqual(cardCount(G2.hand[p], G2.handCount[p], estate), + cardCount(G.hand[p], G.handCount[p], estate) - 1, "Estate card not discarded"); + assertEqual(cardCount(G2.hand[p], G2.handCount[p], baron), + cardCount(G.hand[p], G.handCount[p], baron) - 1, "Baron card not discarded"); + + printf("Test 3\n"); + memcpy(&G2, &G, sizeof(G)); + p = 0; + G2.hand[p][0] = estate; + G2.hand[p][1] = baron; + G2.hand[p][2] = copper; + G2.hand[p][3] = copper; + G2.hand[p][4] = copper; + choice1 = 1; // choose to discard an estate card + doBaron(choice1, &G2, 0); + assertEqual(G2.numBuys, G.numBuys + 1, "Number of buys not increased by 1"); + assertEqual(G2.coins, G.coins + 4, "Coins not increased by 4"); + assertEqual(cardCount(G2.hand[p], G2.handCount[p], estate), + cardCount(G.hand[p], G.handCount[p], estate) - 1, "Estate card not discarded"); + assertEqual(cardCount(G2.hand[p], G2.handCount[p], baron), + cardCount(G.hand[p], G.handCount[p], baron) - 1, "Baron card not discarded"); + + printf("End of doBaron() Tests\n\n"); + return 0; +} diff --git a/projects/alghanmz/alghanmz-assignment-3/unittest2.c b/projects/alghanmz/alghanmz-assignment-3/unittest2.c new file mode 100644 index 000000000..c22d721b2 --- /dev/null +++ b/projects/alghanmz/alghanmz-assignment-3/unittest2.c @@ -0,0 +1,73 @@ +#include +#include +#include +#include "dominion.h" + +void doMinion(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer); + +void assert(int a, char *s) { + if (!a) { + printf("Assert failed: %s\n", s); + } +} + +void assertEqual(int a, int b, char *s) { + if (a != b) { + printf("Assert failed: %s\n", s); + } +} + +int containsCard(int *container, int size, int card) { + for (int i=0; i < size; i++) { + if (container[i] == card) { + return 1; + } + } + return 0; +} + +int main() { + int seed = 47; + int p; + int p2; + int choice1; + int choice2; + + // card array + int k[10] = { adventurer, council_room, feast, gardens, mine + , remodel, smithy, village, minion, great_hall }; + + // declare the game state + struct gameState G, G2; + + printf("\nBegin Testing doMinion():\n\n"); + initializeGame(4, k, seed, &G); // 4 players + + printf("Test 1\n"); + memcpy(&G2, &G, sizeof(G)); + p = 0; + G2.hand[p][0] = minion; + choice1 = 1; // choose +2 coins + choice2 = 0; + doMinion(choice1, choice2, &G2, 0, p); + assertEqual(G2.numActions, G.numActions + 1, "Number of actions not increased by 1"); + assertEqual(G2.coins, G.coins + 2, "Number of coins not increased by 2"); + assert(containsCard(G2.playedCards, G2.playedCardCount, minion), "Minion card not discarded"); + + printf("Test 2\n"); + memcpy(&G2, &G, sizeof(G)); + p = 0; + p2 = 2; // another player + G2.hand[p][0] = minion; + G2.handCount[p2] = 3; // change handcount from 5 to 3 + choice1 = 0; + choice2 = 1; // choose to redraw hand + doMinion(choice1, choice2, &G2, 0, p); + assertEqual(G2.numActions, G.numActions + 1, "Number of actions not increased by 1"); + assertEqual(G2.handCount[p], 4, "Current player should have exactly 4 cards"); + assertEqual(G2.handCount[p2], 3, "A player with less than 5 cards discarded hand"); + assert(containsCard(G2.playedCards, G2.playedCardCount, minion), "Minion card not discarded"); + + printf("End of doMinion() Tests\n\n"); + return 0; +} diff --git a/projects/alghanmz/alghanmz-assignment-3/unittest3.c b/projects/alghanmz/alghanmz-assignment-3/unittest3.c new file mode 100644 index 000000000..5de2181f2 --- /dev/null +++ b/projects/alghanmz/alghanmz-assignment-3/unittest3.c @@ -0,0 +1,94 @@ +#include +#include +#include +#include "dominion.h" + +int doAmbassador(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer); + +void assert(int a, char *s) { + if (!a) { + printf("Assert failed: %s\n", s); + } +} + +void assertEqual(int a, int b, char *s) { + if (a != b) { + printf("Assert failed: %s\n", s); + } +} + +int containsCard(int *container, int size, int card) { + for (int i=0; i < size; i++) { + if (container[i] == card) { + return 1; + } + } + return 0; +} + +int cardCount(int *container, int size, int card) { + int count = 0; + + for (int i=0; i < size; i++) { + if (container[i] == card) { + count++; + } + } + return count; +} + +int main() { + int seed = 47; + int p; + int p2; + int handPos; + int choice1; + int choice2; + int ret_val; + + // card array + int k[10] = { adventurer, council_room, feast, gardens, mine + , remodel, smithy, village, ambassador, great_hall }; + + // declare the game state + struct gameState G, G2; + + printf("\nBegin Testing doAmbassador():\n\n"); + initializeGame(2, k, seed, &G); + + printf("Test 1\n"); + memcpy(&G2, &G, sizeof(G)); + p = 0; + p2 = 1; + G2.hand[p][0] = copper; + G2.hand[p][1] = smithy; + G2.hand[p][2] = copper; + G2.hand[p][3] = copper; + G2.hand[p][4] = ambassador; + choice1 = 0; // choose to discard copper + choice2 = 3; // choose to discard 3 of them + handPos = 4; // ambassador + ret_val = doAmbassador(choice1, choice2, &G2, handPos, p); + assertEqual(ret_val, -1, "Didn't return -1 when trying to discard too many cards"); + assertEqual(cardCount(G2.hand[p], G2.handCount[p], copper), + cardCount(G.hand[p], G.handCount[p], copper) - choice2, "Trashed the wrong number of cards"); + assert(containsCard(G2.playedCards, G2.playedCardCount, ambassador), "Ambassador card not discarded"); + assert(containsCard(G2.discard[p2], G2.discardCount[p2], copper), "Player 2 did not gain a copper"); + + printf("Test 2\n"); + memcpy(&G2, &G, sizeof(G)); + p = 0; + p2 = 1; + G2.hand[p][0] = ambassador; + G2.hand[p][1] = ambassador; + choice1 = 0; // choose to discard ambassador + choice2 = 1; // choose to discard 1 of them + handPos = 0; // ambassador + ret_val = doAmbassador(choice1, choice2, &G2, handPos, p); + assertEqual(ret_val, -1, "Didn't return -1 when trying to discard ambassador card"); + assert(containsCard(G2.playedCards, G2.playedCardCount, ambassador), "Ambassador card not discarded"); + assert(containsCard(G2.discard[p2], G2.discardCount[p2], ambassador), "Player 2 did not gain an ambassador card"); + + printf("End of doAmbassador() Tests\n\n"); + return 0; +} diff --git a/projects/alghanmz/alghanmz-assignment-3/unittest4.c b/projects/alghanmz/alghanmz-assignment-3/unittest4.c new file mode 100644 index 000000000..0466e2d66 --- /dev/null +++ b/projects/alghanmz/alghanmz-assignment-3/unittest4.c @@ -0,0 +1,109 @@ +#include +#include +#include +#include "dominion.h" + +void doTribute(struct gameState *state, int currentPlayer, int nextPlayer, int tributeRevealedCards[2]); + +void assert(int a, char *s) { + if (!a) { + printf("Assert failed: %s\n", s); + } +} + +void assertEqual(int a, int b, char *s) { + if (a != b) { + printf("Assert failed: %s\n", s); + } +} + +int containsCard(int *container, int size, int card) { + for (int i=0; i < size; i++) { + if (container[i] == card) { + return 1; + } + } + return 0; +} + +int cardCount(int *container, int size, int card) { + int count = 0; + + for (int i=0; i < size; i++) { + if (container[i] == card) { + count++; + } + } + return count; +} + +int main() { + int seed = 47; + int p; + int p2; + int tributeRevealedCards[2]; + int result; + + // card array + int k[10] = { adventurer, council_room, feast, gardens, mine + , remodel, smithy, village, tribute, great_hall }; + + // declare the game state + struct gameState G, G2; + + printf("\nBegin Testing doTribute():\n\n"); + initializeGame(2, k, seed, &G); + + printf("Test 1\n"); + memcpy(&G2, &G, sizeof(G)); + p = 0; + p2 = 1; + G2.hand[p][0] = tribute; + G2.deckCount[p2] = 0; + G2.discardCount[p2] = 2; + G2.discard[p2][G2.discardCount[p2]-2] = copper; + G2.discard[p2][G2.discardCount[p2]-1] = estate; + doTribute(&G2, p, p2, tributeRevealedCards); + result = containsCard(G2.playedCards, G2.playedCardCount, tribute); + assert(result, "Tribute card not discarded"); + if (result) + assertEqual(G2.handCount[p], G.handCount[p]+1, "Didn't draw 2 cards"); + else + assertEqual(G2.handCount[p], G.handCount[p]+2, "Didn't draw 2 cards"); + assertEqual(G2.coins, G.coins+2, "Coins didn't increase by 2"); + + printf("Test 2\n"); + memcpy(&G2, &G, sizeof(G)); + p = 0; + p2 = 1; + G2.hand[p][0] = tribute; + G2.deck[p2][G2.deckCount[p2]-2] = smithy; + G2.deck[p2][G2.deckCount[p2]-1] = estate; + doTribute(&G2, p, p2, tributeRevealedCards); + result = containsCard(G2.playedCards, G2.playedCardCount, tribute); + assert(result, "Tribute card not discarded"); + if (result) + assertEqual(G2.handCount[p], G.handCount[p]+1, "Didn't draw 2 cards"); + else + assertEqual(G2.handCount[p], G.handCount[p]+2, "Didn't draw 2 cards"); + assertEqual(G2.numActions, G.numActions+2, "Actions didn't increase by 2"); + + printf("Test 3\n"); + memcpy(&G2, &G, sizeof(G)); + p = 0; + p2 = 1; + G2.hand[p][0] = tribute; + G2.deckCount[p2] = 0; + G2.discardCount[p2] = 1; + G2.discard[p2][0] = estate; + doTribute(&G2, p, p2, tributeRevealedCards); + result = containsCard(G2.playedCards, G2.playedCardCount, tribute); + assert(result, "Tribute card not discarded"); + if (result) + assertEqual(G2.handCount[p], G.handCount[p]+1, "Didn't draw 2 cards"); + else + assertEqual(G2.handCount[p], G.handCount[p]+2, "Didn't draw 2 cards"); + + printf("End of doTribute() Tests\n\n"); + return 0; +} diff --git a/projects/alghanmz/alghanmz-assignment-3/unittest5.c b/projects/alghanmz/alghanmz-assignment-3/unittest5.c new file mode 100644 index 000000000..d5040c060 --- /dev/null +++ b/projects/alghanmz/alghanmz-assignment-3/unittest5.c @@ -0,0 +1,98 @@ +#include +#include +#include +#include "dominion.h" + +int doMine(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer); + +void assert(int a, char *s) { + if (!a) { + printf("Assert failed: %s\n", s); + } +} + +void assertEqual(int a, int b, char *s) { + if (a != b) { + printf("Assert failed: %s\n", s); + } +} + +int containsCard(int *container, int size, int card) { + for (int i=0; i < size; i++) { + if (container[i] == card) { + return 1; + } + } + return 0; +} + +int cardCount(int *container, int size, int card) { + int count = 0; + + for (int i=0; i < size; i++) { + if (container[i] == card) { + count++; + } + } + return count; +} + +int main() { + int seed = 47; + int p; + int handPos; + int choice1; + int choice2; + int ret_val; + + // card array + int k[10] = { adventurer, council_room, feast, gardens, mine + , remodel, smithy, village, ambassador, great_hall }; + + // declare the game state + struct gameState G, G2; + + printf("\nBegin Testing doMine():\n\n"); + initializeGame(2, k, seed, &G); + + printf("Test 1\n"); + memcpy(&G2, &G, sizeof(G)); + p = 0; + G2.hand[p][0] = curse; + G2.hand[p][1] = mine; + choice1 = 0; // choose to trash curse + choice2 = silver; // choose to gain a silver + handPos = 1; // mine + ret_val = doMine(choice1, choice2, &G2, handPos, p); + assertEqual(ret_val, -1, "Didn't return -1 when trying to trash a curse"); + + printf("Test 2\n"); + memcpy(&G2, &G, sizeof(G)); + p = 0; + G2.hand[p][0] = copper; + G2.hand[p][1] = mine; + G2.hand[p][2] = copper; + G2.hand[p][3] = estate; + G2.hand[p][4] = estate; + choice1 = 0; // choose to trash copper + choice2 = silver; // choose to gain a silver + handPos = 1; // mine + ret_val = doMine(choice1, choice2, &G2, handPos, p); + assert(containsCard(G2.playedCards, G2.playedCardCount, mine), "Mine card not discarded"); + assert(containsCard(G2.hand[p], G2.handCount[p], silver), "Silver not gained to hand"); + assert(containsCard(G2.playedCards, G2.playedCardCount, copper), "Copper card not discarded"); + + printf("Test 3\n"); + memcpy(&G2, &G, sizeof(G)); + p = 0; + G2.hand[p][0] = smithy; + G2.hand[p][1] = mine; + choice1 = 0; // choose to trash smithy + choice2 = silver; // choose to gain a silver + handPos = 1; // mine + ret_val = doMine(choice1, choice2, &G2, handPos, p); + assertEqual(ret_val, -1, "Didn't return -1 when trying to trash a smithy"); + + printf("End of doMine() Tests\n\n"); + return 0; +} diff --git a/projects/alghanmz/alghanmz-assignment-3/unittestresults.out b/projects/alghanmz/alghanmz-assignment-3/unittestresults.out new file mode 100644 index 000000000..e7b35ea86 --- /dev/null +++ b/projects/alghanmz/alghanmz-assignment-3/unittestresults.out @@ -0,0 +1,963 @@ + +Begin Testing doBaron(): + +Test 1 +Assert failed: Number of buys not increased by 1 +Assert failed: Baron card not discarded +Test 2 +Assert failed: Number of buys not increased by 1 +Assert failed: Baron card not discarded +Test 3 +Assert failed: Number of buys not increased by 1 +Assert failed: Coins not increased by 4 +Assert failed: Baron card not discarded +End of doBaron() Tests + +Function 'updateCoins' +Lines executed:81.82% of 11 +Branches executed:100.00% of 8 +Taken at least once:75.00% of 8 +No calls + +Function 'gainCard' +Lines executed:61.54% of 13 +Branches executed:100.00% of 6 +Taken at least once:50.00% of 6 +Calls executed:100.00% of 1 + +Function 'discardCard' +Lines executed:0.00% of 13 +Branches executed:0.00% of 6 +Taken at least once:0.00% of 6 +No calls + +Function 'cardEffect' +Lines executed:0.00% of 133 +Branches executed:0.00% of 93 +Taken at least once:0.00% of 93 +Calls executed:0.00% of 44 + +Function 'doAmbassador' +Lines executed:0.00% of 20 +Branches executed:0.00% of 22 +Taken at least once:0.00% of 22 +Calls executed:0.00% of 3 + +Function 'doTribute' +Lines executed:0.00% of 28 +Branches executed:0.00% of 30 +Taken at least once:0.00% of 30 +Calls executed:0.00% of 2 + +Function 'printHand' +Lines executed:0.00% of 6 +Branches executed:0.00% of 2 +Taken at least once:0.00% of 2 +Calls executed:0.00% of 3 + +Function 'printDeck' +Lines executed:0.00% of 6 +Branches executed:0.00% of 2 +Taken at least once:0.00% of 2 +Calls executed:0.00% of 3 + +Function 'doMinion' +Lines executed:0.00% of 17 +Branches executed:0.00% of 16 +Taken at least once:0.00% of 16 +Calls executed:0.00% of 6 + +Function 'doBaron' +Lines executed:100.00% of 22 +Branches executed:100.00% of 10 +Taken at least once:100.00% of 10 +Calls executed:100.00% of 2 + +Function 'getEstateCard' +Lines executed:85.71% of 7 +Branches executed:100.00% of 4 +Taken at least once:50.00% of 4 +Calls executed:75.00% of 4 + +Function 'doMine' +Lines executed:0.00% of 14 +Branches executed:0.00% of 12 +Taken at least once:0.00% of 12 +Calls executed:0.00% of 4 + +Function 'getCost' +Lines executed:0.00% of 30 +Branches executed:0.00% of 28 +Taken at least once:0.00% of 28 +No calls + +Function 'drawCard' +Lines executed:36.36% of 22 +Branches executed:33.33% of 6 +Taken at least once:16.67% of 6 +Calls executed:0.00% of 1 + +Function 'getWinners' +Lines executed:0.00% of 24 +Branches executed:0.00% of 22 +Taken at least once:0.00% of 22 +Calls executed:0.00% of 2 + +Function 'scoreFor' +Lines executed:0.00% of 42 +Branches executed:0.00% of 42 +Taken at least once:0.00% of 42 +Calls executed:0.00% of 3 + +Function 'isGameOver' +Lines executed:0.00% of 10 +Branches executed:0.00% of 8 +Taken at least once:0.00% of 8 +No calls + +Function 'endTurn' +Lines executed:0.00% of 20 +Branches executed:0.00% of 6 +Taken at least once:0.00% of 6 +Calls executed:0.00% of 3 + +Function 'whoseTurn' +Lines executed:0.00% of 2 +No branches +No calls + +Function 'fullDeckCount' +Lines executed:0.00% of 9 +Branches executed:0.00% of 12 +Taken at least once:0.00% of 12 +No calls + +Function 'supplyCount' +Lines executed:100.00% of 2 +No branches +No calls + +Function 'handCard' +Lines executed:0.00% of 3 +No branches +Calls executed:0.00% of 1 + +Function 'numHandCards' +Lines executed:0.00% of 2 +No branches +Calls executed:0.00% of 1 + +Function 'buyCard' +Lines executed:0.00% of 13 +Branches executed:0.00% of 6 +Taken at least once:0.00% of 6 +Calls executed:0.00% of 4 + +Function 'playCard' +Lines executed:0.00% of 14 +Branches executed:0.00% of 10 +Taken at least once:0.00% of 10 +Calls executed:0.00% of 3 + +Function 'shuffle' +Lines executed:93.75% of 16 +Branches executed:100.00% of 8 +Taken at least once:87.50% of 8 +Calls executed:100.00% of 2 + +Function 'initializeGame' +Lines executed:83.87% of 62 +Branches executed:95.65% of 46 +Taken at least once:80.43% of 46 +Calls executed:100.00% of 5 + +Function 'kingdomCards' +Lines executed:0.00% of 13 +No branches +No calls + +Function 'newGame' +Lines executed:0.00% of 3 +No branches +No calls + +Function 'compare' +Lines executed:83.33% of 6 +Branches executed:100.00% of 4 +Taken at least once:75.00% of 4 +No calls + +File 'dominion.c' +Lines executed:21.78% of 583 +Branches executed:21.03% of 409 +Taken at least once:16.87% of 409 +Calls executed:13.40% of 97 +Creating 'dominion.c.gcov' + + +Begin Testing doMinion(): + +Test 1 +Test 2 +Assert failed: Current player should have exactly 4 cards +Assert failed: A player with less than 5 cards discarded hand +End of doMinion() Tests + +Function 'updateCoins' +Lines executed:81.82% of 11 +Branches executed:100.00% of 8 +Taken at least once:75.00% of 8 +No calls + +Function 'gainCard' +Lines executed:61.54% of 13 +Branches executed:100.00% of 6 +Taken at least once:50.00% of 6 +Calls executed:100.00% of 1 + +Function 'discardCard' +Lines executed:92.31% of 13 +Branches executed:100.00% of 6 +Taken at least once:66.67% of 6 +No calls + +Function 'cardEffect' +Lines executed:0.00% of 133 +Branches executed:0.00% of 93 +Taken at least once:0.00% of 93 +Calls executed:0.00% of 44 + +Function 'doAmbassador' +Lines executed:0.00% of 20 +Branches executed:0.00% of 22 +Taken at least once:0.00% of 22 +Calls executed:0.00% of 3 + +Function 'doTribute' +Lines executed:0.00% of 28 +Branches executed:0.00% of 30 +Taken at least once:0.00% of 30 +Calls executed:0.00% of 2 + +Function 'printHand' +Lines executed:0.00% of 6 +Branches executed:0.00% of 2 +Taken at least once:0.00% of 2 +Calls executed:0.00% of 3 + +Function 'printDeck' +Lines executed:0.00% of 6 +Branches executed:0.00% of 2 +Taken at least once:0.00% of 2 +Calls executed:0.00% of 3 + +Function 'doMinion' +Lines executed:100.00% of 17 +Branches executed:100.00% of 16 +Taken at least once:93.75% of 16 +Calls executed:100.00% of 6 + +Function 'doBaron' +Lines executed:100.00% of 22 +Branches executed:100.00% of 10 +Taken at least once:100.00% of 10 +Calls executed:100.00% of 2 + +Function 'getEstateCard' +Lines executed:85.71% of 7 +Branches executed:100.00% of 4 +Taken at least once:50.00% of 4 +Calls executed:75.00% of 4 + +Function 'doMine' +Lines executed:0.00% of 14 +Branches executed:0.00% of 12 +Taken at least once:0.00% of 12 +Calls executed:0.00% of 4 + +Function 'getCost' +Lines executed:0.00% of 30 +Branches executed:0.00% of 28 +Taken at least once:0.00% of 28 +No calls + +Function 'drawCard' +Lines executed:36.36% of 22 +Branches executed:33.33% of 6 +Taken at least once:16.67% of 6 +Calls executed:0.00% of 1 + +Function 'getWinners' +Lines executed:0.00% of 24 +Branches executed:0.00% of 22 +Taken at least once:0.00% of 22 +Calls executed:0.00% of 2 + +Function 'scoreFor' +Lines executed:0.00% of 42 +Branches executed:0.00% of 42 +Taken at least once:0.00% of 42 +Calls executed:0.00% of 3 + +Function 'isGameOver' +Lines executed:0.00% of 10 +Branches executed:0.00% of 8 +Taken at least once:0.00% of 8 +No calls + +Function 'endTurn' +Lines executed:0.00% of 20 +Branches executed:0.00% of 6 +Taken at least once:0.00% of 6 +Calls executed:0.00% of 3 + +Function 'whoseTurn' +Lines executed:100.00% of 2 +No branches +No calls + +Function 'fullDeckCount' +Lines executed:0.00% of 9 +Branches executed:0.00% of 12 +Taken at least once:0.00% of 12 +No calls + +Function 'supplyCount' +Lines executed:100.00% of 2 +No branches +No calls + +Function 'handCard' +Lines executed:0.00% of 3 +No branches +Calls executed:0.00% of 1 + +Function 'numHandCards' +Lines executed:100.00% of 2 +No branches +Calls executed:100.00% of 1 + +Function 'buyCard' +Lines executed:0.00% of 13 +Branches executed:0.00% of 6 +Taken at least once:0.00% of 6 +Calls executed:0.00% of 4 + +Function 'playCard' +Lines executed:0.00% of 14 +Branches executed:0.00% of 10 +Taken at least once:0.00% of 10 +Calls executed:0.00% of 3 + +Function 'shuffle' +Lines executed:93.75% of 16 +Branches executed:100.00% of 8 +Taken at least once:87.50% of 8 +Calls executed:100.00% of 2 + +Function 'initializeGame' +Lines executed:93.55% of 62 +Branches executed:100.00% of 46 +Taken at least once:89.13% of 46 +Calls executed:100.00% of 5 + +Function 'kingdomCards' +Lines executed:0.00% of 13 +No branches +No calls + +Function 'newGame' +Lines executed:0.00% of 3 +No branches +No calls + +Function 'compare' +Lines executed:83.33% of 6 +Branches executed:100.00% of 4 +Taken at least once:75.00% of 4 +No calls + +File 'dominion.c' +Lines executed:28.47% of 583 +Branches executed:26.89% of 409 +Taken at least once:22.49% of 409 +Calls executed:20.62% of 97 +Creating 'dominion.c.gcov' + + +Begin Testing doAmbassador(): + +Test 1 +Assert failed: Didn't return -1 when trying to discard too many cards +Test 2 +Assert failed: Didn't return -1 when trying to discard ambassador card +End of doAmbassador() Tests + +Function 'updateCoins' +Lines executed:81.82% of 11 +Branches executed:100.00% of 8 +Taken at least once:75.00% of 8 +No calls + +Function 'gainCard' +Lines executed:61.54% of 13 +Branches executed:100.00% of 6 +Taken at least once:50.00% of 6 +Calls executed:100.00% of 1 + +Function 'discardCard' +Lines executed:92.31% of 13 +Branches executed:100.00% of 6 +Taken at least once:83.33% of 6 +No calls + +Function 'cardEffect' +Lines executed:0.00% of 133 +Branches executed:0.00% of 93 +Taken at least once:0.00% of 93 +Calls executed:0.00% of 44 + +Function 'doAmbassador' +Lines executed:90.00% of 20 +Branches executed:100.00% of 22 +Taken at least once:77.27% of 22 +Calls executed:100.00% of 3 + +Function 'doTribute' +Lines executed:0.00% of 28 +Branches executed:0.00% of 30 +Taken at least once:0.00% of 30 +Calls executed:0.00% of 2 + +Function 'printHand' +Lines executed:0.00% of 6 +Branches executed:0.00% of 2 +Taken at least once:0.00% of 2 +Calls executed:0.00% of 3 + +Function 'printDeck' +Lines executed:0.00% of 6 +Branches executed:0.00% of 2 +Taken at least once:0.00% of 2 +Calls executed:0.00% of 3 + +Function 'doMinion' +Lines executed:100.00% of 17 +Branches executed:100.00% of 16 +Taken at least once:93.75% of 16 +Calls executed:100.00% of 6 + +Function 'doBaron' +Lines executed:100.00% of 22 +Branches executed:100.00% of 10 +Taken at least once:100.00% of 10 +Calls executed:100.00% of 2 + +Function 'getEstateCard' +Lines executed:85.71% of 7 +Branches executed:100.00% of 4 +Taken at least once:50.00% of 4 +Calls executed:75.00% of 4 + +Function 'doMine' +Lines executed:0.00% of 14 +Branches executed:0.00% of 12 +Taken at least once:0.00% of 12 +Calls executed:0.00% of 4 + +Function 'getCost' +Lines executed:0.00% of 30 +Branches executed:0.00% of 28 +Taken at least once:0.00% of 28 +No calls + +Function 'drawCard' +Lines executed:36.36% of 22 +Branches executed:33.33% of 6 +Taken at least once:16.67% of 6 +Calls executed:0.00% of 1 + +Function 'getWinners' +Lines executed:0.00% of 24 +Branches executed:0.00% of 22 +Taken at least once:0.00% of 22 +Calls executed:0.00% of 2 + +Function 'scoreFor' +Lines executed:0.00% of 42 +Branches executed:0.00% of 42 +Taken at least once:0.00% of 42 +Calls executed:0.00% of 3 + +Function 'isGameOver' +Lines executed:0.00% of 10 +Branches executed:0.00% of 8 +Taken at least once:0.00% of 8 +No calls + +Function 'endTurn' +Lines executed:0.00% of 20 +Branches executed:0.00% of 6 +Taken at least once:0.00% of 6 +Calls executed:0.00% of 3 + +Function 'whoseTurn' +Lines executed:100.00% of 2 +No branches +No calls + +Function 'fullDeckCount' +Lines executed:0.00% of 9 +Branches executed:0.00% of 12 +Taken at least once:0.00% of 12 +No calls + +Function 'supplyCount' +Lines executed:100.00% of 2 +No branches +No calls + +Function 'handCard' +Lines executed:0.00% of 3 +No branches +Calls executed:0.00% of 1 + +Function 'numHandCards' +Lines executed:100.00% of 2 +No branches +Calls executed:100.00% of 1 + +Function 'buyCard' +Lines executed:0.00% of 13 +Branches executed:0.00% of 6 +Taken at least once:0.00% of 6 +Calls executed:0.00% of 4 + +Function 'playCard' +Lines executed:0.00% of 14 +Branches executed:0.00% of 10 +Taken at least once:0.00% of 10 +Calls executed:0.00% of 3 + +Function 'shuffle' +Lines executed:93.75% of 16 +Branches executed:100.00% of 8 +Taken at least once:87.50% of 8 +Calls executed:100.00% of 2 + +Function 'initializeGame' +Lines executed:93.55% of 62 +Branches executed:100.00% of 46 +Taken at least once:89.13% of 46 +Calls executed:100.00% of 5 + +Function 'kingdomCards' +Lines executed:0.00% of 13 +No branches +No calls + +Function 'newGame' +Lines executed:0.00% of 3 +No branches +No calls + +Function 'compare' +Lines executed:83.33% of 6 +Branches executed:100.00% of 4 +Taken at least once:75.00% of 4 +No calls + +File 'dominion.c' +Lines executed:31.56% of 583 +Branches executed:32.27% of 409 +Taken at least once:26.89% of 409 +Calls executed:23.71% of 97 +Creating 'dominion.c.gcov' + + +Begin Testing doTribute(): + +Test 1 +Assert failed: Tribute card not discarded +Assert failed: Didn't draw 2 cards +Test 2 +Assert failed: Tribute card not discarded +Assert failed: Didn't draw 2 cards +Assert failed: Actions didn't increase by 2 +Test 3 +Assert failed: Tribute card not discarded +Assert failed: Didn't draw 2 cards +End of doTribute() Tests + +Function 'updateCoins' +Lines executed:81.82% of 11 +Branches executed:100.00% of 8 +Taken at least once:75.00% of 8 +No calls + +Function 'gainCard' +Lines executed:61.54% of 13 +Branches executed:100.00% of 6 +Taken at least once:50.00% of 6 +Calls executed:100.00% of 1 + +Function 'discardCard' +Lines executed:92.31% of 13 +Branches executed:100.00% of 6 +Taken at least once:83.33% of 6 +No calls + +Function 'cardEffect' +Lines executed:0.00% of 133 +Branches executed:0.00% of 93 +Taken at least once:0.00% of 93 +Calls executed:0.00% of 44 + +Function 'doAmbassador' +Lines executed:90.00% of 20 +Branches executed:100.00% of 22 +Taken at least once:77.27% of 22 +Calls executed:100.00% of 3 + +Function 'doTribute' +Lines executed:82.14% of 28 +Branches executed:100.00% of 30 +Taken at least once:70.00% of 30 +Calls executed:100.00% of 2 + +Function 'printHand' +Lines executed:0.00% of 6 +Branches executed:0.00% of 2 +Taken at least once:0.00% of 2 +Calls executed:0.00% of 3 + +Function 'printDeck' +Lines executed:0.00% of 6 +Branches executed:0.00% of 2 +Taken at least once:0.00% of 2 +Calls executed:0.00% of 3 + +Function 'doMinion' +Lines executed:100.00% of 17 +Branches executed:100.00% of 16 +Taken at least once:93.75% of 16 +Calls executed:100.00% of 6 + +Function 'doBaron' +Lines executed:100.00% of 22 +Branches executed:100.00% of 10 +Taken at least once:100.00% of 10 +Calls executed:100.00% of 2 + +Function 'getEstateCard' +Lines executed:85.71% of 7 +Branches executed:100.00% of 4 +Taken at least once:50.00% of 4 +Calls executed:75.00% of 4 + +Function 'doMine' +Lines executed:0.00% of 14 +Branches executed:0.00% of 12 +Taken at least once:0.00% of 12 +Calls executed:0.00% of 4 + +Function 'getCost' +Lines executed:0.00% of 30 +Branches executed:0.00% of 28 +Taken at least once:0.00% of 28 +No calls + +Function 'drawCard' +Lines executed:36.36% of 22 +Branches executed:33.33% of 6 +Taken at least once:16.67% of 6 +Calls executed:0.00% of 1 + +Function 'getWinners' +Lines executed:0.00% of 24 +Branches executed:0.00% of 22 +Taken at least once:0.00% of 22 +Calls executed:0.00% of 2 + +Function 'scoreFor' +Lines executed:0.00% of 42 +Branches executed:0.00% of 42 +Taken at least once:0.00% of 42 +Calls executed:0.00% of 3 + +Function 'isGameOver' +Lines executed:0.00% of 10 +Branches executed:0.00% of 8 +Taken at least once:0.00% of 8 +No calls + +Function 'endTurn' +Lines executed:0.00% of 20 +Branches executed:0.00% of 6 +Taken at least once:0.00% of 6 +Calls executed:0.00% of 3 + +Function 'whoseTurn' +Lines executed:100.00% of 2 +No branches +No calls + +Function 'fullDeckCount' +Lines executed:0.00% of 9 +Branches executed:0.00% of 12 +Taken at least once:0.00% of 12 +No calls + +Function 'supplyCount' +Lines executed:100.00% of 2 +No branches +No calls + +Function 'handCard' +Lines executed:0.00% of 3 +No branches +Calls executed:0.00% of 1 + +Function 'numHandCards' +Lines executed:100.00% of 2 +No branches +Calls executed:100.00% of 1 + +Function 'buyCard' +Lines executed:0.00% of 13 +Branches executed:0.00% of 6 +Taken at least once:0.00% of 6 +Calls executed:0.00% of 4 + +Function 'playCard' +Lines executed:0.00% of 14 +Branches executed:0.00% of 10 +Taken at least once:0.00% of 10 +Calls executed:0.00% of 3 + +Function 'shuffle' +Lines executed:93.75% of 16 +Branches executed:100.00% of 8 +Taken at least once:87.50% of 8 +Calls executed:100.00% of 2 + +Function 'initializeGame' +Lines executed:93.55% of 62 +Branches executed:100.00% of 46 +Taken at least once:89.13% of 46 +Calls executed:100.00% of 5 + +Function 'kingdomCards' +Lines executed:0.00% of 13 +No branches +No calls + +Function 'newGame' +Lines executed:0.00% of 3 +No branches +No calls + +Function 'compare' +Lines executed:83.33% of 6 +Branches executed:100.00% of 4 +Taken at least once:75.00% of 4 +No calls + +File 'dominion.c' +Lines executed:35.51% of 583 +Branches executed:39.61% of 409 +Taken at least once:32.03% of 409 +Calls executed:25.77% of 97 +Creating 'dominion.c.gcov' + + +Begin Testing doMine(): + +Test 1 +Assert failed: Didn't return -1 when trying to trash a curse +Test 2 +Assert failed: Silver not gained to hand +Test 3 +End of doMine() Tests + +Function 'updateCoins' +Lines executed:81.82% of 11 +Branches executed:100.00% of 8 +Taken at least once:75.00% of 8 +No calls + +Function 'gainCard' +Lines executed:61.54% of 13 +Branches executed:100.00% of 6 +Taken at least once:50.00% of 6 +Calls executed:100.00% of 1 + +Function 'discardCard' +Lines executed:92.31% of 13 +Branches executed:100.00% of 6 +Taken at least once:83.33% of 6 +No calls + +Function 'cardEffect' +Lines executed:0.00% of 133 +Branches executed:0.00% of 93 +Taken at least once:0.00% of 93 +Calls executed:0.00% of 44 + +Function 'doAmbassador' +Lines executed:90.00% of 20 +Branches executed:100.00% of 22 +Taken at least once:77.27% of 22 +Calls executed:100.00% of 3 + +Function 'doTribute' +Lines executed:82.14% of 28 +Branches executed:100.00% of 30 +Taken at least once:70.00% of 30 +Calls executed:100.00% of 2 + +Function 'printHand' +Lines executed:0.00% of 6 +Branches executed:0.00% of 2 +Taken at least once:0.00% of 2 +Calls executed:0.00% of 3 + +Function 'printDeck' +Lines executed:0.00% of 6 +Branches executed:0.00% of 2 +Taken at least once:0.00% of 2 +Calls executed:0.00% of 3 + +Function 'doMinion' +Lines executed:100.00% of 17 +Branches executed:100.00% of 16 +Taken at least once:93.75% of 16 +Calls executed:100.00% of 6 + +Function 'doBaron' +Lines executed:100.00% of 22 +Branches executed:100.00% of 10 +Taken at least once:100.00% of 10 +Calls executed:100.00% of 2 + +Function 'getEstateCard' +Lines executed:85.71% of 7 +Branches executed:100.00% of 4 +Taken at least once:50.00% of 4 +Calls executed:75.00% of 4 + +Function 'doMine' +Lines executed:85.71% of 14 +Branches executed:100.00% of 12 +Taken at least once:58.33% of 12 +Calls executed:100.00% of 4 + +Function 'getCost' +Lines executed:16.67% of 30 +Branches executed:100.00% of 28 +Taken at least once:10.71% of 28 +No calls + +Function 'drawCard' +Lines executed:36.36% of 22 +Branches executed:33.33% of 6 +Taken at least once:16.67% of 6 +Calls executed:0.00% of 1 + +Function 'getWinners' +Lines executed:0.00% of 24 +Branches executed:0.00% of 22 +Taken at least once:0.00% of 22 +Calls executed:0.00% of 2 + +Function 'scoreFor' +Lines executed:0.00% of 42 +Branches executed:0.00% of 42 +Taken at least once:0.00% of 42 +Calls executed:0.00% of 3 + +Function 'isGameOver' +Lines executed:0.00% of 10 +Branches executed:0.00% of 8 +Taken at least once:0.00% of 8 +No calls + +Function 'endTurn' +Lines executed:0.00% of 20 +Branches executed:0.00% of 6 +Taken at least once:0.00% of 6 +Calls executed:0.00% of 3 + +Function 'whoseTurn' +Lines executed:100.00% of 2 +No branches +No calls + +Function 'fullDeckCount' +Lines executed:0.00% of 9 +Branches executed:0.00% of 12 +Taken at least once:0.00% of 12 +No calls + +Function 'supplyCount' +Lines executed:100.00% of 2 +No branches +No calls + +Function 'handCard' +Lines executed:0.00% of 3 +No branches +Calls executed:0.00% of 1 + +Function 'numHandCards' +Lines executed:100.00% of 2 +No branches +Calls executed:100.00% of 1 + +Function 'buyCard' +Lines executed:0.00% of 13 +Branches executed:0.00% of 6 +Taken at least once:0.00% of 6 +Calls executed:0.00% of 4 + +Function 'playCard' +Lines executed:0.00% of 14 +Branches executed:0.00% of 10 +Taken at least once:0.00% of 10 +Calls executed:0.00% of 3 + +Function 'shuffle' +Lines executed:93.75% of 16 +Branches executed:100.00% of 8 +Taken at least once:87.50% of 8 +Calls executed:100.00% of 2 + +Function 'initializeGame' +Lines executed:93.55% of 62 +Branches executed:100.00% of 46 +Taken at least once:89.13% of 46 +Calls executed:100.00% of 5 + +Function 'kingdomCards' +Lines executed:0.00% of 13 +No branches +No calls + +Function 'newGame' +Lines executed:0.00% of 3 +No branches +No calls + +Function 'compare' +Lines executed:83.33% of 6 +Branches executed:100.00% of 4 +Taken at least once:75.00% of 4 +No calls + +File 'dominion.c' +Lines executed:38.42% of 583 +Branches executed:49.39% of 409 +Taken at least once:34.47% of 409 +Calls executed:29.90% of 97 +Creating 'dominion.c.gcov' + From f660460f84843e80e5838f249737542114272525 Mon Sep 17 00:00:00 2001 From: zee100100 Date: Wed, 27 Nov 2019 23:33:16 -0800 Subject: [PATCH 06/15] Create hw.c --- projects/alghanmz/aljanahaDominion/hw.c | 1 + 1 file changed, 1 insertion(+) create mode 100644 projects/alghanmz/aljanahaDominion/hw.c diff --git a/projects/alghanmz/aljanahaDominion/hw.c b/projects/alghanmz/aljanahaDominion/hw.c new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/projects/alghanmz/aljanahaDominion/hw.c @@ -0,0 +1 @@ + From 27306b53f6758759dd56d05d2c7c217bbb26c334 Mon Sep 17 00:00:00 2001 From: zee100100 Date: Wed, 27 Nov 2019 23:34:25 -0800 Subject: [PATCH 07/15] Add files via upload --- projects/alghanmz/aljanahaDominion/Makefile | 31 + projects/alghanmz/aljanahaDominion/READM.md | 2 + projects/alghanmz/aljanahaDominion/dominion.c | 1373 +++++++++++++++++ projects/alghanmz/aljanahaDominion/dominion.h | 131 ++ .../aljanahaDominion/dominion_helpers.h | 15 + .../alghanmz/aljanahaDominion/interface.c | 425 +++++ .../alghanmz/aljanahaDominion/interface.h | 128 ++ projects/alghanmz/aljanahaDominion/playdom.c | 135 ++ projects/alghanmz/aljanahaDominion/player.c | 205 +++ projects/alghanmz/aljanahaDominion/rngs.c | 183 +++ projects/alghanmz/aljanahaDominion/rngs.h | 19 + projects/alghanmz/aljanahaDominion/rt.c | 27 + .../alghanmz/aljanahaDominion/testdrawcard.c | 74 + 13 files changed, 2748 insertions(+) create mode 100644 projects/alghanmz/aljanahaDominion/Makefile create mode 100644 projects/alghanmz/aljanahaDominion/READM.md create mode 100644 projects/alghanmz/aljanahaDominion/dominion.c create mode 100644 projects/alghanmz/aljanahaDominion/dominion.h create mode 100644 projects/alghanmz/aljanahaDominion/dominion_helpers.h create mode 100644 projects/alghanmz/aljanahaDominion/interface.c create mode 100644 projects/alghanmz/aljanahaDominion/interface.h create mode 100644 projects/alghanmz/aljanahaDominion/playdom.c create mode 100644 projects/alghanmz/aljanahaDominion/player.c create mode 100644 projects/alghanmz/aljanahaDominion/rngs.c create mode 100644 projects/alghanmz/aljanahaDominion/rngs.h create mode 100644 projects/alghanmz/aljanahaDominion/rt.c create mode 100644 projects/alghanmz/aljanahaDominion/testdrawcard.c diff --git a/projects/alghanmz/aljanahaDominion/Makefile b/projects/alghanmz/aljanahaDominion/Makefile new file mode 100644 index 000000000..5541801f3 --- /dev/null +++ b/projects/alghanmz/aljanahaDominion/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/alghanmz/aljanahaDominion/READM.md b/projects/alghanmz/aljanahaDominion/READM.md new file mode 100644 index 000000000..c3599f6ad --- /dev/null +++ b/projects/alghanmz/aljanahaDominion/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/alghanmz/aljanahaDominion/dominion.c b/projects/alghanmz/aljanahaDominion/dominion.c new file mode 100644 index 000000000..c94e2edb9 --- /dev/null +++ b/projects/alghanmz/aljanahaDominion/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/alghanmz/aljanahaDominion/dominion.h b/projects/alghanmz/aljanahaDominion/dominion.h new file mode 100644 index 000000000..f9d9039b8 --- /dev/null +++ b/projects/alghanmz/aljanahaDominion/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/alghanmz/aljanahaDominion/dominion_helpers.h b/projects/alghanmz/aljanahaDominion/dominion_helpers.h new file mode 100644 index 000000000..0887fda15 --- /dev/null +++ b/projects/alghanmz/aljanahaDominion/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/alghanmz/aljanahaDominion/interface.c b/projects/alghanmz/aljanahaDominion/interface.c new file mode 100644 index 000000000..58cc5ba58 --- /dev/null +++ b/projects/alghanmz/aljanahaDominion/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/alghanmz/aljanahaDominion/interface.h b/projects/alghanmz/aljanahaDominion/interface.h new file mode 100644 index 000000000..6f7bacac2 --- /dev/null +++ b/projects/alghanmz/aljanahaDominion/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/alghanmz/aljanahaDominion/playdom.c b/projects/alghanmz/aljanahaDominion/playdom.c new file mode 100644 index 000000000..336d9a661 --- /dev/null +++ b/projects/alghanmz/aljanahaDominion/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/alghanmz/aljanahaDominion/player.c b/projects/alghanmz/aljanahaDominion/player.c new file mode 100644 index 000000000..0a169d126 --- /dev/null +++ b/projects/alghanmz/aljanahaDominion/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/alghanmz/aljanahaDominion/rngs.c b/projects/alghanmz/aljanahaDominion/rngs.c new file mode 100644 index 000000000..a85bbc961 --- /dev/null +++ b/projects/alghanmz/aljanahaDominion/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/alghanmz/aljanahaDominion/rngs.h b/projects/alghanmz/aljanahaDominion/rngs.h new file mode 100644 index 000000000..c9f3f451a --- /dev/null +++ b/projects/alghanmz/aljanahaDominion/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/alghanmz/aljanahaDominion/rt.c b/projects/alghanmz/aljanahaDominion/rt.c new file mode 100644 index 000000000..5805bb9b4 --- /dev/null +++ b/projects/alghanmz/aljanahaDominion/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/alghanmz/aljanahaDominion/testdrawcard.c b/projects/alghanmz/aljanahaDominion/testdrawcard.c new file mode 100644 index 000000000..da5379646 --- /dev/null +++ b/projects/alghanmz/aljanahaDominion/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 d5b0a63756f19eda7d04a314a3098ed8468a721b Mon Sep 17 00:00:00 2001 From: zee100100 Date: Wed, 27 Nov 2019 23:37:45 -0800 Subject: [PATCH 08/15] Add files via upload --- dominion/Makefile old | 31 + dominion/dominion.c | 518 +++++---- dominion/dominion.c.gcov | 1936 ++++++++++++++++++++++++++++++++ dominion/dominion.gcda | Bin 0 -> 5688 bytes dominion/dominion.gcno | Bin 0 -> 40596 bytes dominion/dominion.o | Bin 0 -> 52256 bytes dominion/randomtestcard1 | Bin 0 -> 62256 bytes dominion/randomtestcard1.gcda | Bin 0 -> 1264 bytes dominion/randomtestcard1.gcno | Bin 0 -> 5328 bytes dominion/randomtestcard2 | Bin 0 -> 62048 bytes dominion/randomtestcard2.gcda | Bin 0 -> 1152 bytes dominion/randomtestcard2.gcno | Bin 0 -> 4968 bytes dominion/randomtestcard3 | Bin 0 -> 62256 bytes dominion/randomtestcard3.gcda | Bin 0 -> 1328 bytes dominion/randomtestcard3.gcno | Bin 0 -> 6336 bytes dominion/randomtestresults.out | 541 +++++++++ dominion/rngs.gcda | Bin 0 -> 2632 bytes dominion/rngs.gcno | Bin 0 -> 4032 bytes dominion/rngs.o | Bin 0 -> 11792 bytes dominion/unittest1 | Bin 0 -> 62248 bytes 20 files changed, 2783 insertions(+), 243 deletions(-) create mode 100644 dominion/Makefile old create mode 100644 dominion/dominion.c.gcov create mode 100644 dominion/dominion.gcda create mode 100644 dominion/dominion.gcno create mode 100644 dominion/dominion.o create mode 100644 dominion/randomtestcard1 create mode 100644 dominion/randomtestcard1.gcda create mode 100644 dominion/randomtestcard1.gcno create mode 100644 dominion/randomtestcard2 create mode 100644 dominion/randomtestcard2.gcda create mode 100644 dominion/randomtestcard2.gcno create mode 100644 dominion/randomtestcard3 create mode 100644 dominion/randomtestcard3.gcda create mode 100644 dominion/randomtestcard3.gcno create mode 100644 dominion/randomtestresults.out create mode 100644 dominion/rngs.gcda create mode 100644 dominion/rngs.gcno create mode 100644 dominion/rngs.o create mode 100644 dominion/unittest1 diff --git a/dominion/Makefile old b/dominion/Makefile old new file mode 100644 index 000000000..5541801f3 --- /dev/null +++ b/dominion/Makefile old @@ -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/dominion/dominion.c b/dominion/dominion.c index c94e2edb9..739e2605e 100644 --- a/dominion/dominion.c +++ b/dominion/dominion.c @@ -681,6 +681,276 @@ int getCost(int cardNumber) return -1; } +int doMine(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) +{ + int i; + int j; + + 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; +} + +void getEstateCard(struct gameState *state, int currentPlayer) +{ + 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); + } + } +} + +void doBaron(int choice1, struct gameState *state, int currentPlayer) +{ + state->numBuys++;//Increase buys by 1! + state->numBuys++;//Increase buys by 1! + if (choice1 > 0) { //Boolean true or going to discard an estate + int p = 1; //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"); + } + getEstateCard(state, currentPlayer); + card_not_discarded = 0;//Exit the loop + } + + else { + p++;//Next card + } + } + } + + else { + getEstateCard(state, currentPlayer); + } +} + +void doMinion(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) +{ + int i; + int j; + + //+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) > 1 /*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); + } + } + } + } + } +} + +void doTribute(struct gameState *state, int currentPlayer, int nextPlayer, int tributeRevealedCards[2]) +{ + int i; + + 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->numActions = state->numActions + 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->coins += 2; + } + } +} + +int doAmbassador(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) +{ + int i; + int j; + + j = 0; //used to check if player has enough cards to discard + + if (choice2 > 3 || 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; +} + int cardEffect(int card, int choice1, int choice2, int choice3, struct gameState *state, int handPos, int *bonus) { int i; @@ -806,39 +1076,7 @@ int cardEffect(int card, int choice1, int choice2, int choice3, struct gameState 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; + return doMine(choice1, choice2, state, handPos, currentPlayer); case remodel: j = state->hand[currentPlayer][choice1]; //store card we will trash @@ -889,56 +1127,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); - } - } - } - - + doBaron(choice1, state, currentPlayer); return 0; case great_hall: @@ -953,53 +1142,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); - } - } - } - } - - } + doMinion(choice1, choice2, state, handPos, currentPlayer); return 0; case steward: @@ -1026,121 +1169,11 @@ 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; - } - } - + doTribute(state, currentPlayer, nextPlayer, tributeRevealedCards); 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; + return doAmbassador(choice1, choice2, state, handPos, currentPlayer); case cutpurse: @@ -1370,4 +1403,3 @@ int updateCoins(int player, struct gameState *state, int bonus) //end of dominion.c - diff --git a/dominion/dominion.c.gcov b/dominion/dominion.c.gcov new file mode 100644 index 000000000..2e0a8d298 --- /dev/null +++ b/dominion/dominion.c.gcov @@ -0,0 +1,1936 @@ + -: 0:Source:dominion.c + -: 0:Graph:dominion.gcno + -: 0:Data:dominion.gcda + -: 0:Runs:3 + -: 0:Programs:3 + -: 1:#include "dominion.h" + -: 2:#include "dominion_helpers.h" + -: 3:#include "rngs.h" + -: 4:#include + -: 5:#include + -: 6:#include + -: 7: +function compare called 93382020 returned 100% blocks executed 100% + 93382020: 8:int compare(const void* a, const void* b) { + 93382020: 9: if (*(int*)a > *(int*)b) +branch 0 taken 1% (fallthrough) +branch 1 taken 99% + 45588: 10: return 1; + 93336432: 11: if (*(int*)a < *(int*)b) +branch 0 taken 27% (fallthrough) +branch 1 taken 73% + 24916392: 12: return -1; + 68420040: 13: return 0; + -: 14:} + -: 15: +function newGame called 0 returned 0% blocks executed 0% + #####: 16:struct gameState* newGame() { + #####: 17: struct gameState* g = malloc(sizeof(struct gameState)); + #####: 18: return g; + -: 19:} + -: 20: +function kingdomCards called 0 returned 0% blocks executed 0% + #####: 21:int* kingdomCards(int k1, int k2, int k3, int k4, int k5, int k6, int k7, + -: 22: int k8, int k9, int k10) { + #####: 23: int* k = malloc(10 * sizeof(int)); + #####: 24: k[0] = k1; + #####: 25: k[1] = k2; + #####: 26: k[2] = k3; + #####: 27: k[3] = k4; + #####: 28: k[4] = k5; + #####: 29: k[5] = k6; + #####: 30: k[6] = k7; + #####: 31: k[7] = k8; + #####: 32: k[8] = k9; + #####: 33: k[9] = k10; + #####: 34: return k; + -: 35:} + -: 36: +function initializeGame called 2073550 returned 100% blocks executed 95% + 2073550: 37:int initializeGame(int numPlayers, int kingdomCards[10], int randomSeed, + -: 38: struct gameState *state) { + -: 39: int i; + -: 40: int j; + -: 41: int it; + -: 42: + -: 43: //set up random number generator + 2073550: 44: SelectStream(1); +call 0 returned 100% + 2073550: 45: PutSeed((long)randomSeed); +call 0 returned 100% + -: 46: + -: 47: //check number of players + 2073550: 48: if (numPlayers > MAX_PLAYERS || numPlayers < 2) +branch 0 taken 100% (fallthrough) +branch 1 taken 0% +branch 2 taken 0% (fallthrough) +branch 3 taken 100% + -: 49: { + #####: 50: return -1; + -: 51: } + -: 52: + -: 53: //set number of players + 2073550: 54: state->numPlayers = numPlayers; + -: 55: + -: 56: //check selected kingdom cards are different + 22809050: 57: for (i = 0; i < 10; i++) +branch 0 taken 91% +branch 1 taken 9% (fallthrough) + -: 58: { +228090500: 59: for (j = 0; j < 10; j++) +branch 0 taken 91% +branch 1 taken 9% (fallthrough) + -: 60: { +207355000: 61: if (j != i && kingdomCards[j] == kingdomCards[i]) +branch 0 taken 90% (fallthrough) +branch 1 taken 10% +branch 2 taken 0% (fallthrough) +branch 3 taken 100% + -: 62: { + #####: 63: return -1; + -: 64: } + -: 65: } + -: 66: } + -: 67: + -: 68: + -: 69: //initialize supply + -: 70: /////////////////////////////// + -: 71: + -: 72: //set number of Curse cards + 2073550: 73: if (numPlayers == 2) +branch 0 taken 33% (fallthrough) +branch 1 taken 67% + -: 74: { + 691948: 75: state->supplyCount[curse] = 10; + -: 76: } + 1381602: 77: else if (numPlayers == 3) +branch 0 taken 50% (fallthrough) +branch 1 taken 50% + -: 78: { + 690892: 79: state->supplyCount[curse] = 20; + -: 80: } + -: 81: else + -: 82: { + 690710: 83: state->supplyCount[curse] = 30; + -: 84: } + -: 85: + -: 86: //set number of Victory cards + 2073550: 87: if (numPlayers == 2) +branch 0 taken 33% (fallthrough) +branch 1 taken 67% + -: 88: { + 691948: 89: state->supplyCount[estate] = 8; + 691948: 90: state->supplyCount[duchy] = 8; + 691948: 91: state->supplyCount[province] = 8; + -: 92: } + -: 93: else + -: 94: { + 1381602: 95: state->supplyCount[estate] = 12; + 1381602: 96: state->supplyCount[duchy] = 12; + 1381602: 97: state->supplyCount[province] = 12; + -: 98: } + -: 99: + -: 100: //set number of Treasure cards + 2073550: 101: state->supplyCount[copper] = 60 - (7 * numPlayers); + 2073550: 102: state->supplyCount[silver] = 40; + 2073550: 103: state->supplyCount[gold] = 30; + -: 104: + -: 105: //set number of Kingdom cards + 43544550: 106: for (i = adventurer; i <= treasure_map; i++) //loop all cards +branch 0 taken 95% +branch 1 taken 5% (fallthrough) + -: 107: { +342135750: 108: for (j = 0; j < 10; j++) //loop chosen cards +branch 0 taken 94% +branch 1 taken 6% (fallthrough) + -: 109: { +321400250: 110: if (kingdomCards[j] == i) +branch 0 taken 6% (fallthrough) +branch 1 taken 94% + -: 111: { + -: 112: //check if card is a 'Victory' Kingdom card + 20735500: 113: if (kingdomCards[j] == great_hall || kingdomCards[j] == gardens) +branch 0 taken 90% (fallthrough) +branch 1 taken 10% +branch 2 taken 11% (fallthrough) +branch 3 taken 89% + -: 114: { + 8294200: 115: if (numPlayers == 2) { +branch 0 taken 33% (fallthrough) +branch 1 taken 67% + 1383896: 116: state->supplyCount[i] = 8; + -: 117: } + -: 118: else { + 2763204: 119: state->supplyCount[i] = 12; + -: 120: } + -: 121: } + -: 122: else + -: 123: { + 16588400: 124: state->supplyCount[i] = 10; + -: 125: } + 20735500: 126: break; + -: 127: } + -: 128: else //card is not in the set choosen for the game + -: 129: { +300664750: 130: state->supplyCount[i] = -1; + -: 131: } + -: 132: } + -: 133: + -: 134: } + -: 135: + -: 136: //////////////////////// + -: 137: //supply intilization complete + -: 138: + -: 139: //set player decks + 8292962: 140: for (i = 0; i < numPlayers; i++) +branch 0 taken 75% +branch 1 taken 25% (fallthrough) + -: 141: { + 6219412: 142: state->deckCount[i] = 0; + 24877648: 143: for (j = 0; j < 3; j++) +branch 0 taken 75% +branch 1 taken 25% (fallthrough) + -: 144: { + 18658236: 145: state->deck[i][j] = estate; + 18658236: 146: state->deckCount[i]++; + -: 147: } + 49755296: 148: for (j = 3; j < 10; j++) +branch 0 taken 88% +branch 1 taken 13% (fallthrough) + -: 149: { + 43535884: 150: state->deck[i][j] = copper; + 43535884: 151: state->deckCount[i]++; + -: 152: } + -: 153: } + -: 154: + -: 155: //shuffle player decks + 8292962: 156: for (i = 0; i < numPlayers; i++) +branch 0 taken 75% +branch 1 taken 25% (fallthrough) + -: 157: { + 6219412: 158: if ( shuffle(i, state) < 0 ) +call 0 returned 100% +branch 1 taken 0% (fallthrough) +branch 2 taken 100% + -: 159: { + #####: 160: return -1; + -: 161: } + -: 162: } + -: 163: + -: 164: //draw player hands + 8292962: 165: for (i = 0; i < numPlayers; i++) +branch 0 taken 75% +branch 1 taken 25% (fallthrough) + -: 166: { + -: 167: //initialize hand size to zero + 6219412: 168: state->handCount[i] = 0; + 6219412: 169: state->discardCount[i] = 0; + -: 170: //draw 5 cards + -: 171: // for (j = 0; j < 5; j++) + -: 172: // { + -: 173: // drawCard(i, state); + -: 174: // } + -: 175: } + -: 176: + -: 177: //set embargo tokens to 0 for all supply piles + 58059400: 178: for (i = 0; i <= treasure_map; i++) +branch 0 taken 96% +branch 1 taken 4% (fallthrough) + -: 179: { + 55985850: 180: state->embargoTokens[i] = 0; + -: 181: } + -: 182: + -: 183: //initialize first player's turn + 2073550: 184: state->outpostPlayed = 0; + 2073550: 185: state->phase = 0; + 2073550: 186: state->numActions = 1; + 2073550: 187: state->numBuys = 1; + 2073550: 188: state->playedCardCount = 0; + 2073550: 189: state->whoseTurn = 0; + 2073550: 190: state->handCount[state->whoseTurn] = 0; + -: 191: //int it; move to top + -: 192: + -: 193: //Moved draw cards to here, only drawing at the start of a turn + 12441300: 194: for (it = 0; it < 5; it++) { +branch 0 taken 83% +branch 1 taken 17% (fallthrough) + 10367750: 195: drawCard(state->whoseTurn, state); +call 0 returned 100% + -: 196: } + -: 197: + 2073550: 198: updateCoins(state->whoseTurn, state, 0); +call 0 returned 100% + -: 199: + 2073550: 200: return 0; + -: 201:} + -: 202: +function shuffle called 6297823 returned 100% blocks executed 94% + 6297823: 203:int shuffle(int player, struct gameState *state) { + -: 204: + -: 205: + -: 206: int newDeck[MAX_DECK]; + 6297823: 207: int newDeckPos = 0; + -: 208: int card; + -: 209: int i; + -: 210: + 6297823: 211: if (state->deckCount[player] < 1) +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + #####: 212: return -1; + 6297823: 213: qsort ((void*)(state->deck[player]), state->deckCount[player], sizeof(int), compare); +call 0 returned 100% + -: 214: /* SORT CARDS IN DECK TO ENSURE DETERMINISM! */ + -: 215: + 74946595: 216: while (state->deckCount[player] > 0) { +branch 0 taken 91% +branch 1 taken 9% (fallthrough) + 62350949: 217: card = floor(Random() * state->deckCount[player]); +call 0 returned 100% + 62350949: 218: newDeck[newDeckPos] = state->deck[player][card]; + 62350949: 219: newDeckPos++; +228253492: 220: for (i = card; i < state->deckCount[player]-1; i++) { +branch 0 taken 73% +branch 1 taken 27% (fallthrough) +165902543: 221: state->deck[player][i] = state->deck[player][i+1]; + -: 222: } + 62350949: 223: state->deckCount[player]--; + -: 224: } + 68648772: 225: for (i = 0; i < newDeckPos; i++) { +branch 0 taken 91% +branch 1 taken 9% (fallthrough) + 62350949: 226: state->deck[player][i] = newDeck[i]; + 62350949: 227: state->deckCount[player]++; + -: 228: } + -: 229: + 6297823: 230: return 0; + -: 231:} + -: 232: +function playCard called 0 returned 0% blocks executed 0% + #####: 233:int playCard(int handPos, int choice1, int choice2, int choice3, struct gameState *state) + -: 234:{ + -: 235: int card; + #####: 236: int coin_bonus = 0; //tracks coins gain from actions + -: 237: + -: 238: //check if it is the right phase + #####: 239: if (state->phase != 0) +branch 0 never executed +branch 1 never executed + -: 240: { + #####: 241: return -1; + -: 242: } + -: 243: + -: 244: //check if player has enough actions + #####: 245: if ( state->numActions < 1 ) +branch 0 never executed +branch 1 never executed + -: 246: { + #####: 247: return -1; + -: 248: } + -: 249: + -: 250: //get card played + #####: 251: card = handCard(handPos, state); +call 0 never executed + -: 252: + -: 253: //check if selected card is an action + #####: 254: if ( card < adventurer || card > treasure_map ) +branch 0 never executed +branch 1 never executed +branch 2 never executed +branch 3 never executed + -: 255: { + #####: 256: return -1; + -: 257: } + -: 258: + -: 259: //play card + #####: 260: if ( cardEffect(card, choice1, choice2, choice3, state, handPos, &coin_bonus) < 0 ) +call 0 never executed +branch 1 never executed +branch 2 never executed + -: 261: { + #####: 262: return -1; + -: 263: } + -: 264: + -: 265: //reduce number of actions + #####: 266: state->numActions--; + -: 267: + -: 268: //update coins (Treasure cards may be added with card draws) + #####: 269: updateCoins(state->whoseTurn, state, coin_bonus); +call 0 never executed + -: 270: + #####: 271: return 0; + -: 272:} + -: 273: +function buyCard called 0 returned 0% blocks executed 0% + #####: 274:int buyCard(int supplyPos, struct gameState *state) { + -: 275: int who; + -: 276: if (DEBUG) { + -: 277: printf("Entering buyCard...\n"); + -: 278: } + -: 279: + -: 280: // I don't know what to do about the phase thing. + -: 281: + #####: 282: who = state->whoseTurn; + -: 283: + #####: 284: if (state->numBuys < 1) { +branch 0 never executed +branch 1 never executed + -: 285: if (DEBUG) + -: 286: printf("You do not have any buys left\n"); + #####: 287: return -1; + #####: 288: } else if (supplyCount(supplyPos, state) <1) { +call 0 never executed +branch 1 never executed +branch 2 never executed + -: 289: if (DEBUG) + -: 290: printf("There are not any of that type of card left\n"); + #####: 291: return -1; + #####: 292: } else if (state->coins < getCost(supplyPos)) { +call 0 never executed +branch 1 never executed +branch 2 never executed + -: 293: if (DEBUG) + -: 294: printf("You do not have enough money to buy that. You have %d coins.\n", state->coins); + #####: 295: return -1; + -: 296: } else { + #####: 297: state->phase=1; + -: 298: //state->supplyCount[supplyPos]--; + #####: 299: gainCard(supplyPos, state, 0, who); //card goes in discard, this might be wrong.. (2 means goes into hand, 0 goes into discard) +call 0 never executed + -: 300: + #####: 301: state->coins = (state->coins) - (getCost(supplyPos)); +call 0 never executed + #####: 302: state->numBuys--; + -: 303: if (DEBUG) + -: 304: 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); + -: 305: } + -: 306: + -: 307: //state->discard[who][state->discardCount[who]] = supplyPos; + -: 308: //state->discardCount[who]++; + -: 309: + #####: 310: return 0; + -: 311:} + -: 312: +function numHandCards called 747834 returned 100% blocks executed 100% + 747834: 313:int numHandCards(struct gameState *state) { + 747834: 314: return state->handCount[ whoseTurn(state) ]; +call 0 returned 100% + -: 315:} + -: 316: +function handCard called 0 returned 0% blocks executed 0% + #####: 317:int handCard(int handPos, struct gameState *state) { + #####: 318: int currentPlayer = whoseTurn(state); +call 0 never executed + #####: 319: return state->hand[currentPlayer][handPos]; + -: 320:} + -: 321: +function supplyCount called 1669227 returned 100% blocks executed 100% + 1669227: 322:int supplyCount(int card, struct gameState *state) { + 1669227: 323: return state->supplyCount[card]; + -: 324:} + -: 325: +function fullDeckCount called 0 returned 0% blocks executed 0% + #####: 326:int fullDeckCount(int player, int card, struct gameState *state) { + -: 327: int i; + #####: 328: int count = 0; + -: 329: + #####: 330: for (i = 0; i < state->deckCount[player]; i++) +branch 0 never executed +branch 1 never executed + -: 331: { + #####: 332: if (state->deck[player][i] == card) count++; +branch 0 never executed +branch 1 never executed + -: 333: } + -: 334: + #####: 335: for (i = 0; i < state->handCount[player]; i++) +branch 0 never executed +branch 1 never executed + -: 336: { + #####: 337: if (state->hand[player][i] == card) count++; +branch 0 never executed +branch 1 never executed + -: 338: } + -: 339: + #####: 340: for (i = 0; i < state->discardCount[player]; i++) +branch 0 never executed +branch 1 never executed + -: 341: { + #####: 342: if (state->discard[player][i] == card) count++; +branch 0 never executed +branch 1 never executed + -: 343: } + -: 344: + #####: 345: return count; + -: 346:} + -: 347: +function whoseTurn called 747834 returned 100% blocks executed 100% + 747834: 348:int whoseTurn(struct gameState *state) { + 747834: 349: return state->whoseTurn; + -: 350:} + -: 351: +function endTurn called 0 returned 0% blocks executed 0% + #####: 352:int endTurn(struct gameState *state) { + -: 353: int k; + -: 354: int i; + #####: 355: int currentPlayer = whoseTurn(state); +call 0 never executed + -: 356: + -: 357: //Discard hand + #####: 358: for (i = 0; i < state->handCount[currentPlayer]; i++) { +branch 0 never executed +branch 1 never executed + #####: 359: state->discard[currentPlayer][state->discardCount[currentPlayer]++] = state->hand[currentPlayer][i];//Discard + #####: 360: state->hand[currentPlayer][i] = -1;//Set card to -1 + -: 361: } + #####: 362: state->handCount[currentPlayer] = 0;//Reset hand count + -: 363: + -: 364: //Code for determining the player + #####: 365: if (currentPlayer < (state->numPlayers - 1)) { +branch 0 never executed +branch 1 never executed + #####: 366: state->whoseTurn = currentPlayer + 1;//Still safe to increment + -: 367: } + -: 368: else { + #####: 369: state->whoseTurn = 0;//Max player has been reached, loop back around to player 1 + -: 370: } + -: 371: + #####: 372: state->outpostPlayed = 0; + #####: 373: state->phase = 0; + #####: 374: state->numActions = 1; + #####: 375: state->coins = 0; + #####: 376: state->numBuys = 1; + #####: 377: state->playedCardCount = 0; + #####: 378: state->handCount[state->whoseTurn] = 0; + -: 379: + -: 380: //int k; move to top + -: 381: //Next player draws hand + #####: 382: for (k = 0; k < 5; k++) { +branch 0 never executed +branch 1 never executed + #####: 383: drawCard(state->whoseTurn, state);//Draw a card +call 0 never executed + -: 384: } + -: 385: + -: 386: //Update money + #####: 387: updateCoins(state->whoseTurn, state, 0); +call 0 never executed + -: 388: + #####: 389: return 0; + -: 390:} + -: 391: +function isGameOver called 0 returned 0% blocks executed 0% + #####: 392:int isGameOver(struct gameState *state) { + -: 393: int i; + -: 394: int j; + -: 395: + -: 396: //if stack of Province cards is empty, the game ends + #####: 397: if (state->supplyCount[province] == 0) +branch 0 never executed +branch 1 never executed + -: 398: { + #####: 399: return 1; + -: 400: } + -: 401: + -: 402: //if three supply pile are at 0, the game ends + #####: 403: j = 0; + #####: 404: for (i = 0; i < 25; i++) +branch 0 never executed +branch 1 never executed + -: 405: { + #####: 406: if (state->supplyCount[i] == 0) +branch 0 never executed +branch 1 never executed + -: 407: { + #####: 408: j++; + -: 409: } + -: 410: } + #####: 411: if ( j >= 3) +branch 0 never executed +branch 1 never executed + -: 412: { + #####: 413: return 1; + -: 414: } + -: 415: + #####: 416: return 0; + -: 417:} + -: 418: +function scoreFor called 0 returned 0% blocks executed 0% + #####: 419:int scoreFor (int player, struct gameState *state) { + -: 420: + -: 421: int i; + #####: 422: int score = 0; + -: 423: //score from hand + #####: 424: for (i = 0; i < state->handCount[player]; i++) +branch 0 never executed +branch 1 never executed + -: 425: { + #####: 426: if (state->hand[player][i] == curse) { +branch 0 never executed +branch 1 never executed + #####: 427: score = score - 1; + -: 428: }; + #####: 429: if (state->hand[player][i] == estate) { +branch 0 never executed +branch 1 never executed + #####: 430: score = score + 1; + -: 431: }; + #####: 432: if (state->hand[player][i] == duchy) { +branch 0 never executed +branch 1 never executed + #####: 433: score = score + 3; + -: 434: }; + #####: 435: if (state->hand[player][i] == province) { +branch 0 never executed +branch 1 never executed + #####: 436: score = score + 6; + -: 437: }; + #####: 438: if (state->hand[player][i] == great_hall) { +branch 0 never executed +branch 1 never executed + #####: 439: score = score + 1; + -: 440: }; + #####: 441: if (state->hand[player][i] == gardens) { +branch 0 never executed +branch 1 never executed + #####: 442: score = score + ( fullDeckCount(player, 0, state) / 10 ); +call 0 never executed + -: 443: }; + -: 444: } + -: 445: + -: 446: //score from discard + #####: 447: for (i = 0; i < state->discardCount[player]; i++) +branch 0 never executed +branch 1 never executed + -: 448: { + #####: 449: if (state->discard[player][i] == curse) { +branch 0 never executed +branch 1 never executed + #####: 450: score = score - 1; + -: 451: }; + #####: 452: if (state->discard[player][i] == estate) { +branch 0 never executed +branch 1 never executed + #####: 453: score = score + 1; + -: 454: }; + #####: 455: if (state->discard[player][i] == duchy) { +branch 0 never executed +branch 1 never executed + #####: 456: score = score + 3; + -: 457: }; + #####: 458: if (state->discard[player][i] == province) { +branch 0 never executed +branch 1 never executed + #####: 459: score = score + 6; + -: 460: }; + #####: 461: if (state->discard[player][i] == great_hall) { +branch 0 never executed +branch 1 never executed + #####: 462: score = score + 1; + -: 463: }; + #####: 464: if (state->discard[player][i] == gardens) { +branch 0 never executed +branch 1 never executed + #####: 465: score = score + ( fullDeckCount(player, 0, state) / 10 ); +call 0 never executed + -: 466: }; + -: 467: } + -: 468: + -: 469: //score from deck + #####: 470: for (i = 0; i < state->discardCount[player]; i++) +branch 0 never executed +branch 1 never executed + -: 471: { + #####: 472: if (state->deck[player][i] == curse) { +branch 0 never executed +branch 1 never executed + #####: 473: score = score - 1; + -: 474: }; + #####: 475: if (state->deck[player][i] == estate) { +branch 0 never executed +branch 1 never executed + #####: 476: score = score + 1; + -: 477: }; + #####: 478: if (state->deck[player][i] == duchy) { +branch 0 never executed +branch 1 never executed + #####: 479: score = score + 3; + -: 480: }; + #####: 481: if (state->deck[player][i] == province) { +branch 0 never executed +branch 1 never executed + #####: 482: score = score + 6; + -: 483: }; + #####: 484: if (state->deck[player][i] == great_hall) { +branch 0 never executed +branch 1 never executed + #####: 485: score = score + 1; + -: 486: }; + #####: 487: if (state->deck[player][i] == gardens) { +branch 0 never executed +branch 1 never executed + #####: 488: score = score + ( fullDeckCount(player, 0, state) / 10 ); +call 0 never executed + -: 489: }; + -: 490: } + -: 491: + #####: 492: return score; + -: 493:} + -: 494: +function getWinners called 0 returned 0% blocks executed 0% + #####: 495:int getWinners(int players[MAX_PLAYERS], struct gameState *state) { + -: 496: int i; + -: 497: int j; + -: 498: int highScore; + -: 499: int currentPlayer; + -: 500: + -: 501: //get score for each player + #####: 502: for (i = 0; i < MAX_PLAYERS; i++) +branch 0 never executed +branch 1 never executed + -: 503: { + -: 504: //set unused player scores to -9999 + #####: 505: if (i >= state->numPlayers) +branch 0 never executed +branch 1 never executed + -: 506: { + #####: 507: players[i] = -9999; + -: 508: } + -: 509: else + -: 510: { + #####: 511: players[i] = scoreFor (i, state); +call 0 never executed + -: 512: } + -: 513: } + -: 514: + -: 515: //find highest score + #####: 516: j = 0; + #####: 517: for (i = 0; i < MAX_PLAYERS; i++) +branch 0 never executed +branch 1 never executed + -: 518: { + #####: 519: if (players[i] > players[j]) +branch 0 never executed +branch 1 never executed + -: 520: { + #####: 521: j = i; + -: 522: } + -: 523: } + #####: 524: highScore = players[j]; + -: 525: + -: 526: //add 1 to players who had less turns + #####: 527: currentPlayer = whoseTurn(state); +call 0 never executed + #####: 528: for (i = 0; i < MAX_PLAYERS; i++) +branch 0 never executed +branch 1 never executed + -: 529: { + #####: 530: if ( players[i] == highScore && i > currentPlayer ) +branch 0 never executed +branch 1 never executed +branch 2 never executed +branch 3 never executed + -: 531: { + #####: 532: players[i]++; + -: 533: } + -: 534: } + -: 535: + -: 536: //find new highest score + #####: 537: j = 0; + #####: 538: for (i = 0; i < MAX_PLAYERS; i++) +branch 0 never executed +branch 1 never executed + -: 539: { + #####: 540: if ( players[i] > players[j] ) +branch 0 never executed +branch 1 never executed + -: 541: { + #####: 542: j = i; + -: 543: } + -: 544: } + #####: 545: highScore = players[j]; + -: 546: + -: 547: //set winners in array to 1 and rest to 0 + #####: 548: for (i = 0; i < MAX_PLAYERS; i++) +branch 0 never executed +branch 1 never executed + -: 549: { + #####: 550: if ( players[i] == highScore ) +branch 0 never executed +branch 1 never executed + -: 551: { + #####: 552: players[i] = 1; + -: 553: } + -: 554: else + -: 555: { + #####: 556: players[i] = 0; + -: 557: } + -: 558: } + -: 559: + #####: 560: return 0; + -: 561:} + -: 562: +function drawCard called 15673140 returned 100% blocks executed 38% + 15673140: 563:int drawCard(int player, struct gameState *state) + -: 564:{ int count; + -: 565: int deckCounter; + 15673140: 566: if (state->deckCount[player] <= 0) { //Deck is empty +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + -: 567: + -: 568: //Step 1 Shuffle the discard pile back into a deck + -: 569: int i; + -: 570: //Move discard to deck + #####: 571: for (i = 0; i < state->discardCount[player]; i++) { +branch 0 never executed +branch 1 never executed + #####: 572: state->deck[player][i] = state->discard[player][i]; + #####: 573: state->discard[player][i] = -1; + -: 574: } + -: 575: + #####: 576: state->deckCount[player] = state->discardCount[player]; + #####: 577: state->discardCount[player] = 0;//Reset discard + -: 578: + -: 579: //Shufffle the deck + #####: 580: shuffle(player, state);//Shuffle the deck up and make it so that we can draw +call 0 never executed + -: 581: + -: 582: if (DEBUG) { //Debug statements + -: 583: printf("Deck count now: %d\n", state->deckCount[player]); + -: 584: } + -: 585: + #####: 586: state->discardCount[player] = 0; + -: 587: + -: 588: //Step 2 Draw Card + #####: 589: count = state->handCount[player];//Get current player's hand count + -: 590: + -: 591: if (DEBUG) { //Debug statements + -: 592: printf("Current hand count: %d\n", count); + -: 593: } + -: 594: + #####: 595: deckCounter = state->deckCount[player];//Create a holder for the deck count + -: 596: + #####: 597: if (deckCounter == 0) +branch 0 never executed +branch 1 never executed + #####: 598: return -1; + -: 599: + #####: 600: state->hand[player][count] = state->deck[player][deckCounter - 1];//Add card to hand + #####: 601: state->deckCount[player]--; + #####: 602: state->handCount[player]++;//Increment hand count + -: 603: } + -: 604: + -: 605: else { + 15673140: 606: int count = state->handCount[player];//Get current hand count for player + -: 607: int deckCounter; + -: 608: if (DEBUG) { //Debug statements + -: 609: printf("Current hand count: %d\n", count); + -: 610: } + -: 611: + 15673140: 612: deckCounter = state->deckCount[player];//Create holder for the deck count + 15673140: 613: state->hand[player][count] = state->deck[player][deckCounter - 1];//Add card to the hand + 15673140: 614: state->deckCount[player]--; + 15673140: 615: state->handCount[player]++;//Increment hand count + -: 616: } + -: 617: + 15673140: 618: return 0; + -: 619:} + -: 620: +function getCost called 0 returned 0% blocks executed 0% + #####: 621:int getCost(int cardNumber) + -: 622:{ + #####: 623: switch( cardNumber ) +branch 0 never executed +branch 1 never executed +branch 2 never executed +branch 3 never executed +branch 4 never executed +branch 5 never executed +branch 6 never executed +branch 7 never executed +branch 8 never executed +branch 9 never executed +branch 10 never executed +branch 11 never executed +branch 12 never executed +branch 13 never executed +branch 14 never executed +branch 15 never executed +branch 16 never executed +branch 17 never executed +branch 18 never executed +branch 19 never executed +branch 20 never executed +branch 21 never executed +branch 22 never executed +branch 23 never executed +branch 24 never executed +branch 25 never executed +branch 26 never executed +branch 27 never executed + -: 624: { + -: 625: case curse: + #####: 626: return 0; + -: 627: case estate: + #####: 628: return 2; + -: 629: case duchy: + #####: 630: return 5; + -: 631: case province: + #####: 632: return 8; + -: 633: case copper: + #####: 634: return 0; + -: 635: case silver: + #####: 636: return 3; + -: 637: case gold: + #####: 638: return 6; + -: 639: case adventurer: + #####: 640: return 6; + -: 641: case council_room: + #####: 642: return 5; + -: 643: case feast: + #####: 644: return 4; + -: 645: case gardens: + #####: 646: return 4; + -: 647: case mine: + #####: 648: return 5; + -: 649: case remodel: + #####: 650: return 4; + -: 651: case smithy: + #####: 652: return 4; + -: 653: case village: + #####: 654: return 3; + -: 655: case baron: + #####: 656: return 4; + -: 657: case great_hall: + #####: 658: return 3; + -: 659: case minion: + #####: 660: return 5; + -: 661: case steward: + #####: 662: return 3; + -: 663: case tribute: + #####: 664: return 5; + -: 665: case ambassador: + #####: 666: return 3; + -: 667: case cutpurse: + #####: 668: return 4; + -: 669: case embargo: + #####: 670: return 2; + -: 671: case outpost: + #####: 672: return 5; + -: 673: case salvager: + #####: 674: return 4; + -: 675: case sea_hag: + #####: 676: return 4; + -: 677: case treasure_map: + #####: 678: return 4; + -: 679: } + -: 680: + #####: 681: return -1; + -: 682:} + -: 683: +function doMine called 0 returned 0% blocks executed 0% + #####: 684:int doMine(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) + -: 685:{ + -: 686: int i; + -: 687: int j; + -: 688: + #####: 689: j = state->hand[currentPlayer][choice1]; //store card we will trash + -: 690: + #####: 691: if (/*state->hand[currentPlayer][choice1] < copper ||*/ state->hand[currentPlayer][choice1] > gold) +branch 0 never executed +branch 1 never executed + -: 692: { + #####: 693: return -1; + -: 694: } + -: 695: + #####: 696: if (choice2 > treasure_map || choice2 < curse) +branch 0 never executed +branch 1 never executed +branch 2 never executed +branch 3 never executed + -: 697: { + #####: 698: return -1; + -: 699: } + -: 700: + #####: 701: if ( (getCost(state->hand[currentPlayer][choice1]) + 3) > getCost(choice2) ) +call 0 never executed +call 1 never executed +branch 2 never executed +branch 3 never executed + -: 702: { + #####: 703: return -1; + -: 704: } + -: 705: + -: 706: //gainCard(choice2, state, 2, currentPlayer); + -: 707: + -: 708: //discard card from hand + #####: 709: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + -: 710: + -: 711: //discard trashed card + #####: 712: for (i = 0; i < state->handCount[currentPlayer]; i++) +branch 0 never executed +branch 1 never executed + -: 713: { + #####: 714: if (state->hand[currentPlayer][i] == j) +branch 0 never executed +branch 1 never executed + -: 715: { + #####: 716: discardCard(i, currentPlayer, state, 0); +call 0 never executed + #####: 717: break; + -: 718: } + -: 719: } + -: 720: + #####: 721: return 0; + -: 722:} + -: 723: +function getEstateCard called 556409 returned 100% blocks executed 86% + 556409: 724:void getEstateCard(struct gameState *state, int currentPlayer) + -: 725:{ + 556409: 726: if (supplyCount(estate, state) > 0) { +call 0 returned 100% +branch 1 taken 100% (fallthrough) +branch 2 taken 0% + 556409: 727: gainCard(estate, state, 0, currentPlayer);//Gain an estate +call 0 returned 100% + -: 728: + 556409: 729: state->supplyCount[estate]--;//Decrement Estates + 556409: 730: if (supplyCount(estate, state) == 0) { +call 0 returned 100% +branch 1 taken 0% (fallthrough) +branch 2 taken 100% + #####: 731: isGameOver(state); +call 0 never executed + -: 732: } + -: 733: } + 556409: 734:} + -: 735: +function doBaron called 647059 returned 100% blocks executed 100% + 647059: 736:void doBaron(int choice1, struct gameState *state, int currentPlayer) + -: 737:{ + 647059: 738: state->numBuys++;//Increase buys by 1! + 647059: 739: state->numBuys++;//Increase buys by 1! + 647059: 740: if (choice1 > 0) { //Boolean true or going to discard an estate +branch 0 taken 50% (fallthrough) +branch 1 taken 50% + 322771: 741: int p = 1; //0;//Iterator for hand! + 322771: 742: int card_not_discarded = 1;//Flag for discard set! + 1333592: 743: while(card_not_discarded) { +branch 0 taken 68% +branch 1 taken 32% (fallthrough) + 688050: 744: if (state->hand[currentPlayer][p] == estate) { //Found an estate card! +branch 0 taken 13% (fallthrough) +branch 1 taken 87% + 90650: 745: state->coins += 4;//Add 4 coins to the amount of coins + 90650: 746: state->discard[currentPlayer][state->discardCount[currentPlayer]] = state->hand[currentPlayer][p]; + 90650: 747: state->discardCount[currentPlayer]++; + 247791: 748: for (; p < state->handCount[currentPlayer]; p++) { +branch 0 taken 63% +branch 1 taken 37% (fallthrough) + 157141: 749: state->hand[currentPlayer][p] = state->hand[currentPlayer][p+1]; + -: 750: } + 90650: 751: state->hand[currentPlayer][state->handCount[currentPlayer]] = -1; + 90650: 752: state->handCount[currentPlayer]--; + 90650: 753: card_not_discarded = 0;//Exit the loop + -: 754: } + 597400: 755: else if (p > state->handCount[currentPlayer]) { +branch 0 taken 39% (fallthrough) +branch 1 taken 61% + -: 756: if(DEBUG) { + -: 757: printf("No estate cards in your hand, invalid choice\n"); + -: 758: printf("Must gain an estate if there are any\n"); + -: 759: } + 232121: 760: getEstateCard(state, currentPlayer); +call 0 returned 100% + 232121: 761: card_not_discarded = 0;//Exit the loop + -: 762: } + -: 763: + -: 764: else { + 365279: 765: p++;//Next card + -: 766: } + -: 767: } + -: 768: } + -: 769: + -: 770: else { + 324288: 771: getEstateCard(state, currentPlayer); +call 0 returned 100% + -: 772: } + 647059: 773:} + -: 774: +function doMinion called 720681 returned 100% blocks executed 100% + 720681: 775:void doMinion(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) + -: 776:{ + -: 777: int i; + -: 778: int j; + -: 779: + -: 780: //+1 action + 720681: 781: state->numActions++; + -: 782: + -: 783: //discard card from hand + 720681: 784: discardCard(handPos, currentPlayer, state, 0); +call 0 returned 100% + -: 785: + 720681: 786: if (choice1) +branch 0 taken 50% (fallthrough) +branch 1 taken 50% + -: 787: { + 361452: 788: state->coins = state->coins + 2; + -: 789: } + 359229: 790: else if (choice2) //discard hand, redraw 4, other players with 5+ cards discard hand and draw 4 +branch 0 taken 100% (fallthrough) +branch 1 taken 0% + -: 791: { + -: 792: //discard hand + 1107063: 793: while(numHandCards(state) > 1 /*0*/) +call 0 returned 100% +branch 1 taken 52% +branch 2 taken 48% (fallthrough) + -: 794: { + 388605: 795: discardCard(handPos, currentPlayer, state, 0); +call 0 returned 100% + -: 796: } + -: 797: + -: 798: //draw 4 + 1796145: 799: for (i = 0; i < 4; i++) +branch 0 taken 80% +branch 1 taken 20% (fallthrough) + -: 800: { + 1436916: 801: drawCard(currentPlayer, state); +call 0 returned 100% + -: 802: } + -: 803: + -: 804: //other players discard hand and redraw if hand size > 4 + 1436917: 805: for (i = 0; i < state->numPlayers; i++) +branch 0 taken 75% +branch 1 taken 25% (fallthrough) + -: 806: { + 1077688: 807: if (i != currentPlayer) +branch 0 taken 67% (fallthrough) +branch 1 taken 33% + -: 808: { + -: 809: //if ( state->handCount[i] > 4 ) + -: 810: { + -: 811: //discard hand + 4671315: 812: while( state->handCount[i] > 0 ) +branch 0 taken 82% +branch 1 taken 18% (fallthrough) + -: 813: { + 3234397: 814: discardCard(handPos, i, state, 0); +call 0 returned 100% + -: 815: } + -: 816: + -: 817: //draw 4 + 3592295: 818: for (j = 0; j < 4; j++) +branch 0 taken 80% +branch 1 taken 20% (fallthrough) + -: 819: { + 2873836: 820: drawCard(i, state); +call 0 returned 100% + -: 821: } + -: 822: } + -: 823: } + -: 824: } + -: 825: } + 720681: 826:} + -: 827: +function doTribute called 705810 returned 100% blocks executed 100% + 705810: 828:void doTribute(struct gameState *state, int currentPlayer, int nextPlayer, int tributeRevealedCards[2]) + -: 829:{ + -: 830: int i; + -: 831: + 705810: 832: if ((state->discardCount[nextPlayer] + state->deckCount[nextPlayer]) <= 1) { +branch 0 taken 8% (fallthrough) +branch 1 taken 92% + 58992: 833: if (state->deckCount[nextPlayer] > 0) { +branch 0 taken 33% (fallthrough) +branch 1 taken 67% + 19584: 834: tributeRevealedCards[0] = state->deck[nextPlayer][state->deckCount[nextPlayer]-1]; + 19584: 835: state->deckCount[nextPlayer]--; + -: 836: } + 39408: 837: else if (state->discardCount[nextPlayer] > 0) { +branch 0 taken 50% (fallthrough) +branch 1 taken 50% + 19581: 838: tributeRevealedCards[0] = state->discard[nextPlayer][state->discardCount[nextPlayer]-1]; + 19581: 839: state->discardCount[nextPlayer]--; + -: 840: } + -: 841: else { + -: 842: //No Card to Reveal + -: 843: if (DEBUG) { + -: 844: printf("No cards to reveal\n"); + -: 845: } + -: 846: } + -: 847: } + -: 848: + -: 849: else { + 646818: 850: if (state->deckCount[nextPlayer] == 0) { +branch 0 taken 12% (fallthrough) +branch 1 taken 88% + 235240: 851: for (i = 0; i < state->discardCount[nextPlayer]; i++) { +branch 0 taken 67% +branch 1 taken 33% (fallthrough) + 156829: 852: state->deck[nextPlayer][i] = state->discard[nextPlayer][i];//Move to deck + 156829: 853: state->deckCount[nextPlayer]++; + 156829: 854: state->discard[nextPlayer][i] = -1; + 156829: 855: state->discardCount[nextPlayer]--; + -: 856: } + -: 857: + 78411: 858: shuffle(nextPlayer,state);//Shuffle the deck +call 0 returned 100% + -: 859: } + 646818: 860: tributeRevealedCards[0] = state->deck[nextPlayer][state->deckCount[nextPlayer]-1]; + 646818: 861: state->deck[nextPlayer][state->deckCount[nextPlayer]--] = -1; + 646818: 862: state->deckCount[nextPlayer]--; + 646818: 863: tributeRevealedCards[1] = state->deck[nextPlayer][state->deckCount[nextPlayer]-1]; + 646818: 864: state->deck[nextPlayer][state->deckCount[nextPlayer]--] = -1; + 646818: 865: state->deckCount[nextPlayer]--; + -: 866: } + -: 867: + 705810: 868: if (tributeRevealedCards[0] == tributeRevealedCards[1]) { //If we have a duplicate card, just drop one +branch 0 taken 7% (fallthrough) +branch 1 taken 93% + 46711: 869: state->playedCards[state->playedCardCount] = tributeRevealedCards[1]; + 46711: 870: state->playedCardCount++; + 46711: 871: tributeRevealedCards[1] = -1; + -: 872: } + -: 873: + 2823240: 874: for (i = 0; i <= 2; i ++) { +branch 0 taken 75% +branch 1 taken 25% (fallthrough) + 2117430: 875: if (tributeRevealedCards[i] == copper || tributeRevealedCards[i] == silver || tributeRevealedCards[i] == gold) { //Treasure cards +branch 0 taken 97% (fallthrough) +branch 1 taken 3% +branch 2 taken 96% (fallthrough) +branch 3 taken 4% +branch 4 taken 4% (fallthrough) +branch 5 taken 96% + 216627: 876: state->numActions = state->numActions + 2; + -: 877: } + -: 878: + 1900803: 879: else if (tributeRevealedCards[i] == estate || tributeRevealedCards[i] == duchy || tributeRevealedCards[i] == province || tributeRevealedCards[i] == gardens || tributeRevealedCards[i] == great_hall) { //Victory Card Found +branch 0 taken 96% (fallthrough) +branch 1 taken 4% +branch 2 taken 96% (fallthrough) +branch 3 taken 4% +branch 4 taken 56% (fallthrough) +branch 5 taken 44% +branch 6 taken 93% (fallthrough) +branch 7 taken 7% +branch 8 taken 0% (fallthrough) +branch 9 taken 100% + 994638: 880: drawCard(currentPlayer, state); +call 0 returned 100% + -: 881: //drawCard(currentPlayer, state); + -: 882: } + -: 883: else { //Action Card + 906165: 884: state->coins += 2; + -: 885: } + -: 886: } + 705810: 887:} + -: 888: +function doAmbassador called 0 returned 0% blocks executed 0% + #####: 889:int doAmbassador(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) + -: 890:{ + -: 891: int i; + -: 892: int j; + -: 893: + #####: 894: j = 0; //used to check if player has enough cards to discard + -: 895: + #####: 896: if (choice2 > 3 || choice2 < 0) +branch 0 never executed +branch 1 never executed +branch 2 never executed +branch 3 never executed + -: 897: { + #####: 898: return -1; + -: 899: } + -: 900: + -: 901:/* + -: 902: if (choice1 == handPos) + -: 903: { + -: 904: return -1; + -: 905: } + -: 906: */ + -: 907: + #####: 908: for (i = 0; i < state->handCount[currentPlayer]; i++) +branch 0 never executed +branch 1 never executed + -: 909: { + #####: 910: if (i != handPos && i == state->hand[currentPlayer][choice1] && i != choice1) +branch 0 never executed +branch 1 never executed +branch 2 never executed +branch 3 never executed +branch 4 never executed +branch 5 never executed + -: 911: { + #####: 912: j++; + -: 913: } + -: 914: } + #####: 915: if (j < choice2) +branch 0 never executed +branch 1 never executed + -: 916: { + #####: 917: return -1; + -: 918: } + -: 919: + -: 920: if (DEBUG) + -: 921: printf("Player %d reveals card number: %d\n", currentPlayer, state->hand[currentPlayer][choice1]); + -: 922: + -: 923: //increase supply count for choosen card by amount being discarded + #####: 924: state->supplyCount[state->hand[currentPlayer][choice1]] += choice2; + -: 925: + -: 926: //each other player gains a copy of revealed card + #####: 927: for (i = 0; i < state->numPlayers; i++) +branch 0 never executed +branch 1 never executed + -: 928: { + #####: 929: if (i != currentPlayer) +branch 0 never executed +branch 1 never executed + -: 930: { + #####: 931: gainCard(state->hand[currentPlayer][choice1], state, 0, i); +call 0 never executed + -: 932: } + -: 933: } + -: 934: + -: 935: //discard played card from hand + #####: 936: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + -: 937: + -: 938: //trash copies of cards returned to supply + #####: 939: for (j = 0; j < choice2; j++) +branch 0 never executed +branch 1 never executed + -: 940: { + #####: 941: for (i = 0; i < state->handCount[currentPlayer]; i++) +branch 0 never executed +branch 1 never executed + -: 942: { + #####: 943: if (state->hand[currentPlayer][i] == state->hand[currentPlayer][choice1]) +branch 0 never executed +branch 1 never executed + -: 944: { + #####: 945: discardCard(i, currentPlayer, state, 1); +call 0 never executed + #####: 946: break; + -: 947: } + -: 948: } + -: 949: } + -: 950: + #####: 951: return 0; + -: 952:} + -: 953: +function cardEffect called 0 returned 0% blocks executed 0% + #####: 954:int cardEffect(int card, int choice1, int choice2, int choice3, struct gameState *state, int handPos, int *bonus) + -: 955:{ + -: 956: int i; + -: 957: int j; + -: 958: int k; + -: 959: int x; + -: 960: int index; + #####: 961: int currentPlayer = whoseTurn(state); +call 0 never executed + #####: 962: int nextPlayer = currentPlayer + 1; + -: 963: + #####: 964: int tributeRevealedCards[2] = {-1, -1}; + -: 965: int temphand[MAX_HAND];// moved above the if statement + #####: 966: int drawntreasure=0; + -: 967: int cardDrawn; + #####: 968: int z = 0;// this is the counter for the temp hand + #####: 969: if (nextPlayer > (state->numPlayers - 1)) { +branch 0 never executed +branch 1 never executed + #####: 970: nextPlayer = 0; + -: 971: } + -: 972: + -: 973: + -: 974: //uses switch to select card and perform actions + #####: 975: switch( card ) +branch 0 never executed +branch 1 never executed +branch 2 never executed +branch 3 never executed +branch 4 never executed +branch 5 never executed +branch 6 never executed +branch 7 never executed +branch 8 never executed +branch 9 never executed +branch 10 never executed +branch 11 never executed +branch 12 never executed +branch 13 never executed +branch 14 never executed +branch 15 never executed +branch 16 never executed +branch 17 never executed +branch 18 never executed +branch 19 never executed +branch 20 never executed + -: 976: { + -: 977: case adventurer: + #####: 978: while(drawntreasure<2) { +branch 0 never executed +branch 1 never executed + #####: 979: if (state->deckCount[currentPlayer] <1) { //if the deck is empty we need to shuffle discard and add to deck +branch 0 never executed +branch 1 never executed + #####: 980: shuffle(currentPlayer, state); +call 0 never executed + -: 981: } + #####: 982: drawCard(currentPlayer, state); +call 0 never executed + #####: 983: cardDrawn = state->hand[currentPlayer][state->handCount[currentPlayer]-1];//top card of hand is most recently drawn card. + #####: 984: if (cardDrawn == copper || cardDrawn == silver || cardDrawn == gold) +branch 0 never executed +branch 1 never executed +branch 2 never executed +branch 3 never executed +branch 4 never executed +branch 5 never executed + #####: 985: drawntreasure++; + -: 986: else { + #####: 987: temphand[z]=cardDrawn; + #####: 988: state->handCount[currentPlayer]--; //this should just remove the top card (the most recently drawn one). + #####: 989: z++; + -: 990: } + -: 991: } + #####: 992: while(z-1>=0) { +branch 0 never executed +branch 1 never executed + #####: 993: state->discard[currentPlayer][state->discardCount[currentPlayer]++]=temphand[z-1]; // discard all cards in play that have been drawn + #####: 994: z=z-1; + -: 995: } + #####: 996: return 0; + -: 997: + -: 998: case council_room: + -: 999: //+4 Cards + #####: 1000: for (i = 0; i < 4; i++) +branch 0 never executed +branch 1 never executed + -: 1001: { + #####: 1002: drawCard(currentPlayer, state); +call 0 never executed + -: 1003: } + -: 1004: + -: 1005: //+1 Buy + #####: 1006: state->numBuys++; + -: 1007: + -: 1008: //Each other player draws a card + #####: 1009: for (i = 0; i < state->numPlayers; i++) +branch 0 never executed +branch 1 never executed + -: 1010: { + #####: 1011: if ( i != currentPlayer ) +branch 0 never executed +branch 1 never executed + -: 1012: { + #####: 1013: drawCard(i, state); +call 0 never executed + -: 1014: } + -: 1015: } + -: 1016: + -: 1017: //put played card in played card pile + #####: 1018: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + -: 1019: + #####: 1020: return 0; + -: 1021: + -: 1022: case feast: + -: 1023: //gain card with cost up to 5 + -: 1024: //Backup hand + #####: 1025: for (i = 0; i <= state->handCount[currentPlayer]; i++) { +branch 0 never executed +branch 1 never executed + #####: 1026: temphand[i] = state->hand[currentPlayer][i];//Backup card + #####: 1027: state->hand[currentPlayer][i] = -1;//Set to nothing + -: 1028: } + -: 1029: //Backup hand + -: 1030: + -: 1031: //Update Coins for Buy + #####: 1032: updateCoins(currentPlayer, state, 5); +call 0 never executed + #####: 1033: x = 1;//Condition to loop on + #####: 1034: while( x == 1) {//Buy one card +branch 0 never executed +branch 1 never executed + #####: 1035: if (supplyCount(choice1, state) <= 0) { +call 0 never executed +branch 1 never executed +branch 2 never executed + -: 1036: if (DEBUG) + -: 1037: printf("None of that card left, sorry!\n"); + -: 1038: + -: 1039: if (DEBUG) { + -: 1040: printf("Cards Left: %d\n", supplyCount(choice1, state)); + -: 1041: } + -: 1042: } + #####: 1043: else if (state->coins < getCost(choice1)) { +call 0 never executed +branch 1 never executed +branch 2 never executed + #####: 1044: printf("That card is too expensive!\n"); +call 0 never executed + -: 1045: + -: 1046: if (DEBUG) { + -: 1047: printf("Coins: %d < %d\n", state->coins, getCost(choice1)); + -: 1048: } + -: 1049: } + -: 1050: else { + -: 1051: + -: 1052: if (DEBUG) { + -: 1053: printf("Deck Count: %d\n", state->handCount[currentPlayer] + state->deckCount[currentPlayer] + state->discardCount[currentPlayer]); + -: 1054: } + -: 1055: + #####: 1056: gainCard(choice1, state, 0, currentPlayer);//Gain the card +call 0 never executed + #####: 1057: x = 0;//No more buying cards + -: 1058: + -: 1059: if (DEBUG) { + -: 1060: printf("Deck Count: %d\n", state->handCount[currentPlayer] + state->deckCount[currentPlayer] + state->discardCount[currentPlayer]); + -: 1061: } + -: 1062: + -: 1063: } + -: 1064: } + -: 1065: + -: 1066: //Reset Hand + #####: 1067: for (i = 0; i <= state->handCount[currentPlayer]; i++) { +branch 0 never executed +branch 1 never executed + #####: 1068: state->hand[currentPlayer][i] = temphand[i]; + #####: 1069: temphand[i] = -1; + -: 1070: } + -: 1071: //Reset Hand + -: 1072: + #####: 1073: return 0; + -: 1074: + -: 1075: case gardens: + #####: 1076: return -1; + -: 1077: + -: 1078: case mine: + #####: 1079: return doMine(choice1, choice2, state, handPos, currentPlayer); +call 0 never executed + -: 1080: + -: 1081: case remodel: + #####: 1082: j = state->hand[currentPlayer][choice1]; //store card we will trash + -: 1083: + #####: 1084: if ( (getCost(state->hand[currentPlayer][choice1]) + 2) > getCost(choice2) ) +call 0 never executed +call 1 never executed +branch 2 never executed +branch 3 never executed + -: 1085: { + #####: 1086: return -1; + -: 1087: } + -: 1088: + #####: 1089: gainCard(choice2, state, 0, currentPlayer); +call 0 never executed + -: 1090: + -: 1091: //discard card from hand + #####: 1092: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + -: 1093: + -: 1094: //discard trashed card + #####: 1095: for (i = 0; i < state->handCount[currentPlayer]; i++) +branch 0 never executed +branch 1 never executed + -: 1096: { + #####: 1097: if (state->hand[currentPlayer][i] == j) +branch 0 never executed +branch 1 never executed + -: 1098: { + #####: 1099: discardCard(i, currentPlayer, state, 0); +call 0 never executed + #####: 1100: break; + -: 1101: } + -: 1102: } + -: 1103: + -: 1104: + #####: 1105: return 0; + -: 1106: + -: 1107: case smithy: + -: 1108: //+3 Cards + #####: 1109: for (i = 0; i < 3; i++) +branch 0 never executed +branch 1 never executed + -: 1110: { + #####: 1111: drawCard(currentPlayer, state); +call 0 never executed + -: 1112: } + -: 1113: + -: 1114: //discard card from hand + #####: 1115: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + #####: 1116: return 0; + -: 1117: + -: 1118: case village: + -: 1119: //+1 Card + #####: 1120: drawCard(currentPlayer, state); +call 0 never executed + -: 1121: + -: 1122: //+2 Actions + #####: 1123: state->numActions = state->numActions + 2; + -: 1124: + -: 1125: //discard played card from hand + #####: 1126: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + #####: 1127: return 0; + -: 1128: + -: 1129: case baron: + #####: 1130: doBaron(choice1, state, currentPlayer); +call 0 never executed + #####: 1131: return 0; + -: 1132: + -: 1133: case great_hall: + -: 1134: //+1 Card + #####: 1135: drawCard(currentPlayer, state); +call 0 never executed + -: 1136: + -: 1137: //+1 Actions + #####: 1138: state->numActions++; + -: 1139: + -: 1140: //discard card from hand + #####: 1141: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + #####: 1142: return 0; + -: 1143: + -: 1144: case minion: + #####: 1145: doMinion(choice1, choice2, state, handPos, currentPlayer); +call 0 never executed + #####: 1146: return 0; + -: 1147: + -: 1148: case steward: + #####: 1149: if (choice1 == 1) +branch 0 never executed +branch 1 never executed + -: 1150: { + -: 1151: //+2 cards + #####: 1152: drawCard(currentPlayer, state); +call 0 never executed + #####: 1153: drawCard(currentPlayer, state); +call 0 never executed + -: 1154: } + #####: 1155: else if (choice1 == 2) +branch 0 never executed +branch 1 never executed + -: 1156: { + -: 1157: //+2 coins + #####: 1158: state->coins = state->coins + 2; + -: 1159: } + -: 1160: else + -: 1161: { + -: 1162: //trash 2 cards in hand + #####: 1163: discardCard(choice2, currentPlayer, state, 1); +call 0 never executed + #####: 1164: discardCard(choice3, currentPlayer, state, 1); +call 0 never executed + -: 1165: } + -: 1166: + -: 1167: //discard card from hand + #####: 1168: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + #####: 1169: return 0; + -: 1170: + -: 1171: case tribute: + #####: 1172: doTribute(state, currentPlayer, nextPlayer, tributeRevealedCards); +call 0 never executed + #####: 1173: return 0; + -: 1174: + -: 1175: case ambassador: + #####: 1176: return doAmbassador(choice1, choice2, state, handPos, currentPlayer); +call 0 never executed + -: 1177: + -: 1178: case cutpurse: + -: 1179: + #####: 1180: updateCoins(currentPlayer, state, 2); +call 0 never executed + #####: 1181: for (i = 0; i < state->numPlayers; i++) +branch 0 never executed +branch 1 never executed + -: 1182: { + #####: 1183: if (i != currentPlayer) +branch 0 never executed +branch 1 never executed + -: 1184: { + #####: 1185: for (j = 0; j < state->handCount[i]; j++) +branch 0 never executed +branch 1 never executed + -: 1186: { + #####: 1187: if (state->hand[i][j] == copper) +branch 0 never executed +branch 1 never executed + -: 1188: { + #####: 1189: discardCard(j, i, state, 0); +call 0 never executed + #####: 1190: break; + -: 1191: } + #####: 1192: if (j == state->handCount[i]) +branch 0 never executed +branch 1 never executed + -: 1193: { + #####: 1194: for (k = 0; k < state->handCount[i]; k++) +branch 0 never executed +branch 1 never executed + -: 1195: { + -: 1196: if (DEBUG) + -: 1197: printf("Player %d reveals card number %d\n", i, state->hand[i][k]); + -: 1198: } + #####: 1199: break; + -: 1200: } + -: 1201: } + -: 1202: + -: 1203: } + -: 1204: + -: 1205: } + -: 1206: + -: 1207: //discard played card from hand + #####: 1208: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + -: 1209: + #####: 1210: return 0; + -: 1211: + -: 1212: + -: 1213: case embargo: + -: 1214: //+2 Coins + #####: 1215: state->coins = state->coins + 2; + -: 1216: + -: 1217: //see if selected pile is in play + #####: 1218: if ( state->supplyCount[choice1] == -1 ) +branch 0 never executed +branch 1 never executed + -: 1219: { + #####: 1220: return -1; + -: 1221: } + -: 1222: + -: 1223: //add embargo token to selected supply pile + #####: 1224: state->embargoTokens[choice1]++; + -: 1225: + -: 1226: //trash card + #####: 1227: discardCard(handPos, currentPlayer, state, 1); +call 0 never executed + #####: 1228: return 0; + -: 1229: + -: 1230: case outpost: + -: 1231: //set outpost flag + #####: 1232: state->outpostPlayed++; + -: 1233: + -: 1234: //discard card + #####: 1235: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + #####: 1236: return 0; + -: 1237: + -: 1238: case salvager: + -: 1239: //+1 buy + #####: 1240: state->numBuys++; + -: 1241: + #####: 1242: if (choice1) +branch 0 never executed +branch 1 never executed + -: 1243: { + -: 1244: //gain coins equal to trashed card + #####: 1245: state->coins = state->coins + getCost( handCard(choice1, state) ); +call 0 never executed +call 1 never executed + -: 1246: //trash card + #####: 1247: discardCard(choice1, currentPlayer, state, 1); +call 0 never executed + -: 1248: } + -: 1249: + -: 1250: //discard card + #####: 1251: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + #####: 1252: return 0; + -: 1253: + -: 1254: case sea_hag: + #####: 1255: for (i = 0; i < state->numPlayers; i++) { +branch 0 never executed +branch 1 never executed + #####: 1256: if (i != currentPlayer) { +branch 0 never executed +branch 1 never executed + #####: 1257: state->discard[i][state->discardCount[i]] = state->deck[i][state->deckCount[i]--]; + #####: 1258: state->deckCount[i]--; + #####: 1259: state->discardCount[i]++; + #####: 1260: state->deck[i][state->deckCount[i]--] = curse;//Top card now a curse + -: 1261: } + -: 1262: } + #####: 1263: return 0; + -: 1264: + -: 1265: case treasure_map: + -: 1266: //search hand for another treasure_map + #####: 1267: index = -1; + #####: 1268: for (i = 0; i < state->handCount[currentPlayer]; i++) +branch 0 never executed +branch 1 never executed + -: 1269: { + #####: 1270: if (state->hand[currentPlayer][i] == treasure_map && i != handPos) +branch 0 never executed +branch 1 never executed +branch 2 never executed +branch 3 never executed + -: 1271: { + #####: 1272: index = i; + #####: 1273: break; + -: 1274: } + -: 1275: } + #####: 1276: if (index > -1) +branch 0 never executed +branch 1 never executed + -: 1277: { + -: 1278: //trash both treasure cards + #####: 1279: discardCard(handPos, currentPlayer, state, 1); +call 0 never executed + #####: 1280: discardCard(index, currentPlayer, state, 1); +call 0 never executed + -: 1281: + -: 1282: //gain 4 Gold cards + #####: 1283: for (i = 0; i < 4; i++) +branch 0 never executed +branch 1 never executed + -: 1284: { + #####: 1285: gainCard(gold, state, 1, currentPlayer); +call 0 never executed + -: 1286: } + -: 1287: + -: 1288: //return success + #####: 1289: return 1; + -: 1290: } + -: 1291: + -: 1292: //no second treasure_map found in hand + #####: 1293: return -1; + -: 1294: } + -: 1295: + #####: 1296: return -1; + -: 1297:} + -: 1298: +function discardCard called 4343683 returned 100% blocks executed 100% + 4343683: 1299:int discardCard(int handPos, int currentPlayer, struct gameState *state, int trashFlag) + -: 1300:{ + -: 1301: + -: 1302: //if card is not trashed, added to Played pile + 4343683: 1303: if (trashFlag < 1) +branch 0 taken 100% (fallthrough) +branch 1 taken 0% + -: 1304: { + -: 1305: //add card to played pile + 4343683: 1306: state->playedCards[state->playedCardCount] = state->hand[currentPlayer][handPos]; + 4343683: 1307: state->playedCardCount++; + -: 1308: } + -: 1309: + -: 1310: //set played card to -1 + 4343683: 1311: state->hand[currentPlayer][handPos] = -1; + -: 1312: + -: 1313: //remove card from player's hand + 4343683: 1314: if ( handPos == (state->handCount[currentPlayer] - 1) ) //last card in hand array is played +branch 0 taken 17% (fallthrough) +branch 1 taken 83% + -: 1315: { + -: 1316: //reduce number of cards in hand + 739365: 1317: state->handCount[currentPlayer]--; + -: 1318: } + 3604318: 1319: else if ( state->handCount[currentPlayer] == 1 ) //only one card in hand +branch 0 taken 16% (fallthrough) +branch 1 taken 84% + -: 1320: { + -: 1321: //reduce number of cards in hand + 575003: 1322: state->handCount[currentPlayer]--; + -: 1323: } + -: 1324: else + -: 1325: { + -: 1326: //replace discarded card with last card in hand + 3029315: 1327: state->hand[currentPlayer][handPos] = state->hand[currentPlayer][ (state->handCount[currentPlayer] - 1)]; + -: 1328: //set last card to -1 + 3029315: 1329: state->hand[currentPlayer][state->handCount[currentPlayer] - 1] = -1; + -: 1330: //reduce number of cards in hand + 3029315: 1331: state->handCount[currentPlayer]--; + -: 1332: } + -: 1333: + 4343683: 1334: return 0; + -: 1335:} + -: 1336: +function gainCard called 556409 returned 100% blocks executed 70% + 556409: 1337:int gainCard(int supplyPos, struct gameState *state, int toFlag, int player) + -: 1338:{ + -: 1339: //Note: supplyPos is enum of choosen card + -: 1340: + -: 1341: //check if supply pile is empty (0) or card is not used in game (-1) + 556409: 1342: if ( supplyCount(supplyPos, state) < 1 ) +call 0 returned 100% +branch 1 taken 0% (fallthrough) +branch 2 taken 100% + -: 1343: { + #####: 1344: return -1; + -: 1345: } + -: 1346: + -: 1347: //added card for [whoseTurn] current player: + -: 1348: // toFlag = 0 : add to discard + -: 1349: // toFlag = 1 : add to deck + -: 1350: // toFlag = 2 : add to hand + -: 1351: + 556409: 1352: if (toFlag == 1) +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + -: 1353: { + #####: 1354: state->deck[ player ][ state->deckCount[player] ] = supplyPos; + #####: 1355: state->deckCount[player]++; + -: 1356: } + 556409: 1357: else if (toFlag == 2) +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + -: 1358: { + #####: 1359: state->hand[ player ][ state->handCount[player] ] = supplyPos; + #####: 1360: state->handCount[player]++; + -: 1361: } + -: 1362: else + -: 1363: { + 556409: 1364: state->discard[player][ state->discardCount[player] ] = supplyPos; + 556409: 1365: state->discardCount[player]++; + -: 1366: } + -: 1367: + -: 1368: //decrease number in supply pile + 556409: 1369: state->supplyCount[supplyPos]--; + -: 1370: + 556409: 1371: return 0; + -: 1372:} + -: 1373: +function updateCoins called 4147100 returned 100% blocks executed 100% + 4147100: 1374:int updateCoins(int player, struct gameState *state, int bonus) + -: 1375:{ + -: 1376: int i; + -: 1377: + -: 1378: //reset coin count + 4147100: 1379: state->coins = 0; + -: 1380: + -: 1381: //add coins for each Treasure card in player's hand + 18253150: 1382: for (i = 0; i < state->handCount[player]; i++) +branch 0 taken 77% +branch 1 taken 23% (fallthrough) + -: 1383: { + 14106050: 1384: if (state->hand[player][i] == copper) +branch 0 taken 45% (fallthrough) +branch 1 taken 55% + -: 1385: { + 6412512: 1386: state->coins += 1; + -: 1387: } + 7693538: 1388: else if (state->hand[player][i] == silver) +branch 0 taken 2% (fallthrough) +branch 1 taken 98% + -: 1389: { + 191917: 1390: state->coins += 2; + -: 1391: } + 7501621: 1392: else if (state->hand[player][i] == gold) +branch 0 taken 3% (fallthrough) +branch 1 taken 97% + -: 1393: { + 192262: 1394: state->coins += 3; + -: 1395: } + -: 1396: } + -: 1397: + -: 1398: //add bonus + 4147100: 1399: state->coins += bonus; + -: 1400: + 4147100: 1401: return 0; + -: 1402:} + -: 1403: + -: 1404: + -: 1405://end of dominion.c diff --git a/dominion/dominion.gcda b/dominion/dominion.gcda new file mode 100644 index 0000000000000000000000000000000000000000..515b2ab339e379017450699dad5a9e4797f0fae4 GIT binary patch literal 5688 zcmeHL4OGro7{9L)CA^3t9~}#o<})E`l#g18i6U}TiWH-bqMA9ajdH8gB&bBdGL`CB4eMd))u#l$kqrU|3v5mvpy1pX3o8qP0>IjTFbseT;**Cdkp9m zCn)QcPO{H5+9>E7Q>zid)i-dAEo9%IT#*qwl@-)yN2@j?df9=BV>FUnc?c{B5q_v0 zA$qTS7*PA&6i5gG?og8AB0IMtu8pkAstu`q+s}~@)+>`K96AKYb{Km}&Y>T|Bt)7= zA94y+_9_$N7%}hUUrmXd-?bYdxYCo#*WTND5C`49hgIYl!G%Y6rEx}hemqs_B>I)o z7~~HB@B+0NvFgfz!NfTYwSfr5AkWT?xT*b;3E@ls3p1$wb}lkR$$ga{MD5t9B0?Cj ziCIo^RiT4Np8>S@x(Dg*WhwzdLa8^-=l{Ffr#l9#4$q7 zE&T(sGfpJqk)dRy%WBC2$K<_I33?ZEhxf-oSzIRBVrdg5c$^Uy{2f)EExWHJ zIb=l49hGMl=4Lb*D(!ZaQ;Y~i?oy>QWoHoS!i(DK&eV1~Hg9Q=1W-!_5lf7{LWrRT0Ms&gYuSbw>CcTH%2qF@1cpF3+xRdzBstBLo)i z|DHHTaE7})X@g*d&m$9^$d0MuW%Xjqe9V{psWtZo9FR)TGd`GVD?wDfl0dSIDj&7o z*48g;HXlbpS+6|l-Wunn4AyN@hy|HttM-a=tVsF1M1@l@A{f!e%Av3c6dGFF)_F>Y z5%v~atMR}B6%t6SPEp(`dzJIB#BD|dXKt9v@4g*I$es`u^1ow|%I};NEyw}bJ5bgZ z!(!ofOG0p4W~!W@?V;fSg-&2VZ<#6IZFuLOr!DCF7+uRgz$PBUurW#cjl$J#03xgknEwd zE?P|-BRICr2(FLz63H=wt2)*jphM)mrJvewi*uqW{~+*VZ2&zGMsU;Ii-}_d*ZL0! zxT!W2> zfXpz@y4X*>yfU_GR~?YSP177Fspr-62t1F#V?==7VeHwvi%U0qow(8k?~v7FDERjS8i_vki73nkbIVVZ-RR&K)7@HUxN7^rfuQ-it>#?f};T(gV zUEa&$6>`7shUzo&{f?34`0mDcN50=N@?DWpPDMW9ws>KXQ|UVA8K>bBPS=9p=!npL zd-1mwBY#8jcMyMPu^!vTsk}RM!I8qBPCkHbM2+|Mzd|XhU&vqFm#VYYT;H)OZ!v5l zrq8g@oE_x^C1>iL632uWU`}Ds(sP8PKRggIRP8ESNscwe8IQbcLNIC%-vj5;fuW3{GSS~5%1Zpl>Q}q1B2zy zFpqv_%`Bd5;5P12ke_Q|KhOm>VDkwI*~I12Y-yqK)oTG2u!)T(;R?~U;Hy1fX^Wwy)E)3G#eK{u<^Qs+Ck`EV>#f{T4FSD$vEU$x6 zijXY6jusVo4-SiWJqNq$>*Zmif1^jXacNJ|o{PHfqB#oN*r%Rip*e8+B(E12uZ-Ie z$))km60RuLO} zQKCfOpGDs&rlINwM8=XNwKH{Tz)NO0*@SQ@>`sUM5nDUzFX>rFxaXVe*xE$ii#9k? zghfd-eaL)~qvTD!H&H*OY7T~Vh5P!LH^G-;U^G;2E3z;)vmS~8gnN9}eM-}uBt=z` q3>=8*>oeg|GFY58FTCcKdzSnFOVc1H`1?O|a4fC;n8r+(&VK@-U=5@I literal 0 HcmV?d00001 diff --git a/dominion/dominion.gcno b/dominion/dominion.gcno new file mode 100644 index 0000000000000000000000000000000000000000..d2c549165199836c29bd476271e3a270240c5c26 GIT binary patch literal 40596 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 mOn9tQmPF-0XQ_H~9>By|j^`iK+47W literal 0 HcmV?d00001 diff --git a/dominion/randomtestcard1 b/dominion/randomtestcard1 new file mode 100644 index 0000000000000000000000000000000000000000..658665dc1856def5b144a6b86088e37b4aea127d GIT binary patch literal 62256 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 literal 0 HcmV?d00001 diff --git a/dominion/randomtestcard1.gcda b/dominion/randomtestcard1.gcda new file mode 100644 index 0000000000000000000000000000000000000000..189119319eeeec91a8c92aff6fbbc29d58fdfad8 GIT binary patch literal 1264 zcmah|Ur5tY6h6N#Q)dJt_pqRXWNlbrvLPnEg!y0(1xC4-gw<4HBO*kN6tRb(D1$ZV zL5Vba$Y^7OKn+?TJt&O9WcbizL=U~lkYEWy)BBz4squT+WxL-w-}!UT@7!|(!P`T< z?dN^(-<4;G=xsu6&sS^1NrOoJXt3PqQb0!kZcQax4XRVRZ=z80orA%&IuLAH$CNHK zWGv|QEd57tdk37LMd{X@Cc_Il3-*mpEek?R1~eylSaG=lWFQJH9c6?z++$_=Sri^b z;Fg|h?!KdzxdyebZyjQ})Yry{?1c!o;~#>PJc6eb=X0Y?L~}hZE(%+6(#D)1&b_*Q zgt;N-aYk^Nw668^n-k0-_Do85P7qvZ%*l2^RKE6F$2{)Kunm5xA5AO^;;RccTbb+d zdf>u6SZ?lOuGbx5L@j6YewLpsVnVdvm(RCY9v}V2hy&vo3RXaui=gR1MAXUw`X!%qV`< zzPFkkEkjRniZksmeoWr+qNlhRd22H7od-RT7{uMZc%db~xfquiMe&k)rA|fiIp{*- ikNwe3?6LzfI9J|;ych9B?R$TJ1uA{7W%c{1$V>Z@=c0B1 literal 0 HcmV?d00001 diff --git a/dominion/randomtestcard1.gcno b/dominion/randomtestcard1.gcno new file mode 100644 index 0000000000000000000000000000000000000000..975deb27e9fde5efdeb610e0204c07b7544ad0cc GIT binary patch literal 5328 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 literal 0 HcmV?d00001 diff --git a/dominion/randomtestcard2.gcno b/dominion/randomtestcard2.gcno new file mode 100644 index 0000000000000000000000000000000000000000..c6b256665b6d7e8abb4cbfd1dfdde19349c7535d GIT binary patch literal 4968 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

D=0~K@tRkzldql$kO} zz@#kAd=@}aNwKr^@ht|2E46;O8Wz6uSE>YCxRpRyC^e3OVeQNasQXZFB%qF|?$+}2 z0E!ins+L>}QcVz)7FMZ($D`m9EqLA03zoi!FZFaS+@rlxY5k!}yk5BzZ zb?J0cDACnjPeQ_7&jV~zT|SOf)um2jbzjLM+)eHQC_5f^I-E4fpwaze&2^sU3LbFN z4G;|fr2=kcE)%NLG9t_S6n)wCEZ1GHw22mFBR8kPJ0$2eY@-5y@ zcr*V+bZj8SEG0;KLJrnkYUSU<99YP-q&E4Se43koC+OY?#YF1XP#)ih(3G^Gh0$`$ zL!7h(i5powm0t`Fp(l>2*1}9Mc-B9--~=3o@u~xdA-oE0bQ8Un9Se8BRn8Zmw4L`? z0+}AS3I=zCSn&}w3hNZ4M2sLa_?|QRDX$NM2V{P$X^@{PIv83EyBD?u)Mhlp%|I z7^FSvq3S>{bu!jp^U`w$(R<(l+0RsEE<&(bv#?u&(;gcByL#OdQ^1 zlwpf!@(Fytmd!aP*9*N(weZYi6z&`tj+oJaTcpRW0%(ro~7l_I(B*8=081Z+y4!L$7a87_8Kj}?%3tqwtSebKaSS&g}R^ufU@Ps zY3yjbc-iu5zM@^t@)O#&{Eb?6ye*rc}@uC0#R@=uX=F^&BRpltb78XLBY zPt@{aJr!UPo*`}q7`Jo6QVDynK%KlzkD3Tahz;HTWS88DK-yU0@c6(&TzTNeJnqq* zdK~K48sF8&VvU!yrGPdsE7unJ(%%eU++HTE9D;w0a-Y$nz< z@p`~R3wWzm2nK>6Ketyud=(hmdH4~oQ7oew;HfiP;1v8$B zTF}2;p>%Ac_=&D6EffN1SK!WeoHkGM-XaQU)0lKa^P5gPPwP27zRZWEY+Dy8pWKFO zcF@wltU8)c67)9AUq<73?Rlk^rc>&`e}Y~)bgBT_PFcKOFm%6%8F)x6WH5e%ibKx!>N|(Vt~uTl7HjO z^(dTi#;N_LxaZYID>q|{hSO^Ui)$DTo!vcbIk(t_0HaT#8}LSk3#8R^TSxQsW7mjJ zOxY~ znPaI~6CDTtAFmjO*-IAJg9GBq3y7G;zOJ2zbi zOiGfksLmI5u0aNYHP)cCU2{Jb!rJlyMjJ5r*5ixL+kK>_4I$cAqB#X^pr-X9+S5cs zqmbMwnwCzqr9=aXXdN}}$bF#ACK_xe+7CcTTOvfG7ev>05VTJ;?LDH=%dv{~FHNf^ zS}&qWJ73nc=ZJpyc*wS{>1L5>47!t7#jFwuWfZpa0afr-`Yc`oP{{}4QFuc zkX8rrCQcP`uNby#eK&!$@WalCxn+L^8N$U{_*#H;z6g1F z$zZE_`YdMlXyywE1gGUm6|+^dIhGa*y68Ja(cM^vi|zyvo5?{awu9F6%Ti@?ZRAe} z$XsU=p=3J(Y;#vYk4@3mlW*L`ab|}Y~6JYq(r+jlI`AWt@VF(%dyN^Jlnz2^I#N3U3{ zH1LGpf=rjYbdDkyE3Fh`hc4D1E%CJeXuJV+8*16k90U;4uk;vq^LDBy?GU#txCxB6 z^gEwiG>IK4U0s0Q>da}O$<5G$Vpk4Bt8JNT9otrpYe&nxmL*Z`tCpwwUm@I=mD6_nPwDUcs9`~!rD=%n-rq}@rKPiftM0vN5~F73Qqqvrt(&W{+b z%D)KO9hx>9VB;k)agN5#Ah3-s=fD>5jn;gZGM~8Nd+c-Ea5Os>u2o0n+2FlE^JXfY z@CP6GUx`Os<(Wu|X8Y-GGWAIEf*Pp@T7CphHpYH{(Ov8+XPTBu28cmH4-i*A0%~I> z#I|d(R|(__9f@=9A5WtSQLjAGvj5}0_;uZ%+wn}MTET^l*FjS4HiWmL>aLS zS(56gqX4&jga~k2NNrPS0;yzA#%WYUF&|J^kb2dtFY(XGz<2d#I{s~|Tx`8s;^i|Z zSBC7?%mo;|59_`bI@G?G3=AY99@RiTuoix4ZJ<)#+Caif1J_mB20jZg`kk0xmTPn+ zf$dcrCWi*W;p%YVbJ0_0Xwk{GDD}B^oEv95+7wLK8lq+OL=*p*P`gHmnWR16Q$ro4 z*tiI;rGLv|auR7Pz{l4y9A9I&R0M68P9qTU6yr|Bf#QD?3z;T+_5Z7V5CsYME#6Lg z)qO9$o5SNp_3IrzC!IFb=HAJ7we1^3k5jcWRP-6dG_iDOI}BwyO^S#Z$nT{M_T|!PlVBlOmw&^X)6FTS8J)2022u$xhn4# z0&}#$jH3u7vlGT?=FvxC?#xc;ubIy{3UhkkL@`kJiGlj)e%uoD6MoU_5cq{MsNu&8 zZNIz=P)>7o8oQ0K^N%FCmSu>ruvODu0jTFZ{Q!?#Ldn?}i#zX8HVhk8{lr-{E8t441sFYpXC+#^ zBs9*?N7P5-h+EN5sG_%P!d-Z6=_~pGfh|Qkt&vXsC+Z4}0mvS!_ve8!KvT{n@Hah1 zlMte^ehTjR3`2F7=sep`9}`H*#Hwg6pCdc#HN#uX(0a)n>`txSj6P{ZKN3B2tCo2M zpy~@t1oZ(;wOFHC5n6b#u}zChm*G)M4(Z^CpPK1`A;fdM50inhBNp>VUU8rxoLoe^ zVP%Tr1b#O@LzjBIU21!s;ab#NzAbU^4%<0VfTD}Imi7dPI&k=uS-6{g08k96@xH|e zGBLZEn-0)*_1XyiyOLfJG{X(}H{T4^Bgr+x?;$~xem=)8sGdNJ>9pO-`iSnxcH%q+ zdwYIdwi=~l2ewrt@1d%2a2+L5456AHSFWFr7e?y^-g%EMU?D&&M1}<;9fQp$y6#?f zB22B0J7C`DHS_`Vhsf{&GwggCp{C2ojeL-C854#-u4uKw$6|SPS9js_4Uf>8YIDbcqe-JGC;a1zv5rDuu{pdK( z&o#bY;5!5|g5LM&9f5Z=Z7aaWi8!0Xa;9Jho>*_<=1X84KMc+_R{l|U96@g#X`Zh& zmvgD_Ib6#gK&Wn<2kIzGqL zcNh0$U2tX{9`LS12g1_Yyfv<)M*`$J?&$vk7@ggf`W;QtMkC(Ka@I4Q&k^4uP}-y# zdlzk2#kKWQn)6Qp`TF=ZRXu$?#a@s(}sUY1BeZ6<`1+wYQiB*7J)g+_%zh1#G3HYh9y z=LRRLBpxvT7=Zyl!9n2^5*KNSa{)&83iOp4oy&?uXADu$69fIZcd5kgzgCb7*hN18 zr0wQ|Ld5~5aNqfqKZY0ooCN?!;-C<{}lqm!+PZ4;I{wE7&v*Jn#lad?b)l zRf{oZ9|E!femsH%=<^%xHGiq>=2qUY%)IY7M~O4g{-l5v3~FL+d<_blwV`!A%qf9DyQu>{ngWAKIzuhkLlD4Vvry zcDVi_xHfC9mjOnf#+VajB?YozbTEwQldM?;3*Ni8c-T7<7%P97rm+Xi zx<@y}LV)7;TN26cTlf}4CTWog04Z|w4-H+Z@wo)5s?a>q(gfG?Bt&i*@H4eo?>I49 zo4S@iD$a4bX`W8Z(|)vzVkM_~OqAP_d(6iGqyGR+nIx}bTaPDEZF>^O%ND`rn0~p{}Ccx-?QOpCn z7%RS*gU}FP4CO`a!bRX?$WZ@cmF%5`1WFTmrK@T#=NWoQr^^l=pVwhn8`GJ<)}DvSRMz9*Rxa6JYP;kUfYF;l zQ|qI<#qj@-Sy<~%fNJ;`GgUOX8iu@w z0TjLMm-h9EJpM$XAX3puXUbHpzNpI zaET6Dg3UbxeIfhhRO%z#0rmi-4#0~rKW%97yF>QccAIA0K%gpQXX^+lAMy##-)p#* z)QVcK(!yaD)?J+^Ul}&O5ZvXOdumH=-2F?|4PaF}y-}#g6A|8oguia~1ob`UukXre^0A9MR$6Y2@Hy8l~a z-X?JIRyt^u&p6?kQTfB9=9mNY7{kJ;IM8jf)E!cjypF_=m&Of;_$O)T(OBGR$6YTq z#a}NqnN{L?$=S7tOy)-JKp+((?>eDek4HYXS7#G~3-tI2kPj=51n4(wprRE~+~&2! z(}0T7pSWmOf?l1;ZI_Zr7n=GHH`%rE0F1uNy{0{T__cg^3CE3X>q$Rm!9~k^WN^es z9sTTd%L>sBQQWU5QhZbg9;IG)Ot$Ma8=wjTGZ@VsaWcU8Hyw}Q^_C{Hpcx$qerYVU z2|d0FX3fYHYs7!~u;8Z$&|AOushbLf+PVmG!3-}rHo zd-y5zf+O;J6RwJvw4dB+iRV6X*x(YA0&`oG$fw0eEAjG6(RJGtXCE^2Zx89>)FCe1 zvv-p1o?QUx-iG>&w3p|Fqm_FPKYP$l(Jf|_RvN{0;w;rg-$#Ovut&$@mv-Jb z+fW!>s_l3lUc%4njy~QnEa!h{CZ>z|ZPYG!_WuAReDo&3gTBM`vm|{3r@G3cSx}=s)T!34BIcWo1<}v<-C>`1IUN(!HQvF z3u|s9UXv~~olodB;3`@JI?rfrPnNXjd!Or^>hE3Y$ItC=7~i{Ytbz1QEqxQf?_FK# znLc`s&07yvZ@nF`2Js7dmNQvPG*d}%+5VXhN+Z2{p(i^Z$JC2>1WRb$fOpVdCl^NM zVEKvycan^l%xbuTR90<-{!$qI=%I58WH1^?LG)kv2O`gCkw*a{Dqgi_Tw zO`>taeAl`CX&(a zB(=mSn&kj5KzP#r6d?8G#q*EEP$So}Ovs{M|JE#T1GFCzaLZqb$ky}$0JnQ%uma|W zsux`8qsLS?z@_BsMbx(r@Au)Co_#gVr_%4f15wjF+}96Kov)_hG+)0uuI8IQjy=vV zcx}VxeMF$pd)suFwOf;F0gBcevl=Gj$DR4c0&6f-6GeVT|3dRF`k8cJO+*ykxZF4GnIRW$R>nmh@hYW<)_&m}NC?3R9VlN34oF?Qq-&C;J)P#pgh>3o~B zKiMyxcQI@^UW+6VNTgwiC<_v^#|%0balXwY zcIy@b@jK)&ArgBe#yqadb4Amy(|peY#5kNnMqseV_q)0IK%&pdo*{nPCRvL%LkRl^ z5{(a4IV5IvLvWzS-P7$6oK8P9V>uruelY_7hZNvd>~+pIIctq9=j-QT*dW8_`D1p(T%nsy~XyIa$x@KaDB%l;F1>T3Kp?ff z3U_ER|JmqX6n`Q+9!A0P`GhW7$U)%Z`OPjcx|Yd1z9U%6%9?#gU|2jlJW`w@eW|H? z2*j-C8}`bzJ5O@0s9xedEb3VxcsFa_mjMde9Mlh0`n#q*L7*(BNa?zjIj4L%Y7hoeb?FAZ_ zDI`isB1K5_)zqE{pT~y>Zz7cW3rxra zg13W_GH#h>hre^JllDZ^T#nvN(A=;0H~9CuEtc~T(((Aw$9&64J~w|E7E3maIX&=u ze6J(#*kbnHg47qzz0-Z&me-9GSbGM3CtNTB2_hoi}7Rbgek%JG? zpSkcD1@s0~s?~iF(3W!n{d;^R{_R&6dc(DBE9}W`CZqe02eM+OqdTQgI)|QI4m}Av zXcq%l>&(W#^r>YZQdO)8E8S*y!ov+GP!gUOa&Iuw4TF9P1%D3#Rv_LcB|B3<&E8@< zk4$zOb1t#EHz9Sri%LO5@6VB;zj=c_YpruPGW4l+?wsrWIam8ahjI#XCghn13$hj!;%7x{;TM_^j`C2Mznct&li z_&XtZG{=8Z_+|%UXOgexvy?n*UbpnfbF1)h&3<2SOKN_0W8mNU=2wvifyy_VuDc=U z`kWhbZrp+bf50CBwz6R;r;0O?^{0&HV>bZ@yakD z*I#BBo_@P96}|gy@T=r-%H3PWM)IKF*0=cAaYF_T_D?gL=x5n#A{m|~{yxdubNi$Z zUXs$sYy#AEP)#Hq=?O#d&xzxfb9j1*)~Y4ugg!~W+T1>= zRCxl>)M)1p(2Bpjl2+)(5XkM5;R?CX{^F3s{A9yAWJ=7GKCg`cb5?b&b3b+(^r>}5 zZ0I8!st1G)9z$P{xXAk`AXIH`nY$2wvIX{=`(Nt_dGnLV9sffVf9J>v0D?nO{GX!A zm!Zm_Ehn==;C2R}$Uoi}p3ui_ek?-OI956L3ZFIX8c?$i)jFpl<$hZNUBddsTdCgY znDXz>;B-HUQ{vzB_0ckVix;At){_9C7J~ECOd^Nwg&50?*w}`ANFn=T! z#6i`GoX1?|v=lj>bFRs`I>-Fg9+A|mF$nv(^USY&WEpN`7`E@LgW``aYRi zUuV6MBRfyMEXPX6-vdfF-^?|)2e&zD_B-GGveV!d!5R$T>Wsxd9f6X-9%1M+n1jL- zp6{A#4&thrV^eah^ZG>Y1zsRBbF3MCQX`96BDzFo5rV2>X6At-J#wQ)_-g*^Mzsi^ z5gFAk-W?eLyqPIkbF6_}Twbs?CDIL)G1>n$GXs%LWNf2L{QV?EnvCGr4*%F(>r8KG zpZ{AHA#CK+pXhl&cfM8BBq~-11Vg~))f{o>nuRH#Hb-6-oP>ieLI>8+5LY29XA+uA z#wRoq7ZLdkLKqzW<1M%!e{W3K!?A%gas1r=FG~LI_$%kLNp_r-(^+TM3X&-wx|5yd)5`o zW9oMBodYQNB}7jK;4?qZ4^Qdi_GW$Ec&hM=m5DY(ATcYHE43s_IR`Q34Nij1DEHRdvj{`IfK8Xx+>oXLryps z;pwBs9+>BV43BlYDrr@bV{SF;%#W<|Rs^>=LSOqo=guSACnvbovFmHkp=}QT!JNfM zegV7d?j`tF81~=8qLD{f>A7aZuCIw5`!CO!@TJ>x%xm0{URccKnWHl!Cj!Vp??Gme zE5v?n*@LonH*VbC(TIKmMyh0OQi(bGSMpiqPM{h;uce5LzEqn6|KcI~=L!3M`4L88=b2 z7DIo+yz7K8&p4qBFuE%Do`64bZLOS!OuqHVY$SPjtkw$81?0_o!8Tis`O)F%^T=N?pzmLLC{f>SGH_!4+%Ly02 z9YcKKiK+SFKJQ}saaHa?p;h_W9bJ{50LqGG9XcjESoSGMSaZ6tfS7+^ac&mb-r8=O z>aNQR&cy^gA=jFd!7`)6-Li7cLnT#aLOE{;Pfhx)Iqs}#j0bEKx94HOn7zyA%Et{t zwIe5c`<$rP+=XH2Gwc00uN#7qhgDF_6*>!HA?r}|Jds?D#F~>H?Tr*edJJB+9z(B* zEv7zbJwmOQYd-HoljNGBsZ4GvpULe6?Y{8+I}lt@Y^E3M=E}3-R?%K^{xW^3G!gk~ zJIAvwrc5M0Gc<$}JX?qINK+p6{+2+JcU+Y(kfgv^V+%vO#fy|a zG#@%Zet2$bUbxqXKJyW}Bx>v-%FiFViL&`-v%dlp4elEF&+cJg`3M&`G$XLrnwSyV zV?N>mpZ}eFtI(ab2f`wLjIqw!n~$(In0|PvnnFWfIAwd#aO69trRNWwmO4Kr-<*cZ zZE<9?hBH|;bTB6?JVJDt~<-^D@Y7MVf&Tyf#9oo>DDvMRi z9m~*EdqD7Q!2&O|56*F|3?)Mic2bQ!A=ybt`phk^%57bR)LP&c%}b6Agj-XYcPx4| z{arRHV?}i(=CwteNDE#vZbDfYbIgZ*e}NlI<6MW^7i_?R=T^XdTu_rvYJz{Eq{)Xy z4t>XB0-r2O32vemh25cgva|A!6dBML(Z&tbs%EH;l5hxTDU@pxxry{xyBXRca)U&! z898YpyhwU|wV|=3o;*_1H0|NGl}xlY zQ7yI`10!!+oF$(`zQoZBI66Gt~w))uxpRF3l!fr^s@w-?*yJfiQ(cwKC<@9twNUm1#_y66I*M5;uokQob^z`n?7_yb0mI?hF5 z5BG=VVdoKw8sQ7S>48Mn!#oSlXE8^3{UK?rT}6= z=ZzAIjDbnH7Ax|S7iYkAvUgf5FQtwvLe-|@@L!p122cBp{G#B6G`OO&featL) z4L^kraNr|&`{iU56WTX-R9?}0XnGFU;cnw_Dv<08U)sZRQ8?HQ0c;?9L>jwO|29AL z1@~uImuC=d9cVeh1CE^F5%dE@J~G#fJ-o%yInVq!*Ze%M=p9_tk5&4ei zx~Eg9uvT zPedN3F=#z9k!%U=2^`lrK+cQi=RWK%1k)TatBc$FJTp;)vEld0uc^1~wIumm1^BKrKXI%&~50iaZDshed; zE)ULYz=G{Yu7H;!?s#zJnxE!bH>B2l+I4Y_Vf@*F!DFV540joB`ciVjqhtAD|CUsL zU)m4mTSHlvmSmBWSawKWP0XF2{X?!fHzn{13{TI)ZX_>wBsE}KTq}w=4ZJ8@%S~YM zbj$HJawh$zjf~DB;6~SiHLqwZyeUR3`ds)@+!nH~e9M=bpL}JiH~UxD-Cx2X1O#tK zG|V-dyg1Qvy|BgiVBX{3bbv9U!!JLHdSp?v#ey(}+cMm3VZJ3KXcWFAMxkSA>%s1K=4Zdj!){@|xs-<; zh8u?5Uc{qAuF#D*O$k0v!35_V&r=}F2y$#e&^iM&1Qy~)a0$K}i%!G^1oi{DChDXGMqVVk$#uh?bKbuirbN!Fgce%qp%2>-IZIYdrMk8X!A`CQbxCN;VoszpD8-;C(} zG#QCe(Pk)!`S&6`h|E14Zxu9yIXnuJ|J9CY!Qoi!wXe}xY3jchfrO_1kP|GCBFYWv z>Z&{p9!!|i&vK*FtWAg6m@xlCi$tF4^Ud!g7gwS#=!77AfdfY@8-T@O=4rr3H$a(P_{u>^sD<6}_tr!^*-nfLL#-mBrkQNG0B^rq#_!FjhqX(c7ZmLXEYF zB2Z)*0!efpydwtoaHy>{Xpw<|P3N{;n$&JhOplxj1~VgiDI|aua~AJ6L<#`vz8Ya)yd|Vd2m3$%B3C>$Ccf(`7 zFM=x(%u=C+*s&5k{b(y+Yb9~Q4sHo-oA=*|Iv>Q!M!53XuRx`NdJ@?}F^cSKZxxa~ zGTjxrg`C&>1eg-q<65?#3b)zEmNU@s zG&HawxmN$@fXq$q|7RqTZpy6t!C)D5*#3koROpo4LEhduB42;Wb)y+4a@E)5*I|Ez zIKuTonrEEF$WS-fgB&jt=ug_bUWfHX z;ImF~EuRRv$gD-Y4Gm-bAhJ;Pu+OAP4(BJ~M<~Rh$CLYLgqplz^A255h|xhrTJbQRnp+T#?e5w!;$vWulJ{Zt`-oZS^V7hIU^{GG>S5ANft zOv1c?MbXBN(34Al;eB&TUhvWn9Km{={K&=2SNN;T;n|tyVUt(DkzR{gJvLurN$je; zA4+9SMWkgraBLT;qW5yil=0+CoaAK)6Xz=Y?GPn=FM%&q`0FH|4%})(nW!`@M9kRa z0r-dDyl>F><^k+hfEA*Bl_>37a?SlUpLJclnWm&{^f~%DM#1*$K55Z6zgppGN8^8{RTb93QdDhc8Jzw*vrx-vj`Hp`(as20pvZRg?3|soeBx;f}=k+ zVIRkvX)I!Bw@8(bJ^?H(G%cKw;c&_aW-sm?h9U}o;l_}%c#`vlk3SWwe7S9r;dc}E z#0b1kEkI0oAMpwuH`){Gw9F6Sp#2XN_dT;Wy$SP4ho@eYJQw=9*&$T+=C?m`4GPxh6yWrmDY^YqQ`U0?@+*KXlh(d=UG{A zM0?BCgwur9G9`67X%z?ECT~z8;{{3h!&Uhcs}*Ce=F6^& zw{z!y+ZDP7MdVn6`-Hn(lwIQr`KUx|UY}GHo1PPUpZ3!}I#CYYPCYI-?Dkx@VfatR zdjZ%{wl16=5~|-nj?BDBAc2LFMI}6*%0gJQJ;(7A4m6~&EZcc%4iwc zqGw{R17#mh@5M|d=BMbX^v8Y8PrRVrPiM1YMnWx(==g7V?ydCF>^euZR1!32y-`vX ztw#kRa~&thKPB`}N1oOzbP_A>xP4adyGNo1m?bI~Lamqwt&xS;k(XkLOve)7$C5KQ zyQuJ1yf{8`8g(x#r4Ajz|D`WGBk*Z{cv?o**L;34?_4Z^Ps*_h5PRpRW*wphD{Xxu zrFW2Hx8Y3ezn;K{O5vOrDx9cW75Q0JdVxQ$z}eRi$_;IsNaND2B@hR>XiZC!5@ z`PyXis8ojowEkF_MW&&%HGU-51t=Q5;y^Dqdc|4bI0aIX4^X9ugLt2VUx9U!Zrln* zyAb6ogr14fdqJwonGha@-B|(dM`}~4F8n(?d8FQ#{lp=06mstpVd19M*7r}K#7sikG^3B?uu(z2=UDYGV&m);cc7iadnq_c5F zVCGH5D$}PMKTE&bUoVx0WlKRa#czo>Dr6L{L739x>WhE5@EBuqE4-8Zkmsbp&JY(v#$z?NdA9%q<=MOx8 z;K=bv`;R(*P*!&T+lz~{1`Wdh{c|cRN~f01EH3l+KY!rt@>w^N)3xZ7Su;z^P_=>O zlgj{88WoeiN*ei@0a*qvNaaFYg;V# z7QVf`7u-`yJyd;DD|UC=#2j2 zsX$c}7f*3#W}`DqEya+SRqmcqTv5@_ec5GhqwkC0-mCX+L-LvRh;zol_Ep`tW zFu?6Ezs)^)>g3Wg!`-*U?e0u{g+86#6ENaRXU?8cOzl6Jx-d(YO|8IFdvLHEIRk`5 z=ZA5zbJr>I!?S${46blbg~bGPHd@GCd24Zb$&6WZ+;hs&CS_CMiWc;dlgqfS z2paxkG!R9pS>?Bp$6D}R0rivJQ;YCBI8!G3C%a);v22JIe4_$o9827N1Ma>R^snS< zrEg4eIhxn5O$qu0vxB?*+?$L6Mv*XV@{Ad?ieQ>iG%LW}ONkgIvLvG-FmvYQ^4knm zRl{3eKC8T?`Ha#&7(MdJt0#>e=N*+dankq+Otp(7~8$yzpi9Ex2(4Jjfr5jYZl!5R1`I`WGSHf%NZ4BSgOyu_DDaknd4DW62&xeplT8K0?)i72g zrC0EbddMSfLOK^|;lE)o(ltoyka|8seUVn}0Y8@8?!Dkg>OndUX(7@jNEabpgEakP z)DL~rgOqyoY@{Bf4Gr)o(m_}>uAw~E*Ab*uhrx#}9Q~2!iAcvHor|;z>C;G?kX9ot z#9BSI3-lp%Bc)F_kr5fynbWE*sbWA5aUY{`P(U;DVJe0K0Zy0?*BmN$o|oi;Uqthn{mmpEH1Eo?N6e%Q1HlA}1~VuB4I2cSy=X$$~xw z==(wcLks#Sn_db0YoOoRfbE5(Cv?AHJ@6 zu^67|(DX4Z&h!+lvmKz%iKi!(+xq)}J`wZ*@$^zHp9^{k=+*J`q*rbEDWG?lk3NLH zs_pw{2Vx-mDnWlV7>lK03~G9(WJP}x^rd&fKS(uwzJus}fZ7WDHyFdW#M8aO> zlb5p*q<;qJgREHWtay2$p5>Q|&II6x zJ`#)dj;{xmb0Sy8E@vM21|cS5i=peA)MVG^VbGncv7U_Alf2jV$41b%BbHv-f_}M8 z-wXPWSce{L;g4_aes=`)HxO&bBh~)C!mdZJ6vW)WBlb{`Q2oV+dQ9&o8XahA*Ie-B zV_i9{g&jj|JEnkMinZoXE&9blyI)j-J_2jdPz(AZoBkx|f5rMV(fHj8`h%d;;f!r( zaxYtcALtLg5sTg2f?jOXQ!oeZ!@9R;3;Vm<_V)q(W6U|1LA|a2HsJ!UKj=q5r_&3Y zo^-q2j#EIt?k%kKTj)=>^;d#E7IRmk`aLP>9@6hiOAjW^Nuy9lA1Z$<=(8bzJt0OD zeOl+V)EvwZhH)Og`#@g zTKcjiZ(2q;c|@9fX-aNd=3UO5v_ZiRNn<*vW#**0N2FzdXN1&1U1b8~S3`a@$tQt` zgzTIFd_C|X!e5a#DCzpN)T`45QO+2Q?^4ixyRc@^?L>B7o>u2bYPJpa9XA^ANH*Gg z9M>Omg_!FXlcKR{=}99{{ZYqFBqtGlALw_@eiqwX2YlD%o}aLS0Z%%#rUv_W@u$VnR# z?3kNYm|W^e8v;+}q-Dahwil@ke8}#Hp)VC{ma_?wo0eXHYK=Z_6x&90x)8_!eW0XI z1U+BU$)3HSXM%n+^*e13N|W}WbZJjM?0Ln}xjlnKKce!^gFk&A;7pjx<9@c#?q}3~ z`Jm4Q{kiVQTt(}E%a8AH&GO`BDPiZ*4#AGeH+JZ}WyH=AZ;g0+#5+0LF+N5gM{<>r zYif+eo&-#GhRJVBlhL>CN`ZHR>wC8-*|0MK` zg&t}~^`UY%0`CJJ58M6z`P~D*d*F8u{O*C@J@Ef&57fClZ2$0{BK@D6Md~gW=^9CA zCj3K7E&8-h-HgSaR;G)(co;ff=4Y%Bd0z7YSO0t=Q%>Q3ao!+PHMcfPI;|h*qvrn~ ze~rze{Hi1mB?gw-{Hf~T;S@_x{;W^(aEjv{{@f-F=0!R%84^!Rr}z(T&G@sXkQ22A zm@5gi4xkT~di=o?FZ@aERc@2acb0T1 z{(n44{d-}%Wv-L$yj`Xr$n;B@9+GK?<2@|jL#AiR^dgy#lIhhlEs^Q1GQCTt56JW> znXZ%RcA0)4(=TOuNTwaqWce~ZOQsjebd*f5mT8GhZwsAWqev zXV(@|HsMFf6aRZ>K4$Fw&-xdLS;s;_0gkLS0U|wc7*n^6njlluh_i@)Um` z`NIqSHWa;jDKV!=iNa%)r}&?%7!=q4pCcPle9t)H$V7`FS&m(sMk{^U3OCls^$N2cBKh_{_o$ zWh8$b{ew@#G0Ky_c771Mwc$@ zvI##*p4!{BE%(INC;t6k#GEE23Xf5q+H2Q<>X9dn9PucLs`W<0G0IbUKdd-+=L?gI zVkEEZudXYkY{HMS|9EiZRlmAE;gS3gsU)?2So9n6h5sxhc4M_n8)WK!N#F}* zx>}|UGIg(&beXP}X@gAN>m*&Kt7Y0CQ}@e~F4NUAZIG#Zy`;-@wM-ji>V8GiWx86X z4Kj6a5cJmTi&Oq0))$5U<1y&-zq-Cqak@~J$4cY=p{S_eMz47OY~WEjPkU;9e(%N zhO6HkkxO!Ff7ft~@?>vK!>^-ztUSGu&G9T6zj(|t31r~zq)>;enB6PEPwRKk(anLM_*CU&pmj+kO3FE@hJa=gDyJ% z0(a&(JjLw8lktr2e?fLXJdb;f%;yj3CyF`hzscwoLy|mgc#`4m3GL#O4S&1%6#Jea zURg3)eSN$99Sn7k(2~ES(cbxcGIp2h+`c7$Cqte8x5Rfg)IC8<{Bef5FKLPIVyy1s ziAOP;xc&I)62}Z^v?cqs97(Zgu(o*~&d$%wqr9)AWNENKsavf=qhd-$GsfUiCLDMsrLjq?=a zJ3a%7r%}9d7;WvRbEYJmR(V?apEMJGb}Re76>)=g9`N^Ce!L^DBI=#H(|Eh5w_(t9t;2pQ-fA^LT~7 z9}`S_{+Y-8Jq>k^q3X3%;??;`sxVH_elH@iLaMKQ|d&xy|X3$afx@oQ^**l=bsX<&ZiqB{}!eHEx|ug z;&)5DI!{;iqW3w-esxaok^Id{k39dMEAgGsPl#XLD^yARDH5;lD;7!oAcT6iC6bQ3O^5c8b|8>UX7zinIGfmpDp#gDDmpNP3hSp z@#_3d;Xjmk_e(AH>{t3*;pw-zY5c15I;E#;iomP$JB2?(;?;Sc!k;hkh4MU4;e8UX z&ifSp8l}G#|5T-4p8F~Oxk`U4yruNF!auC^x5B@m^viQYrT=xMzZHI$(%%aImD1k| z|BKQu&mEQiE?B^FoNR?ZUEwaZVy~L~iM4{x5NPMB(C!|Vzv&4HO-YxORqh1sr)V^ww#Jho~ajKrLQRDP7=0Dk} z-crb%%ATtv-jMqPg)fnKwU1EvTP0rYD-`}NiC6m!g?~`#-`28Rdhe^fc3A^F+3zX$ zu$|&x?1?0Pk;GrmRKwUU@eLBsnGiv@nc)zF+H|huR+X@_3d9hQiDh?V|@2^*Q@RM=W_5H#))m#y>$BS zXlH#pMe?iXp;X~>7~ggseh=%(XtVBJ4g3kzE-O5&0@D_M)-YaX;*zZi@E-v0j^k5c z6BLsEuRR_{@jEhr8WZUGH39xDj2F`L=5(Ql-w}bHmvGVM#(dFw-R_X(&dL=0yc-ho3!j1iu@+^l_qn2|xBW59j$E2|$0q zI)TdFJ4N96ohITy93cGCSpvV1aQOU<`&HZh?8&5Gu(bHMNVadv{2wLo|0HQoq4Yn$8v}m2h$Vl%JyPi5ci4dTCn)#+1o)?F zrJZL>JNrX7eO?4V^|#jJx(+n5XIZ+3*o-^*U&HuL_P1Zp@-T+qu>|zGDp%Hv_S^J% zP5Swnn?0Q8chUeok1y%}uS?)ZF%{3YC8$?40saW^ZYdj|Y($3ikCgWRK@yL{0~9C3 zGfMb0;JYTJ8;j()RxIZw;2%!>apyB?o%50ObMtTytN2kWx*~y|NwVEfo+|ihe@LG~ zwx_4zlk=m}Um^AT`+J!0RsPp7=tn=gCSiXh`7_f6;a`$}&oIHy?_h$o0Q_f2+4y8N z+nHw6-7olyC6V68ZqIL936JqLTk>Bk`FBfv^&LV_zQli=K+n~P8|hdlEcv2Pa*E_t zY5&ugco@O&m;yQ|^*7BG__LXcztzJ1r0qFdr{mhUpWY>=esZX%&{Hk-^a4Nm)2;j| z@#m2q)Yp*xysO0jP1-s3Vh>~ZU0Fa~W&8FXCGh<2Dexnt9=D9Q16j&2u1;X*&A^j? zTF(oIAxHMFkn;k+^9|gsQvdAxJgoV4{ui&INjoFw2>e+Rf2ZVclKjIZp5C`_uicj? z!2gfbKV-1bpMm<*=S=B`u46o$=XY!YJ&{1qx&-*T1o+uf{|Ti+KfgN*{gtwPuafOM zhfBwAA|%lBEAU;D+Rnds$$AYOAoTM))zH--_0Q`o@cd3X@H7ulyX=tV(s?3%{>J^k z?Rj!%99*6uSX%tMB0=11ka2bJOb_$(ySjkRfgaT-TPP|j_gDA>B_#ujj7gI&A31JP ze%|;A|5s;M?;}SI#YYE4gd(7zh(L&wpv~x#a3N{X-pAgDbeBYTCm~Yg-Rz9_gPWb% z%*-acR1_dV6H!n^NJx>WXdrZSqydRP04Ws;4MH?frb7Il?Kd;_Z5k}yc%J=!_OtzL z@A`bdBMK7GBMn9+$Y!V-Q=I0RDxs0&G)VJalu`l;laiw846Gqc4+D~v@babA)x}EG z2SpG?MG?&jJThPs=@-#hQ376(IUp^GpjkPpM9hh@5=JFBiz;Zh#qRBCl-6l+4w4#B zHEn=^s7Zvd!PF*o%9xpMXnXJa`q~~*IqlIdU0z+iv`Q=Fvlwy5aD@~alogobs9h+9 z3+g6obK6KstBv9QiwafCnYz1;zNzICP@RAZh?~SiU>eVzG>X#Ehsx0{hZxJW!A{a> z?({`(>dGLd+5v5oTR148bV^-YIh{<>dAqqQVSk#Yn<_qWQ|}J*QXNeTbg#8kWr-t? zO17AZWNMWXG(c(#d@_O=sOr5@mVu9_PGX)erzOzY$jfF-lYD=aH7!SW7erT;azIJG z9u;|GoCbmOr>RDm$yzCE;~rcuN?HcS7>urFA8Ygs3zt(JGb%X=(+QY;)CRMOJ`nMA@hOm_pClDO@lmD0Jryh2F$M(ay|+)r%%5 zg$pJ#YIJ5iuOwzgU{0@~tiT&J4w~|sh3!BSuGJoRBaO1^5SV7x+?eWwT4h_g@}WvW zMs;YaklDv9eNyx@)<{kNRXa-?VBK>;!4$f+Q|MX;*>3=aVh68!VIJs(m}#~Y^*~y6 z(oVRW^8%?g&|?W1xnC$n{fwAV%VZ9*t>xHd5;ZdkSc;hU3yxMq;fhI1p=931(G0s+ zsxq@CZyl`dcd2`A6Pu*jG3A{{sNT0QNSp6pTif5=fL1F9OOoEg@GE-i?vN>MXY-(5 z4X$r(9d?iCXl;G3%Qd81g4`?W*7mQ^`?C{O}m>mb*#ovaC4m+rD!{*+7pOBQ@9v7Vdl5VOe!WrgR$H` z5fn(Ecj5ZG+@+Kso5~a8AU`WMF$6x}T(KO>3?c!Vh&yy$^Ypyz9XOd5J z(oSSezaS3^NuB7axS>d|X96#Bd%R59N({DT_%Eg85K|YwNq`G2yH<$fnp&M`?0? zlmsD5!>AkvVKUE9o{6i%@5eRvON+Sl?w@F$Bddm&4Ggl#q8iNo%g(rXUfKskk zg-{LcSB+tULPRo9vvwPVynhfw4b?>BQ4AaMii<}IZzdrIG~m6OnK7L&RsUaj4N!bV z#P3W@xU$sIFIQ}W{Jnt5HM;W7@tgR;kx7j|TIxUo*O0|8YpHq2`H`etz)KrnEp>EO zW$|xmsd@PLO=N+dFBkjoFLku?eb0V;P1OO%p-#943178q`+r#KK*ITr#Xq*^1~`t@ z{UrEvS_|hSh*?GImwREKGXP=Eo!bhY7~Dc0|1G!R<^I?UwxR=z75ha`;uGZa--e5P ze5Ruj#}sD4y}Fkz{^lp5X=15YQor`_a{n%6!w_sY8Uatg{of#s?U!cC zJ-wO552Ryl34VLN_waI`@5z@2z+9*8;Me~nGTZgby}xtZF$mA&oT(lB`hP*@i}=AST9Gk>I?(MHRz7(562*u)htUGO)(bZJgI z_FPmWZv1S3{I6y>ypErH_>q2-^^50MZ9Cp2EdOTS-nHw9q)WXb^BLzN{H?!?##s;G GiNSw%Pd_&R literal 0 HcmV?d00001 diff --git a/dominion/randomtestcard3.gcda b/dominion/randomtestcard3.gcda new file mode 100644 index 0000000000000000000000000000000000000000..b8dbfa83b5588431ac354db72f36c297112ca346 GIT binary patch literal 1328 zcma)*O-Phc6o&7NH91mYWiUCEQ6?1;QDX>E(87>@Ab&873MaLif(Rl~q8}H5o1le6 zVJS^uwde=M4BE7rQV3gEM350u1GR}D2nw_NzQ=cvp#d+$_nh;7=bU@Kd+x-Wn~v60 zY>35r|8_a&?mY94k&fT%2LjIdp9>Fmukmo{>dT?&%nP`D=L(CjOrF_#057uE79?k_ zMc$VT8;g6G>B3WlHaTUBLGPd6ZQ{gr<1CM&KC|22BEssON}DF;dABueJ12I)v$$K$ zmLsCx$x?eCe?FISh-mLLZDidXYN#Yz#Njk1{E_%owxEKH_~*h@0qy>_AR9ovfzf%? zj^B-v&~7%&r+uhuDT&~gfx5SnF zX#W_!zmzmzclc8ok0f(1vwhtqQFU^0rst6>&Nt1o#!$NU4#pq!B{t!#IS~7#|2>(5 zFL|@F$9))k`barvpIEr4zP-vE%sbU_VeHq#or{r!eQTp7OwxZ!vFN$;`^9V1V^vQ? F;y-Rfmq-8r literal 0 HcmV?d00001 diff --git a/dominion/randomtestcard3.gcno b/dominion/randomtestcard3.gcno new file mode 100644 index 0000000000000000000000000000000000000000..ec10ff0443a711cc71c0fb7a8bfca0d790089029 GIT binary patch literal 6336 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 literal 0 HcmV?d00001 diff --git a/dominion/rngs.o b/dominion/rngs.o new file mode 100644 index 0000000000000000000000000000000000000000..6a9e8488b8e9a2c75bdaac18b2282902f224eee0 GIT binary patch literal 11792 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 literal 0 HcmV?d00001 diff --git a/dominion/unittest1 b/dominion/unittest1 new file mode 100644 index 0000000000000000000000000000000000000000..9c15748a230146c02fa0f7c390cab954f3e5cbc0 GIT binary patch literal 62248 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 Date: Wed, 27 Nov 2019 23:38:50 -0800 Subject: [PATCH 09/15] Add files via upload --- dominion/Makefile | 73 +++- dominion/Makefile3.mak | 46 +++ dominion/Makefile_old | 31 ++ dominion/dominion.c | 740 +++++++++++++++++++++---------------- dominion/dominion.gcda | Bin 5688 -> 4144 bytes dominion/dominion.gcno | Bin 40596 -> 41728 bytes dominion/dominion.o | Bin 52256 -> 68840 bytes dominion/randomtestcard1.c | 123 ++++++ dominion/randomtestcard2.c | 120 ++++++ dominion/randomtestcard3.c | 157 ++++++++ dominion/rngs.gcda | Bin 2632 -> 900 bytes dominion/rngs.gcno | Bin 4032 -> 4032 bytes dominion/rngs.o | Bin 11792 -> 15240 bytes dominion/unittest1.c | 99 +++++ dominion/unittest2.c | 74 ++++ dominion/unittest3.c | 95 +++++ dominion/unittest4 | Bin 0 -> 74640 bytes dominion/unittest4.c | 128 +++++++ dominion/unittest4.gcda | Bin 0 -> 736 bytes dominion/unittest4.gcno | Bin 0 -> 2628 bytes dominion/unittest5.c | 99 +++++ 21 files changed, 1448 insertions(+), 337 deletions(-) create mode 100644 dominion/Makefile3.mak create mode 100644 dominion/Makefile_old create mode 100644 dominion/randomtestcard1.c create mode 100644 dominion/randomtestcard2.c create mode 100644 dominion/randomtestcard3.c create mode 100644 dominion/unittest1.c create mode 100644 dominion/unittest2.c create mode 100644 dominion/unittest3.c create mode 100644 dominion/unittest4 create mode 100644 dominion/unittest4.c create mode 100644 dominion/unittest4.gcda create mode 100644 dominion/unittest4.gcno create mode 100644 dominion/unittest5.c diff --git a/dominion/Makefile b/dominion/Makefile index 5541801f3..4a9d67348 100644 --- a/dominion/Makefile +++ b/dominion/Makefile @@ -1,31 +1,68 @@ -CFLAGS= -Wall -fpic -coverage -lm -std=c99 +CFLAGS= -Wall -fpic -coverage -lm -std=c99 -g + +unittestresults: unittest1 unittest2 unittest3 unittest4 unittest5 \ + randomtestcard2 randomtestcard3 runtests + #randomtestcard1 randomtestcard2 randomtestcard3 runtests rngs.o: rngs.h rngs.c - gcc -c rngs.c -g $(CFLAGS) + gcc -c rngs.c $(CFLAGS) dominion.o: dominion.h dominion.c rngs.o - gcc -c dominion.c -g $(CFLAGS) + gcc -c dominion.c $(CFLAGS) + +unittest1: dominion.o rngs.o unittest1.c + gcc -o unittest1 unittest1.c dominion.o rngs.o $(CFLAGS) + #./unittest1 + +unittest2: dominion.o rngs.o unittest2.c + gcc -o unittest2 unittest2.c dominion.o rngs.o $(CFLAGS) + #./unittest2 -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*/ +unittest3: dominion.o rngs.o unittest3.c + gcc -o unittest3 unittest3.c dominion.o rngs.o $(CFLAGS) + #./unittest3 -testDrawCard: testDrawCard.c dominion.o rngs.o - gcc -o testDrawCard -g testDrawCard.c dominion.o rngs.o $(CFLAGS) +unittest4: dominion.o rngs.o unittest4.c + gcc -o unittest4 unittest4.c dominion.o rngs.o $(CFLAGS) + #./unittest4 -interface.o: interface.h interface.c - gcc -c interface.c -g $(CFLAGS) +unittest5: dominion.o rngs.o unittest5.c + gcc -o unittest5 unittest5.c dominion.o rngs.o $(CFLAGS) + #./unittest5 -runtests: testDrawCard - ./testDrawCard &> unittestresult.out - gcov dominion.c >> unittestresult.out - cat dominion.c.gcov >> unittestresult.out +randomtestcard1: dominion.o rngs.o randomtestcard1.c + gcc -o randomtestcard1 randomtestcard1.c dominion.o rngs.o $(CFLAGS) + #./randomtestcard1 +randomtestcard2: dominion.o rngs.o randomtestcard2.c + gcc -o randomtestcard2 randomtestcard2.c dominion.o rngs.o $(CFLAGS) + #./randomtestcard2 -player: player.c interface.o - gcc -o player player.c -g dominion.o rngs.o interface.o $(CFLAGS) +randomtestcard3: dominion.o rngs.o randomtestcard3.c + gcc -o randomtestcard3 randomtestcard3.c dominion.o rngs.o $(CFLAGS) + #./randomtestcard3 -all: playdom player +#ifeq (0,1) +runtests: unittest1 unittest2 unittest3 unittest4 unittest5 \ + randomtestcard1 randomtestcard2 randomtestcard3 + ./unittest1 > unittestresults.out + gcov -b -f dominion.c >> unittestresults.out + ./unittest2 >> unittestresults.out + gcov -b -f dominion.c >> unittestresults.out + ./unittest3 >> unittestresults.out + gcov -b -f dominion.c >> unittestresults.out + ./unittest4 >> unittestresults.out + gcov -b -f dominion.c >> unittestresults.out + ./unittest5 >> unittestresults.out + gcov -b -f dominion.c >> unittestresults.out + #./randomtestcard1 >> randomtestresults.out + #gcov -b -f dominion.c >> randomtestresults.out + ./randomtestcard2 >> randomtestresults.out + gcov -b -f dominion.c >> randomtestresults.out + ./randomtestcard3 >> randomtestresults.out + gcov -b -f dominion.c >> randomtestresults.out +#endif clean: - rm -f *.o playdom.exe playdom player player.exe *.gcov *.gcda *.gcno *.so *.out testDrawCard testDrawCard.exe + rm -f *.o unittest1 unittest2 unittest3 unittest4 unittest5 \ + randomtestcard1 randomtestcard2 randomtestcard3 *.gcov *.gcda *.gcno *.out diff --git a/dominion/Makefile3.mak b/dominion/Makefile3.mak new file mode 100644 index 000000000..377d44b80 --- /dev/null +++ b/dominion/Makefile3.mak @@ -0,0 +1,46 @@ +CFLAGS= -Wall -fpic -coverage -lm -std=c99 + +unittestresults: unittest1 unittest2 unittest3 unittest4 unittest5 runtests + +rngs.o: rngs.h rngs.c + gcc -c rngs.c $(CFLAGS) + +dominion.o: dominion.h dominion.c rngs.o + gcc -c dominion.c $(CFLAGS) + +unittest1: dominion.o rngs.o unittest1.c + gcc -o unittest1 unittest1.c dominion.o rngs.o $(CFLAGS) + #./unittest1 + +unittest2: dominion.o rngs.o unittest2.c + gcc -o unittest2 unittest2.c dominion.o rngs.o $(CFLAGS) + #./unittest2 + +unittest3: dominion.o rngs.o unittest3.c + gcc -o unittest3 unittest3.c dominion.o rngs.o $(CFLAGS) + #./unittest3 + +unittest4: dominion.o rngs.o unittest4.c + gcc -o unittest4 unittest4.c dominion.o rngs.o $(CFLAGS) + #./unittest4 + +unittest5: dominion.o rngs.o unittest5.c + gcc -o unittest5 unittest5.c dominion.o rngs.o $(CFLAGS) + #./unittest5 + +#ifeq (0,1) +runtests: unittest1 unittest2 unittest3 unittest4 unittest5 + ./unittest1 > unittestresults.out + gcov -b -f dominion.c >> unittestresults.out + ./unittest2 >> unittestresults.out + gcov -b -f dominion.c >> unittestresults.out + ./unittest3 >> unittestresults.out + gcov -b -f dominion.c >> unittestresults.out + ./unittest4 >> unittestresults.out + gcov -b -f dominion.c >> unittestresults.out + ./unittest5 >> unittestresults.out + gcov -b -f dominion.c >> unittestresults.out +#endif + +clean: + rm -f *.o unittest1 unittest2 unittest3 unittest4 unittest5 *.gcov *.gcda *.gcno *.out diff --git a/dominion/Makefile_old b/dominion/Makefile_old new file mode 100644 index 000000000..e14ad1e8b --- /dev/null +++ b/dominion/Makefile_old @@ -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/dominion/dominion.c b/dominion/dominion.c index 739e2605e..8f4591d76 100644 --- a/dominion/dominion.c +++ b/dominion/dominion.c @@ -5,22 +5,25 @@ #include #include -int compare(const void* a, const void* b) { - if (*(int*)a > *(int*)b) +int compare(const void *a, const void *b) +{ + if (*(int *)a > *(int *)b) return 1; - if (*(int*)a < *(int*)b) + if (*(int *)a < *(int *)b) return -1; return 0; } -struct gameState* newGame() { - struct gameState* g = malloc(sizeof(struct gameState)); +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)); +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; @@ -35,7 +38,8 @@ int* kingdomCards(int k1, int k2, int k3, int k4, int k5, int k6, int k7, } int initializeGame(int numPlayers, int kingdomCards[10], int randomSeed, - struct gameState *state) { + struct gameState *state) +{ int i; int j; int it; @@ -65,7 +69,6 @@ int initializeGame(int numPlayers, int kingdomCards[10], int randomSeed, } } - //initialize supply /////////////////////////////// @@ -103,19 +106,21 @@ int initializeGame(int numPlayers, int kingdomCards[10], int randomSeed, state->supplyCount[gold] = 30; //set number of Kingdom cards - for (i = adventurer; i <= treasure_map; i++) //loop all cards + for (i = adventurer; i <= treasure_map; i++) //loop all cards { - for (j = 0; j < 10; j++) //loop chosen 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) { + if (numPlayers == 2) + { state->supplyCount[i] = 8; } - else { + else + { state->supplyCount[i] = 12; } } @@ -125,12 +130,11 @@ int initializeGame(int numPlayers, int kingdomCards[10], int randomSeed, } break; } - else //card is not in the set choosen for the game + else //card is not in the set choosen for the game { state->supplyCount[i] = -1; } } - } //////////////////////// @@ -155,7 +159,7 @@ int initializeGame(int numPlayers, int kingdomCards[10], int randomSeed, //shuffle player decks for (i = 0; i < numPlayers; i++) { - if ( shuffle(i, state) < 0 ) + if (shuffle(i, state) < 0) { return -1; } @@ -191,7 +195,8 @@ int initializeGame(int numPlayers, int kingdomCards[10], int randomSeed, //int it; move to top //Moved draw cards to here, only drawing at the start of a turn - for (it = 0; it < 5; it++) { + for (it = 0; it < 5; it++) + { drawCard(state->whoseTurn, state); } @@ -200,8 +205,8 @@ int initializeGame(int numPlayers, int kingdomCards[10], int randomSeed, return 0; } -int shuffle(int player, struct gameState *state) { - +int shuffle(int player, struct gameState *state) +{ int newDeck[MAX_DECK]; int newDeckPos = 0; @@ -210,19 +215,22 @@ int shuffle(int player, struct gameState *state) { if (state->deckCount[player] < 1) return -1; - qsort ((void*)(state->deck[player]), state->deckCount[player], sizeof(int), compare); + qsort((void *)(state->deck[player]), state->deckCount[player], sizeof(int), compare); /* SORT CARDS IN DECK TO ENSURE DETERMINISM! */ - while (state->deckCount[player] > 0) { + 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]; + 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++) { + for (i = 0; i < newDeckPos; i++) + { state->deck[player][i] = newDeck[i]; state->deckCount[player]++; } @@ -233,7 +241,7 @@ int shuffle(int player, struct gameState *state) { int playCard(int handPos, int choice1, int choice2, int choice3, struct gameState *state) { int card; - int coin_bonus = 0; //tracks coins gain from actions + int coin_bonus = 0; //tracks coins gain from actions //check if it is the right phase if (state->phase != 0) @@ -242,7 +250,7 @@ int playCard(int handPos, int choice1, int choice2, int choice3, struct gameStat } //check if player has enough actions - if ( state->numActions < 1 ) + if (state->numActions < 1) { return -1; } @@ -251,13 +259,13 @@ int playCard(int handPos, int choice1, int choice2, int choice3, struct gameStat card = handCard(handPos, state); //check if selected card is an action - if ( card < adventurer || card > treasure_map ) + if (card < adventurer || card > treasure_map) { return -1; } //play card - if ( cardEffect(card, choice1, choice2, choice3, state, handPos, &coin_bonus) < 0 ) + if (cardEffect(card, choice1, choice2, choice3, state, handPos, &coin_bonus) < 0) { return -1; } @@ -271,9 +279,11 @@ int playCard(int handPos, int choice1, int choice2, int choice3, struct gameStat return 0; } -int buyCard(int supplyPos, struct gameState *state) { +int buyCard(int supplyPos, struct gameState *state) +{ int who; - if (DEBUG) { + if (DEBUG) + { printf("Entering buyCard...\n"); } @@ -281,20 +291,27 @@ int buyCard(int supplyPos, struct gameState *state) { who = state->whoseTurn; - if (state->numBuys < 1) { + if (state->numBuys < 1) + { if (DEBUG) printf("You do not have any buys left\n"); return -1; - } else if (supplyCount(supplyPos, state) <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)) { + } + 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; + } + 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) @@ -310,63 +327,75 @@ int buyCard(int supplyPos, struct gameState *state) { return 0; } -int numHandCards(struct gameState *state) { - return state->handCount[ whoseTurn(state) ]; +int numHandCards(struct gameState *state) +{ + return state->handCount[whoseTurn(state)]; } -int handCard(int handPos, struct gameState *state) { +int handCard(int handPos, struct gameState *state) +{ int currentPlayer = whoseTurn(state); return state->hand[currentPlayer][handPos]; } -int supplyCount(int card, struct gameState *state) { +int supplyCount(int card, struct gameState *state) +{ return state->supplyCount[card]; } -int fullDeckCount(int player, int card, struct gameState *state) { +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++; + if (state->deck[player][i] == card) + count++; } for (i = 0; i < state->handCount[player]; i++) { - if (state->hand[player][i] == card) count++; + if (state->hand[player][i] == card) + count++; } for (i = 0; i < state->discardCount[player]; i++) { - if (state->discard[player][i] == card) count++; + if (state->discard[player][i] == card) + count++; } return count; } -int whoseTurn(struct gameState *state) { +int whoseTurn(struct gameState *state) +{ return state->whoseTurn; } -int endTurn(struct gameState *state) { +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 + 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 + 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 + 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 + else + { + state->whoseTurn = 0; //Max player has been reached, loop back around to player 1 } state->outpostPlayed = 0; @@ -379,8 +408,9 @@ int endTurn(struct gameState *state) { //int k; move to top //Next player draws hand - for (k = 0; k < 5; k++) { - drawCard(state->whoseTurn, state);//Draw a card + for (k = 0; k < 5; k++) + { + drawCard(state->whoseTurn, state); //Draw a card } //Update money @@ -389,7 +419,8 @@ int endTurn(struct gameState *state) { return 0; } -int isGameOver(struct gameState *state) { +int isGameOver(struct gameState *state) +{ int i; int j; @@ -408,7 +439,7 @@ int isGameOver(struct gameState *state) { j++; } } - if ( j >= 3) + if (j >= 3) { return 1; } @@ -416,83 +447,103 @@ int isGameOver(struct gameState *state) { return 0; } -int scoreFor (int player, struct gameState *state) { +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) { + if (state->hand[player][i] == curse) + { score = score - 1; }; - if (state->hand[player][i] == estate) { + if (state->hand[player][i] == estate) + { score = score + 1; }; - if (state->hand[player][i] == duchy) { + if (state->hand[player][i] == duchy) + { score = score + 3; }; - if (state->hand[player][i] == province) { + if (state->hand[player][i] == province) + { score = score + 6; }; - if (state->hand[player][i] == great_hall) { + if (state->hand[player][i] == great_hall) + { score = score + 1; }; - if (state->hand[player][i] == gardens) { - score = score + ( fullDeckCount(player, 0, state) / 10 ); + 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) { + if (state->discard[player][i] == curse) + { score = score - 1; }; - if (state->discard[player][i] == estate) { + if (state->discard[player][i] == estate) + { score = score + 1; }; - if (state->discard[player][i] == duchy) { + if (state->discard[player][i] == duchy) + { score = score + 3; }; - if (state->discard[player][i] == province) { + if (state->discard[player][i] == province) + { score = score + 6; }; - if (state->discard[player][i] == great_hall) { + if (state->discard[player][i] == great_hall) + { score = score + 1; }; - if (state->discard[player][i] == gardens) { - score = score + ( fullDeckCount(player, 0, state) / 10 ); + 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) { + if (state->deck[player][i] == curse) + { score = score - 1; }; - if (state->deck[player][i] == estate) { + if (state->deck[player][i] == estate) + { score = score + 1; }; - if (state->deck[player][i] == duchy) { + if (state->deck[player][i] == duchy) + { score = score + 3; }; - if (state->deck[player][i] == province) { + if (state->deck[player][i] == province) + { score = score + 6; }; - if (state->deck[player][i] == great_hall) { + if (state->deck[player][i] == great_hall) + { score = score + 1; }; - if (state->deck[player][i] == gardens) { - score = score + ( fullDeckCount(player, 0, state) / 10 ); + 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 getWinners(int players[MAX_PLAYERS], struct gameState *state) +{ int i; int j; int highScore; @@ -508,7 +559,7 @@ int getWinners(int players[MAX_PLAYERS], struct gameState *state) { } else { - players[i] = scoreFor (i, state); + players[i] = scoreFor(i, state); } } @@ -527,7 +578,7 @@ int getWinners(int players[MAX_PLAYERS], struct gameState *state) { currentPlayer = whoseTurn(state); for (i = 0; i < MAX_PLAYERS; i++) { - if ( players[i] == highScore && i > currentPlayer ) + if (players[i] == highScore && i > currentPlayer) { players[i]++; } @@ -537,7 +588,7 @@ int getWinners(int players[MAX_PLAYERS], struct gameState *state) { j = 0; for (i = 0; i < MAX_PLAYERS; i++) { - if ( players[i] > players[j] ) + if (players[i] > players[j]) { j = i; } @@ -547,7 +598,7 @@ int getWinners(int players[MAX_PLAYERS], struct gameState *state) { //set winners in array to 1 and rest to 0 for (i = 0; i < MAX_PLAYERS; i++) { - if ( players[i] == highScore ) + if (players[i] == highScore) { players[i] = 1; } @@ -561,58 +612,65 @@ int getWinners(int players[MAX_PLAYERS], struct gameState *state) { } int drawCard(int player, struct gameState *state) -{ int count; +{ + int count; int deckCounter; - if (state->deckCount[player] <= 0) { //Deck is empty + 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++) { + 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 + state->discardCount[player] = 0; //Reset discard //Shufffle the deck - shuffle(player, state);//Shuffle the deck up and make it so that we can draw + shuffle(player, state); //Shuffle the deck up and make it so that we can draw - if (DEBUG) { //Debug statements + 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 + count = state->handCount[player]; //Get current player's hand count - if (DEBUG) { //Debug statements + if (DEBUG) + { //Debug statements printf("Current hand count: %d\n", count); } - deckCounter = state->deckCount[player];//Create a holder for the deck 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->hand[player][count] = state->deck[player][deckCounter - 1]; //Add card to hand state->deckCount[player]--; - state->handCount[player]++;//Increment hand count + state->handCount[player]++; //Increment hand count } - else { - int count = state->handCount[player];//Get current hand count for player + else + { + int count = state->handCount[player]; //Get current hand count for player int deckCounter; - if (DEBUG) { //Debug statements + 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 + 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 + state->handCount[player]++; //Increment hand count } return 0; @@ -620,7 +678,7 @@ int drawCard(int player, struct gameState *state) int getCost(int cardNumber) { - switch( cardNumber ) + switch (cardNumber) { case curse: return 0; @@ -681,121 +739,124 @@ int getCost(int cardNumber) return -1; } -int doMine(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) +void supplyEstate(struct gameState *state, int player) { - int i; - int j; - - j = state->hand[currentPlayer][choice1]; //store card we will trash - - if (/*state->hand[currentPlayer][choice1] < copper ||*/ state->hand[currentPlayer][choice1] > gold) + if (supplyCount(estate, state) > 0) { - return -1; - } + gainCard(estate, state, 0, player); //Gain an estate - if (choice2 > treasure_map || choice2 < curse) - { - return -1; - } - - if ( (getCost(state->hand[currentPlayer][choice1]) + 3) > getCost(choice2) ) - { - return -1; + state->supplyCount[estate]--; //Decrement Estates + if (supplyCount(estate, state) == 0) + { + isGameOver(state); + } } +} +void increaseTreasure(struct gameState *state, int amount) +{ + state->coins += amount; +} - //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++) +void putDiscardedInDeck(struct gameState *state, int player) +{ + int i; + if (state->deckCount[player] == 0) { - if (state->hand[currentPlayer][i] == j) + for (i = 0; i < state->discardCount[player]; i++) { - discardCard(i, currentPlayer, state, 0); - break; + state->deck[player][i] = state->discard[player][i]; //Move to deck + state->deckCount[player]++; + state->discard[player][i] = -1; + state->discardCount[player]--; } - } - return 0; + shuffle(player, state); //Shuffle the deck + } } -void getEstateCard(struct gameState *state, int currentPlayer) +int discardTopCardFromDeck(struct gameState *state, int player) { - if (supplyCount(estate, state) > 0) { - gainCard(estate, state, 0, currentPlayer);//Gain an estate + int cardToDiscard = state->deck[player][state->deckCount[player] - 1]; + state->deck[player][state->deckCount[player]--] = -1; + state->deckCount[player]--; - state->supplyCount[estate]--;//Decrement Estates - if (supplyCount(estate, state) == 0) { - isGameOver(state); - } - } + state->discard[player][state->discardCount[player]] = cardToDiscard; + state->discardCount[player]++; + return cardToDiscard; } -void doBaron(int choice1, struct gameState *state, int currentPlayer) +int baronEffect(struct gameState *state, int choiceDiscardCard) { - state->numBuys++;//Increase buys by 1! - state->numBuys++;//Increase buys by 1! - if (choice1 > 0) { //Boolean true or going to discard an estate - int p = 1; //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 + int currentPlayer = whoseTurn(state); + state->numBuys++; //Increase buys by 1! + if (choiceDiscardCard > 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! + increaseTreasure(state, 5); //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]; + 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 + card_not_discarded = 0; //Exit the loop } - else if (p > state->handCount[currentPlayer]) { - if(DEBUG) { + 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"); } - getEstateCard(state, currentPlayer); - card_not_discarded = 0;//Exit the loop + supplyEstate(state, currentPlayer); } - else { - p++;//Next card + else + { + p++; //Next card } } } - else { - getEstateCard(state, currentPlayer); + else + { + supplyEstate(state, currentPlayer); } + + return 0; } -void doMinion(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) +int minionEffect(struct gameState *state, int choiceGainCoins, int choiceDiscard, int handPos) { - int i; - int j; - + int currentPlayer = whoseTurn(state); //+1 action state->numActions++; //discard card from hand discardCard(handPos, currentPlayer, state, 0); - if (choice1) + if (choiceGainCoins) { - state->coins = state->coins + 2; + increaseTreasure(state, 3); //Add 4 coins to the amount of coins } - else if (choice2) //discard hand, redraw 4, other players with 5+ cards discard hand and draw 4 + else if (choiceDiscard) //discard hand, redraw 4, other players with 5+ cards discard hand and draw 4 { //discard hand - while(numHandCards(state) > 1 /*0*/) + while (numHandCards(state) > 0) { discardCard(handPos, currentPlayer, state, 0); } //draw 4 + int i, j; for (i = 0; i < 4; i++) { drawCard(currentPlayer, state); @@ -804,143 +865,75 @@ void doMinion(int choice1, int choice2, struct gameState *state, int handPos, in //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) { - //if ( state->handCount[i] > 4 ) + //discard hand + while (state->handCount[i] > 0) { - //discard hand - while( state->handCount[i] > 0 ) - { - discardCard(handPos, i, state, 0); - } - - //draw 4 - for (j = 0; j < 4; j++) - { - drawCard(i, state); - } + discardCard(handPos, i, state, 0); } - } - } - } -} - -void doTribute(struct gameState *state, int currentPlayer, int nextPlayer, int tributeRevealedCards[2]) -{ - int i; - - 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]--; + //draw 4 + for (j = 0; j < 4; j++) + { + drawCard(i, state); + } } - - 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->numActions = state->numActions + 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->coins += 2; + } } + return 0; } -int doAmbassador(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) +int ambassadorEffect(struct gameState *state, int cardToDiscard, int numberOfCardsToDiscard, int handPos) { - int i; - int j; - j = 0; //used to check if player has enough cards to discard + int currentPlayer = whoseTurn(state); + int i, j; + j = 0; //used to check if player has enough cards to discard - if (choice2 > 3 || choice2 < 0) + if (numberOfCardsToDiscard > 2 || numberOfCardsToDiscard < 0) { return -1; } -/* - if (choice1 == handPos) + else if (cardToDiscard == handPos) { return -1; } - */ for (i = 0; i < state->handCount[currentPlayer]; i++) { - if (i != handPos && i == state->hand[currentPlayer][choice1] && i != choice1) + if (i != handPos && i == state->hand[currentPlayer][cardToDiscard] && i != cardToDiscard) { j++; } } - if (j < choice2) + if (j < numberOfCardsToDiscard) { return -1; } if (DEBUG) - printf("Player %d reveals card number: %d\n", currentPlayer, state->hand[currentPlayer][choice1]); + printf("Player %d reveals card number: %d\n", currentPlayer, state->hand[currentPlayer][cardToDiscard]); - //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); + gainCard(state->hand[currentPlayer][cardToDiscard], 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 (j = 0; j < numberOfCardsToDiscard; j++) { for (i = 0; i < state->handCount[currentPlayer]; i++) { - if (state->hand[currentPlayer][i] == state->hand[currentPlayer][choice1]) + if (state->hand[currentPlayer][i] == state->hand[currentPlayer][cardToDiscard]) { discardCard(i, currentPlayer, state, 1); break; @@ -951,6 +944,110 @@ int doAmbassador(int choice1, int choice2, struct gameState *state, int handPos, return 0; } +int tributeEffect(struct gameState *state, int handPos) +{ + + int currentPlayer = whoseTurn(state); + int nextPlayer = currentPlayer + 1; + int tributeRevealedCards[2] = {-1, -1}; + int i; + + + 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 + { + + putDiscardedInDeck(state, nextPlayer); + + tributeRevealedCards[0] = discardTopCardFromDeck(state, nextPlayer); + tributeRevealedCards[1] = discardTopCardFromDeck(state, nextPlayer); + } + + if (tributeRevealedCards[0] == tributeRevealedCards[1]) + { //If we have a duplicate card, just drop one + + } + + //discard played card from hand + discardCard(handPos, currentPlayer, state, 0); + + 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; +} + +int mineEffect(struct gameState *state, int treasureToTrash, int treasureToGain, int handPos) +{ + int j, i; + int currentPlayer = whoseTurn(state); + + j = state->hand[currentPlayer][treasureToTrash]; //store card we will trash + + + + if (treasureToGain > treasure_map || treasureToGain < curse) + { + return -1; + } + + else if ((getCost(state->hand[currentPlayer][treasureToTrash]) + 3) > getCost(treasureToGain)) + { + return -1; + } + + gainCard(treasureToGain, state, 2, currentPlayer); + //discard card from hand + + //discard trashed card + for (i = 0; i < state->handCount[currentPlayer]; i++) + { + if (state->hand[currentPlayer][i] == j) + { + discardCard(i, currentPlayer, state, 1); + break; + } + } + + return 0; +} + int cardEffect(int card, int choice1, int choice2, int choice3, struct gameState *state, int handPos, int *bonus) { int i; @@ -961,37 +1058,40 @@ 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 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)) { + 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 ) + 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 + 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. + 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; + 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; + 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; @@ -1008,7 +1108,7 @@ int cardEffect(int card, int choice1, int choice2, int choice3, struct gameState //Each other player draws a card for (i = 0; i < state->numPlayers; i++) { - if ( i != currentPlayer ) + if (i != currentPlayer) { drawCard(i, state); } @@ -1022,49 +1122,58 @@ int cardEffect(int card, int choice1, int choice2, int choice3, struct gameState 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 + 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) { + 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) { + if (DEBUG) + { printf("Cards Left: %d\n", supplyCount(choice1, state)); } } - else if (state->coins < getCost(choice1)) { + else if (state->coins < getCost(choice1)) + { printf("That card is too expensive!\n"); - if (DEBUG) { + if (DEBUG) + { printf("Coins: %d < %d\n", state->coins, getCost(choice1)); } } - else { + else + { - if (DEBUG) { + 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 + gainCard(choice1, state, 0, currentPlayer); //Gain the card + x = 0; //No more buying cards - if (DEBUG) { + 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++) { + for (i = 0; i <= state->handCount[currentPlayer]; i++) + { state->hand[currentPlayer][i] = temphand[i]; temphand[i] = -1; } @@ -1076,12 +1185,12 @@ int cardEffect(int card, int choice1, int choice2, int choice3, struct gameState return -1; case mine: - return doMine(choice1, choice2, state, handPos, currentPlayer); + return mineEffect(state, choice1, choice2, handPos); case remodel: - j = state->hand[currentPlayer][choice1]; //store card we will trash + j = state->hand[currentPlayer][choice1]; //store card we will trash - if ( (getCost(state->hand[currentPlayer][choice1]) + 2) > getCost(choice2) ) + if ((getCost(state->hand[currentPlayer][choice1]) + 2) > getCost(choice2)) { return -1; } @@ -1101,7 +1210,6 @@ int cardEffect(int card, int choice1, int choice2, int choice3, struct gameState } } - return 0; case smithy: @@ -1127,9 +1235,7 @@ int cardEffect(int card, int choice1, int choice2, int choice3, struct gameState return 0; case baron: - doBaron(choice1, state, currentPlayer); - return 0; - + return baronEffect(state, choice1); case great_hall: //+1 Card drawCard(currentPlayer, state); @@ -1142,8 +1248,7 @@ int cardEffect(int card, int choice1, int choice2, int choice3, struct gameState return 0; case minion: - doMinion(choice1, choice2, state, handPos, currentPlayer); - return 0; + return minionEffect(state, choice1, choice2, handPos); case steward: if (choice1 == 1) @@ -1169,11 +1274,10 @@ int cardEffect(int card, int choice1, int choice2, int choice3, struct gameState return 0; case tribute: - doTribute(state, currentPlayer, nextPlayer, tributeRevealedCards); - return 0; + return tributeEffect(state, handPos); case ambassador: - return doAmbassador(choice1, choice2, state, handPos, currentPlayer); + return ambassadorEffect(state, choice1, choice2, handPos); case cutpurse: @@ -1199,9 +1303,7 @@ int cardEffect(int card, int choice1, int choice2, int choice3, struct gameState break; } } - } - } //discard played card from hand @@ -1209,13 +1311,12 @@ int cardEffect(int card, int choice1, int choice2, int choice3, struct gameState return 0; - case embargo: //+2 Coins state->coins = state->coins + 2; //see if selected pile is in play - if ( state->supplyCount[choice1] == -1 ) + if (state->supplyCount[choice1] == -1) { return -1; } @@ -1242,7 +1343,7 @@ int cardEffect(int card, int choice1, int choice2, int choice3, struct gameState if (choice1) { //gain coins equal to trashed card - state->coins = state->coins + getCost( handCard(choice1, state) ); + state->coins = state->coins + getCost(handCard(choice1, state)); //trash card discardCard(choice1, currentPlayer, state, 1); } @@ -1252,12 +1353,14 @@ int cardEffect(int card, int choice1, int choice2, int choice3, struct gameState return 0; case sea_hag: - for (i = 0; i < state->numPlayers; i++) { - if (i != currentPlayer) { + 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 + state->deck[i][state->deckCount[i]--] = curse; //Top card now a curse } } return 0; @@ -1311,12 +1414,12 @@ int discardCard(int handPos, int currentPlayer, struct gameState *state, int tra state->hand[currentPlayer][handPos] = -1; //remove card from player's hand - if ( handPos == (state->handCount[currentPlayer] - 1) ) //last card in hand array is played + 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 + else if (state->handCount[currentPlayer] == 1) //only one card in hand { //reduce number of cards in hand state->handCount[currentPlayer]--; @@ -1324,7 +1427,7 @@ int discardCard(int handPos, int currentPlayer, struct gameState *state, int tra else { //replace discarded card with last card in hand - state->hand[currentPlayer][handPos] = state->hand[currentPlayer][ (state->handCount[currentPlayer] - 1)]; + 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 @@ -1339,7 +1442,7 @@ 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 ) + if (supplyCount(supplyPos, state) < 1) { return -1; } @@ -1351,17 +1454,17 @@ int gainCard(int supplyPos, struct gameState *state, int toFlag, int player) if (toFlag == 1) { - state->deck[ player ][ state->deckCount[player] ] = supplyPos; + state->deck[player][state->deckCount[player]] = supplyPos; state->deckCount[player]++; } else if (toFlag == 2) { - state->hand[ player ][ state->handCount[player] ] = supplyPos; + state->hand[player][state->handCount[player]] = supplyPos; state->handCount[player]++; } else { - state->discard[player][ state->discardCount[player] ] = supplyPos; + state->discard[player][state->discardCount[player]] = supplyPos; state->discardCount[player]++; } @@ -1401,5 +1504,4 @@ int updateCoins(int player, struct gameState *state, int bonus) return 0; } - //end of dominion.c diff --git a/dominion/dominion.gcda b/dominion/dominion.gcda index 515b2ab339e379017450699dad5a9e4797f0fae4..863dde89a3e322287211d204bbe43a03b10be05e 100644 GIT binary patch literal 4144 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 diff --git a/dominion/dominion.gcno b/dominion/dominion.gcno index d2c549165199836c29bd476271e3a270240c5c26..ffbf6b315500a6c480558296c2882ab3d94288c6 100644 GIT binary patch delta 8185 zcmZu$4OCRuwdTNFoQX&VXABn^aFkKOt3E_cP%(7~|yfB+SOpCO=68?9p+TpsmSTXM0o zy`=>N{0{Vc3JY{lYpSl^70x|aS69Fp>fc3P5U8sUC|NVqe~8=({eMyi^eCx08iREA zf1#Q#P@hK{jRsKr(ihQ`801l>e3?PZly(YsKkaSkj5PErDl)V-XkL?sUgwIbQq#3_ zz}^t471F;#x*$@Qrn}oAT>|xaq}3<@g*hDqNe}j@?Y^nOk11_C>?)*WT|Zr`g0x$t z3y^9c?H51l#4qmfbK*w>Wm*l}5$KPCj&rBo&x7mpNQ*82PfWJVDLnYdFX)=pZHu(9 zNwRv*7iK#XsGg-a`#<&Myq;pIJ?|&+R-mOl^0JnuWdkoeq9Xx30~y2I|kLkOxy^Vso3XnpgQWXhtny025i2we~jM`!hVF` zyn#>Pw{4&UzhTaBja{8D+fw$Jr zz3U*E@iWI{1>}`I*jl{(p0g*6=YjfqvI=r0i0fDb^4qh__-giO-fD1MTi=%0I;#iE z#oJ$!TVgyLqDG>h)z}-KhJQ+8DxZFmN`Is?d{C<13DU|pWK0wP;x|p>SiyxrniM|QM zzLtUfW5sPVzFB6#W^kp#m4Yi1j;+hN-d*M3`ufD9!wY9Si0kps&#mCLff#!l;o{iISBH%h57;m4pMW3F^D(e zVI~d(erBr>x*icZAO`3NP%J2pu0%TsNslaUJ9R}{s5L=X{~{=7f&}4CE!L^t?Iccq zj|$SYS67MDjIzi@+9cF8S@5i_x|%}C!0V^zw#R`_15FoQ>s)_*cc$oSrj)k3bZs^) z=7_~~7vtk?h12zPCXPVQk&n!Zt2X@cBwF=D4yc{4|xf`WZWsKR^`Xjo^gSUol9qPyj<%vygw63sxqYbSHSTQg|Z4!-r zh_0RyE@_BP(}z1LAMcbAPC5k5LD94W$?}*j+ydGpgpF_I2zn5!exMKqfJ8%^}5Kdkk1KsZ77;YW!7Q3 zdXt6@^IK#=z9<%T;5vjm5AN4=1vaK^kI~g{MUw>XvT*q^I?Wn|4#w!(yKw0}YK!61 z5r^pxtUeUZ<>7M?CWM+#DkxmL2Fp)GQwB{JHFyk4HxLL&p9y{!+)d$PhwJLElsw!} zw?wWSu2cSKa{ybwyT>@`Dr~-{ZrFS$Ht{2L^}oWc0{6XewIg&o4cpg&SmZF%1>`P} zkdeCTCrIK*ozllTDHlk8LF$220=WPrRFE4$TE>P_bYL(!V|6u9(4*kOnNzvkL#gFA zu~NUvXGBGdohwdPZa!YA^)eD3EcTJ2Nr5I#4qjz(x;6%Qywq1HrN>E`A}KQwxS@fDG|+7Xr_r~la!hvHNQSeSF?osbd*kZ%}(w>iz=r!%mqH*+6`T$3YTQ)gVIpP zKOSrg5Vmn`0~SED5VQz{GY3i@@|VQ4=RPhK|2?C1Z3S#rvW?m)noQB`fMyLeSyH-X zw608>-C~m?sCA4^w*pNcs|8;t_ypkgKqqD4orHH?kNhd#halU>>I#_-Ek27n0? zj*IPo^~2K4&+~aFEi5R?o4s~zUJeo=%elos3W|%y<^%+M%K*-#4hpj^q_qB%H8_cb zu00m246%?q&q9~&cDlRAtqp{&g}P@MWZ7<~y7&<7VJTf$ zZP4jjdt;)7>T5%6T%{cpLYdpAP-}!s<7WSlhE8@6pS-_^q-3h{E*m5q@3O(dVNaz~ z(K78D=VD$(J840>t{xU;)_7foncP;LVuv{CPBLaP-n^}vHq$5Q<8-XMK93pzVKC_D zZ@#+v&h3;MR+nuq$SyDI87jJ>9Lh)CW1Fb5!b6q)?V6PaSo)fr-Gob95dOzefrt&~;nAy25CI^!)-JY<|mc|1&?%tI&311Tag zlHSR5MMd7HbwJiZT+&Gm(;P~ts>DeAKA#w=iH5odgwx4!R{A#4PPY=R;)r!p3I-u8 z!5noT#`zp=igeJ`*}ClwNasNpXj6irekIX3IZxNxfpt*BUDpU>-xiqD z-3P*PXr@P6$TL1xU8S~ULw!sOrx@zGXb}nZCu)QIXOTIL{Y5yWF}mi$OkS#EZ}Uzx z)NR3$py)yr64gX5$u1y4QGHbChyWFeu1A1gTxuQu{=AzRJgK~e+1}DpZ*K8sbAD5& za@w}RQJ&I6sbi%-c-G!&Jsz772kve#HoJ9LZ2c_Q-mc7wR0AmNV7QHA!jnUhw-R5Q zc^=BBb!j%PlB)K=p?I^dFd8?_AvL^n&?TjuQfkaNgEH1S$8enac?86+`cGjj^A~Vm zES!dhIuNrEjpMH9;@WU}Db#M`2^z(=ItX|XO*7|!hvoD!htqz_#|SM z!|5ZiHHcmr`-uK@)z`0G>>ty@K{5BNf5e&GlY@hjl?xkJIXzytl-g6QgMwvD_{UsT zJX(Y0^Y+fJ5Uh+4vi5V5t1<*jb%L_eautc_?~IS+@ut+}_BbxVQ;j!&et1Lc8!MK1 z8d~Ujd^n}7wrgRK9CYPiByWpRyi)zK=NZwrtP^Y0LHTP#sB6G1Dp_rz3v2BIc;)lM z(bgzp5;oq5SoF@K=JrN&9-^5l>oiTqkN3$1<|qg1v|};B}Z8kxIsATPvh@8;s7p6tVN-{j+DpilCdq3qPQ%Yle=2SsZAp+h3t zR}8t~v2eLakd?`Wdg9Ab3gyp>e~O(s<`0e?M~h?k7`am|RExC5`G`Gvq<6H#A?dPD zb}rX#gCRwNqRdfAz}A(F6oheaO}0}dw!fDBx@{ONVn80Lg>R`wh{U_?gz>s97E&B& zl+=QFP}U5jbfmBG5|Ko~dCQFAsHkbY=IG8O3*WW)AH}necaYC3;>X^&nfWo#_uPWg z9Pj4b^x~44c+J^dTsSK)2VdW4?4L&47DQ<$Rv;a;MMP%XpzRL|0Sy2>46=j5Kz$zB zbq4{ct_XUwfBLrZJhUa{WwXpS^K$1EJ-D%N1L=#ClaV^HTRe(+UWYk9-$ErBDacF6 zg!`=2@_elJZ6Kcm8kQSWGS`kBxGEts><3`%Jm35Tg1#s3Vnb;dAA=T54IbO;o;b&A z?2}=8+s^NaKh4e+6ykxP9L_~lnKqj4qAX|R*fb~cQvZXg#b(_}Lzf!rJ&_k+JAYp|UiKdf#~b=px&oVz zs3F@>*97g%#(8yqDE(nhu;lN~nZZ=EYy>j;*=6CDAAUN$o-Qx*sI|V^%U)F4T6BHA zbiIVSmm|Sq$!!K!3StDC&SHzU71DMdTt13aL8z9I=5_Wgq=RS}b7+a3+E=)2^*|ax zjp7dPeN7a$(xA?z7Tb%!Pl1|wh+L<^^?BsT&-?K!sb|hn{YsB*s2C)xVMsFv>E50LpW#-OHaW3s*QOeyK}6W!8w$EEJAI^CavHEgdx?3m_=V zMT4N=lY{3eXWBJXwah@4NX{`-4i)BvTMEYCn?yd|ciy9_Ee21HHMsY{kua%9=45`6IVV371-3f61q4?iq!-IM z9pArP1RbSo8*!C^qs3Ry@LY74m~-)_Snwss=cX-^&u!s&K7L7U8x7TMYGCts;W!z6 zZE`qXd_&$sgAT2c%MNPC8&@6pGUk>q95Gwui;X~YD2w zhnQ*1F}tf z+;sFfP*I9logHIy1;FAAmKl|E$oXz_j* zT`hI1r+wd*{#I#EqmrFmwW_4KS8@*YqnEv#`+$sAqV3#pc>stk2Nro(e|c8d|! z0JITAphKX;pd+9r&dXv!^>d7+wV;ReI?6X^Op(tS?!t<8>2)V|ddSf)6W zN#ZVp?H2NG3%9&uiTfq(*cNMBA;o(>X?^#$ol^p30$w9M@Jj4?(PqoAU@^e!Jn?#+ z==k82&)xy$dBSOW19^8FIQYOrs@!6JUv3aB@1reSLPO2})Es_S=OHBB~+5?*r;v@HV6gWeTmfproZxbW} z=XZzF>Y8BuXQxd@fu!CpKh9mIkP4_bM7!obz&6;nNt&;~2bd}qpqxm1>Vf!nLJ_p^9-tg7J7j*qV zxTRlg+aS7oAl4QOC9lYtzA#&u@;zQRB3NTAUIt-Y?;uQ&?mx<{b0(V%lc}P_`G8K5 ztVoqC2>&siZ=^q6+I`CWL(z?T4zF`w5L3CBr%scC~vaRsTvhRy#c z)oS#|K`DoITQ=Ix0p(J`VPil(xB}365bk&n8>(1p;4d}L5&2T19e8v0*g^}B7;2m7 z@wL|2gj>QR46_?Iz*UiIGSnU!@oAM_{W0SkMS2J>ynO{I=&`;nW~N% zwieWI7WA^{%}e6z#|-T}uyYi4+=#jW?jq<{pnn6kgE~N$KyOQ_jmL32eZrhCxJ0IF z$DM?WW9q84&{x%Vx^rB|pW)XJIIMi)OnB^-Psnp3787~g$(8id2^Y94Cq~+0p!9%- zQ`p~ zFwwB4`Rq>JU})}b%4WoCGjdob*RXRCLCsmu; zoDbdtq1r($2DL<}%ck}&2elH=>yx1k1mo!37w#e*;#1DfsUZ`T>4ctJYS#7D=0H%< z{ysKqa|o!RY>65!mhliriXEe9Rj6ef19<}A9v-N7Jg{D$^cV$3TH4b`?Yn>VFpZp_hi_m;8b%?P9FesSs$J>PGB#+;s3(tFDJC>0>HhhEWBuIwp` zP_n$Nhpy-;xAyRNcczCeQ>wo6necvGbVNL@BI_YEL~*)eo8kfWbfwU#>M6IMo8le~ zrB?d_P+!v+0JzZJW()01Ub^z)8(vE^{uZG?qoB1!O3L zf~G63$pf6n(&6)f^|pwmJnRJkwsIjrQH|5zY6hsK)EMTblg`l5th*TC|NNs_1Y#*5 zFv5V&60T(~VX0uOvrKGX2F!1JhRgb=F|y0+r3O1aOKM~R+Xyh}oXZ`x0T>5?$HxB5 z2CN4d^nWgQTuFvBQw1M`A3S(7Ig$I5t3}U*F2RXYC z*zMuvSz8QXGfM#e&+k0u->%O(rQBLn=}$;`?w7N4c==CAc|}wL*z_uZBIWi^rA?qV zOJFy%Ofc5i!flybfYno(+qruuuz*9k+y>a*!`p$fcZitJynv(Fc}(Bl2GiUQf4cyI z_F13lULM#jb80u3wY?O%LN%ZUz@0q=2pGaL=06Bvytj-yVE&#SSzykx4!6&31!e@( z)j=bL^P>vfC^xVdz!eSx6m@97UmpgwPolLC*Z~0R2O50@*nXDo-VcnWy}M+ZHTbIo z1ZuL`O!xAOxP^PZopI^fOiS-A(hRv&;qyJK2xj9QtM2#rppry^)Y4KYk?PYzoo8Qh{U&)ZxhA@(J6Ws0i=-Vo-wAdJ zn4-T8vTVU{QXhb#t|%P1M>H7;b~+Vp&~rz$X@lerk+clf6rbRtljWLTMA;4cGRou% zt-PX92rPzjhgiyAqiu+$>rr+(JH%s)Lp!4Z7Hc+nwMvjGab8WO1Cdf3)oKEjc`b7i zl%~*euSE-B!WmS*4DA%r4vWz$Rj?#r_ftlUrDhA=0D7)qCu207^w{ZqltI@-OAWPD zhRBkKqPIavS)SCSQD&iJ`pi(RR*FV9uq?qm!!(^8jnwFq_{ zSgT-qq*g}-O9l3%V5K89rFvb|3eMBQIScF=##AnkNBvyzHI$O9MgBG9{~}mgtX40G zbe;Ht+xZ!I(nr%>noh*HRG~ETGIc~dRgpO8w{XyDsa7nqGa@UY8$+Yj8`AJq)J+`b zBG)Kwo`?2ZqFpZ9Z;N&Xl}*qFMDI(5!ckg%DA*Zb|0P)WC`8-mQd^|jRpBkRwEC1W z!~tWAyoMHj_-06Ex1BnC(YDVZ`5bUvw0F>j5*fYPMHveyxqTt1_q(RfoZ_=ufO?3+8dwV2_u5?N>Yl}2MLYZ|Vo5mP1cl4+PcKN=b zLs+Co~@ihk#jhbDE1vCuoF*xAxKm ztw@f5M`f!%o2SiIwDP2E|Hnm#xBsUF^N!`^hfSX{lU;-@pW0Dk!&lFXoVWZJNF`gU zgBp`8^-JdRhW|WuBwK#vWIg)dIb=V4GJDxM^FCX9?~2)PSS-#fSzNwh&8EtHx}co4 zDN-W^p}De<5PiGJp$rN{oqUP*CL_$jlPHjGaE%a(NpzB3g;7hRozjd@YMC8I-8lxO zDwk=KCek+y;W*Ha4PFY}6-$c~?UcOBFgc=%V&*uhdxH@!6gV7ngHoETNRC18__#nv z(HDu)DvE65qD_C49jWec!64;G8&ovKO|!uB6+vnn@k0&ZcP|T0cWByN*TTGj5(g&K@oVM>`gS zy9BTlune$BLNrr5R)F~7o1r2oH#3?_XBv)GkYoc^19AYlJYVSSOgrVwH6&@s2e$yQ zPG-$Uv6*Mh1Ck&V3eB_SXZO2!Hk1kj$G@uNd4ba@Wug^Vg$8r#E`;OuDnE-S1l*D(8`voOvFF)y@GLFCxuR+geuWC1SOh)Pzj=OTW zL9K~lw7#F6YQw#eYbBX&SEzob`dlQe#)cOSdnwamnax-0App@4`&)7o-ygRV6s0W z0hi(@y;(ms^N+#6^Gfc^EiWmS4Lq-;NCJEJ+MuAzEX0e1gK`g)sQz@}fRnz?u{Z4t zQ#ShWxSQ7R45R0ALdj>?Z6U0SFOhlM+pox0|^DfSWG z4ie&{Be8qQ>HznuG?hqNxgaz;gEZe{-T-10o$94Ti-NayJV0~HVh z**#2GfASl)P@C_;lK1_V%-8AzI=;-JDJvs9L5f4d+uHSC?EC!L-7gnI(Z9a(>7%8( zPl|G3T`i%AO_R_^M~JhjF}AVW4qPesZHp%!+>8y;ypNh;XvRTZjTpxmEV2#pw0Mr4 zE^W}^ygT#9d#FiWxx>g;6ieMp4YLD%cT&b$OZ|$?r<=><^^Sa*E^3F_uTnyurG6W5 z-)rK&%;hd>$kbGe5_6Z@QL+=yky?%eYI&UJ0uSkjPe#n0|KZ(#OrrLMURBh2Vd0m3 z%p&NOaQAe6l|ffCVzDoAqy|bFJl{epCZU8S+t`6>ho6RgmsnOEur4=v-9mM(6x)0TN@)Ry(O$sxWA?q9H&L$x<#bRVXO%(>lE|Eymlv#lZh~-#|5;3B7lwJ?>?J}qn`Pz(v zg#)DqN65nwqPofmDqb;|5-a_BSq0jRfu2wFI6xyfKq{6l6j-!lEqXy9{nE>2+7l1m zUZ0$Wd^lXV`_yzQUFWksEon{)HeiSC9m-yGCzYm$b~da(X^80O5T9VD;Kox^WT{_J z*B%R57<&YV0~KzzQ$vv<-f5?VVoum%sx0zW`IEyJS(AhDZ*-;DqOUj0Qd7UC-0c>n zK?zP#C#bQ6S0y(Jr>HK$_*ghC7*E|Zlu~M`*MzPv)#~?xCF4rgP{O$YRTtrIh^hOA z2-q{{1j{PZbP+N<3XoCk_s<29z&|~m@*}`L$ddS~j}ljZykxLB4duMoF~-jTVI{c3 zpiDxE=K$QZSi%niR|Mk+fsX}i0d`d|eiS&#`W2e4q4ZSpYX;Zjw*c<77We(@R954p zwo1eJs@eJjov8GweVykjOO&|}5jZFjz;hjD9}+jrv7jK_cM*xlq$NJ4TLj}-+AI-B z+>SoCrFz;Vz_;dr>|MNp&OY_ZOLVHrt8zN8RQ+C=InY}x{S?r9TP>>IZJ6u9E0A7s zG?^Pg6$N^stZM&XA!YRFHfvBNWSan+0abu4fUSUSfL&6DuL`>v=2Qr#u?=){Z$yOu@a4;5^vfsSqUHx<)kIeF zPK4SdK(9}N!xxgGQ}Yt2@*yu0vny3AJG&pMR6sfW@>dROd0?ughR7hjVm60<7%xF; z*ke#_kzHsT??MfWSD+ewYp{3A8Z6x#LAz=~LOK1}Z@*YY$q)N%e-)ejiBm=A z<%cVku&#ssC0%*M|4-QssyS$>zcJ0b*U0Ubr~gm5f>YO~hMXJ0T6T>)Ur|!o+sM&SM z!qPr|*x6LCZ6Bk`p8;1WrruJYP=L&_4x1J4S0D-f(cKfMnM6E@K#=8kVGN|r4lSyYzWEbAtAvei-3T^1j`yg z5Nxeqs@P&{TTrTKsiFo;0hPA2rAjT}AoTnA=XW8y zcRq9G%$YNfJ9qBv?%i2A*V%!9#Ye!JY(+y%Evvaxlx8TLVWnEE*peV4ISPWVNH-cr~xG^oYpHwn(@+GP@}pVjCFlIpXLyMdJYtYdDVZ+%vh8%V9s>gxv5>a)_^ zz`**f!4!xqZH)ck=f=qF=4`M$yS|eucx?lCR-L|#4%cOgi-Uq>Ka?FgsG@6Ewk6!% zH(mkoz}=~a>S(#5GgfETG3B6xS*I}fmdD^FUeUpcO?AkaqXbL)gB;U6q|J4?@vvv)Ti-E8DxQ+E|-)DiE)^cIBxqi5q4^ zD}xf+;d8MR2Qw17qKVf63WhHtl%ld$-pr0Vw)FyvzR)*XDIK6i97h`u`nyL@lkl{4 zG>LSNibPM7^r_4moqc3qV{pikzaLvaa}sKZ%uLaW`VMv#rJ`j}C+EOh%UEa!@lK#R zY3bq{i|swm`4-ev;+kEc(?7blJ*j$Fd`>3euHg*jDrJ8C>{HnVzde|_F+uqT+5@&M zX8z7-y)0G=D=)Sc!(aY|@u#2-o$8;sVIPFJd0*=5tf=f-FmiJC!A&0T~=*C*FiU(nAMiJ?$=T0wa)eP!t7(%qa$z7 zP_(9DnQ_2*9^B#Ip>=L69;Iq(&GyU5<1XxqTt_i}+}$S{5iQ1wU99+u4i(qFl6o*< zBREc(iLGbVuTlNMn&SxJ(4l4>pimoxxS|i%oQw(Wf$JF_I$e_v=q9ldL&%{CLCf$K z>0lOWvGB?&#}7bUk!O?OjhvfZzXn6~52`3tDC|qv+}AYRO~d=sHWoU*RK}#)4@DK0{`Lsu zoxT3Pj5O5pAZCXhZvAqH=LwPDJg-`Q$$gwS zv>}pplEr7A#6G`X7c#!v*XM3@)HN=$Wlb8`r(5Akn9j6T#2W%b>-w2cajN*I)ypQ# zfMMs=`e(HXpJtbSsz;uWvRCiJktdS7Rt+R9?o%PP&4Gzo?TPo_u4ZaR=daI(d7N)7 z4p#BSF$n7>ka&NU8cfuX+HxhN+ibJzakOoV z_WDTHDHx?XukxMy!RTewzth+Ine{W;a&Ul|(O5sbsXp9{4S7A@4NMvs9p8=f`>(~< zr}hGtcKu9fN-){kh=KaqFtLvgWH9+X-RNVgfmzwLZG$5#kHbXz2&g=w$HoXaNd<5m z?a0pqOnyEBw*XN;cch{bvhXeVk@|;DU|Hc_LQm7j|9qvfLLN41Iaq^@2ZbODo|b}eLcB@3 zkowLtJ2JbGdNa=-Zt=H}G|m9Se69#k_K8`|;ogQRtGdPEVtM9>Feu%n>F;3YyI29lIZs2w2B@!6Ix2cW zuH84OKIc9q0TY?n*b~{E&|i_9dmtXO(>D{K+}nnrDsiS8z2)&37OgY5lwYMTv^BQmOA>}za5J|9Ts`5t5C6LhxI~&}!LF7W&1W6xjrLl zO+z@ORno7dw`yUfO;ZLDc6FBz_dI5gpX zJWLMankIH!W$_}vyK$)f)1<9!515MkWfI#eanRSNr_DL25_dkk#7X~-*Rf2o3@R5UA zc>T6oBJdJF+Q7JSq#hQJ+wO)(9&It}%Ew?)|Dg5Ju`j-8oe&?lJ{2Ce%!WG_?>(!} za9x|#=DT{;7EIi*2<9~hv(#jRtZe;yyovF7>xT{alqCAF0jyOI8&<({oVEx&Lh%_` z+hEzaEx2lHd>qV?;>uocMY5XEKhdcr+%qU=wl4Kk5$`_qY*ToeukggI##O`o%LZ!^ z_*^Ug%0LCU=l{ZKMi;S9mc?7_TRi0xLu_4Zm)Q)T*g;G~A)Z6_0ID%by;bl`qu7 zrw4LD^dp^UL6GArY0LYnN&2LSWSxld6=w^pSJ1d=UFORa>;yEhxEAz3Uaxt3a3q$k7cRims=u(Jz}Wa|K2RK935XlrSN&bJ5tpr6Y%fR_Cj zhx&Ztp1?S$6u-E27za^)af>kypT+s;%*8l(j_wyXu7kK#j5FA2VVru15nsM0X!NGI zLl|e!xub)08#{=r#yCUS=X8*6QU~eMFwS6SLI>$^3Sdfi7~>3f?!q{OKeu2U_}i!c zTJJJs*1Eu;t@V0S#0XPFAH(S8E@ma+T5ALrj^Zx#Fm%9j>jCd35!oHqG$d~Lfhruj z8#e8@TT5_l3)0g%vQQ(1QL;Y6(F0O@WF}qvngvn;T1{WVo&r~`paJ^c*hG9RT z7MS%~w(Bgl@)rrie9Wf^u)x+7cO_qQEi^d3lE3TgDkv-@J*CEBP++{0!xA6}!8i;; z#w&Te5&E(b%k{&x(`3t+eQh5VjW7B7$`#eBmnw08ftn-4M!2g4U%~O2ZdKRT?ltyLR;feI3>dudu8dtME{E zC)9T^^B%QmYE~$$j5^)xOFen;wR`=2YFT9VDVje-3mvTmoRGzG%m%N1abx?JY{k+0 z4D7+Meu;~#?rJUuYF9Q{i5o&Ns!_v+bv|h2R(!R!TmnMzSlg^yeEe!O-OeYj!RrQ! zzNE%-TEx<6@ew&Moa^}#I6*0lT>}3Y_7P6PC+3(;bsn{}9$i0Qy-zKX>-i_>@G6F7 z1-J8fI6AoXw)j$k)5%S$5kd-YSN7P!{aBbn^QmYLqC9#2hYwC7F~wIgZsDNe$LAT_ ziG@bD6MHz8j@E7Ci`Y6lK7a5MShn)gcxinNXpX$WO{x_Zp8dDmwOfg6j{ehcaA<{n za&oYZQ*4-7(Wp_|HUgj6z{mm5+afcL$17B=gI7s$Cx*;X6Kt1ZCCoTh+p4X01cy+;oe z>}7NNH5L_~-A14B_&sWXMW&Y)ZWMYd%(Tqe{*Z3(m<=Q{rBKDTIMZrn_&Qk zYwN_UPl#P#xGuJw>3%aj6W}W&OxQNHB)-fFvfUk<4D^cS8w?cXR zHyr4yNnF?eOZJ6hk?>L9dVrNRP|o(#%<)^d@wj%Rvkoo$Nj&^ms!Caq)5dJ+)pM1ytOJ<@1>H9i)-%*WTIkBGdL z1oPsg)XKNaE?zsd=wtO^Xdy?vS7Gi=4=S%oEjUAds6KN|BV2c?Gval6;yYERbr|0{ zoUW=@?MYZa6F>a{yU_F=D4A``N6^ANx&w)IHLA@?L63}GJ-@^JgQu~->uKyy3SX%_ zh_~E)4UEq)PNa2+E;Y`B+*0dFkt~e=&;pBfcH)M7xFziHf{Blj#^GZm7$qXJk3?o1 z_A?H4IlE&;v+iw2Rd2;vzh~<_ZCrwuRlD*?fB)<0kq)k>^L$&=m&lOUBxJi^KPL#Q z%VhibpPP47{@K5s!0wd#Fl^d90+%DWj`MiVk3*LGJBzot`FjT+7r{n$>{ZRMQ0%=< zY>d~3mkz(DYuYJzXX}}s;hz8dOJLwO)OmL8{&BPsa8~x}w!v_t9eJ_s?_YcodA1o} zA8f+c^^NeF6IpW%-ZCTWkHTBLU9e{tpvyOqQV195E-$;rA|c%aymPp3ZPqcL zXRWPsV0?xlclIIJw|+uZn87%;C0v!*Yd2n!YO{{|Xs%s(EReY2n=p>Fu86lu`Z{{q z16A5(u(3C0yIuY4qqQFfaP(OBpte-W;r==$$*TvR{dKjAj>0zYqp<%CF4U1F=Jwq( zqbIgI94D>TNq*+WSEGOTQjZ&7;^IYDX_Qy>W?Rn3XO|^(>xo%Ms^RldvJ%-V-bd>G z7I5C`!TnaVCfHHD2D_;D>TKx#E$K;7_bm2PNsUJD(DiA#F#S^xZe=SoCEx`TT}1yT ziG$Yq3N_n|_ttvqoX=xabelO$Q{htKGlsO_M}7QCrYn984s+g)E-x536a2P8g*IRB z3RjBU>&nVBpDfp34SMtkKwEw8gmB!be^wPwD~s6_4h6*2@oM2l6{a;f`RDfc)p#LQ zNANie??|Aw|A{`PZe4KwQzbZ9rxJi_xb?tmji8PpKJLfWzm;(TmX z7npi=>8V$jA|GevP^|YKe|!60ddlEv2Wn zm78K==-(Zw?Nu;R$B!Lu>Av*%*aM6*YdYN&K{qm5$AlXd71p1a@woa+ z8?zcdPaAJcy>7&$++F26be)3YUKR2Uu$&b~0ayZ9F7bba5aShs_w+843Y2f_vM z{`s=y(~YBJFSI-XeM0ADhevY9ir$G*1^eHOww9ZX!(NS}fOqcSu{2J}zr6I9oex|H zHvsYZ)<3AH{JMA@HL*Y8=Q-ngUj13r>K0#3+4b)AAMd`r*MBv~YnkbL!wAC}OurKA zQX!VM(ZyTY@-}LWGoEW1?)>nY;=gAemNmi`a!U)tcAsYN@Y%9mY1YGm8ir$T(VD|E zVR;Qitk&M~`PXJOac|SNkuhnT?*3(bl2#a-n;}vB2xv4R@qQb|=8lJSoOmYQ|A^tC z@|h2=KLPvLyM{ib?R78H@DZ=t_Aks!>v>9}so1Or9#W>(Cu~#?8)GxTm`HcH+KIy8 z)RHcRrps3o>_{N`R!(+-uJwH}sBRt}I6x5qd zRMS{4`Dv%cWM=$uygmi?15@sL9E=tc$LRn5G3$1C#>X?DZ*BRId?;KgIbMG ztYbMZ5~%fBT?F_{W5E~Ms}EvSBw>j4Scl_j*$L~XyiP<*(=7xNbw# z@5Yf6`a#kj{4}QCC~~4+eaKMn1vnAes8z)e^N7O4~ywEKLj~2CQb!LjtXNc9URqJ^o}?ES6y|?P z%P#`CrU#s1U9Ng@6edyK`b(xoG5mVDwNL!lh379x`6hLYu^PVqwVG^c? zyNokBQbGEL2?^INTHhPLfWZo#QECgmsnW6rcRTh*)oraMm=u=X&gke5(m(pyQ(r&v zm+X5nVage$wyb_2|L85wrAM!CnS)8;snHo7eL;HJ>c2hxVz&W1FyWb|hq;bb{BH8< zL4{@KVS4=LyfZm^gK+Dr5$Vk>xBU^*!FBJ94t(lSw<`FvZn;ZGW5P47fAse|m#q28 zp4t)HG5wk5507@Oe?2w!pRc_4%YR{dSo}Go1D$q5-o9D)W-M&LgxDU>U?rwI)B4Bp;+(-h>6QEATOP#p zcs)6j1Gj09y6VYy&bI!rzNUP;sq}2q<9LWZ}{Im$9a+WxB&)AeQi?T#TtK|nK&~lt~zmoeco|Exb=1hCFzQe^*bO5;32155 zrm+rR1Ys7SZmuB(R|hzu)2~^f@)-49ePu;-JN?t z@LY9i52%FbA3W~VZ&qOIiy)DhZv~tcaAI#NNnGHb&$n=rUYXH z;=-|RASZF*m2MzAap6^N0922&0)4e=Cvo9;H;@FGj&MVLdoHvB{m~X}HYU(!55`kI z)W@nJ5ZF2hyowV(E1(3xZVG7~Gh^cB=+F@Dmh7ITR^SS4Qd!U2t-w%yUedF)+6oNQ zfkMjuh&OxPPci#P-0YP=aMQZQI*%imM{rZkVs-Zr_#L*i;HHffJW9Fh$lp^|XwMt^ zyo9p-$eZmwdXV&_>}-}D%LH=_nP0$aDc`lbi8f)Yw`Q%s5? zod8nc2&1#q65t08Y6Ua#Udjr5g)Au3bK$`37=6QBePf|lYXw@u-c-gxt#3XlxHU$> z7S|<@xeBy|YY+$LXnnU*0cZAsDxb&JX=87rUUTEcbWD_*btf>mon4+!NK+ula2FOH~uCXD9V2N&CVh{)z3 zH(IcJfJzM+_W`>HQeckG=~4>j>fmJ*oJplBQej;d%bG)DZD6Yn(`cQOmT-GZkxdzE zeI=x?LKIJ*`5Pz+)>t`7l&OUeCGtLrY8Brif%!W45C!Maonhby3Q!Vj zv}^Gg*J3RJy+Pj#2i_+WEbDKSEU@(sSNeS_P>C+?`;=dyp2!D2aTAYo6F=!D{v zCvM_Y6b`hziKByIyPLS35>qd0r^LDFrq3zBV?dXnw}E83T{s(V|Fq#TDCOCGCkYH zj@ay4wlvlgJc;8$+ElHGBjj`*ANcyHRPEXJ1$j|F|?xqmK$`TpCLPFK+p;7 zO_|yU&yjNKmp|ofV>_sF+GDc*%x!9IZr1IwS?dIlwKj}{8Qx%U z)84z$;h$4xx{*_0p0?^A6r4kboS)!r^V8I|AAOJt^H8l@O9VF^uZRsF6XByGe8df7 zp9yX{iztxWXQ>rPqX1pZFQy>1fJ-Qtp^H2~ z1<^S=d})H7c{Nt(@MR>Pt%HL|e9zr|mcta1A~We~x4e_rUst=m>Mqw`TEd+taFB++ z<(>2hGG9BBV|gO9Ek=E`UA*P0*AlM!ZL#_|mU83ZJhJ{5G3wX2&F(6=@6`rr3HSQ? z3sO&AjbrCv-#Vz2;c$nK2i!x=%^?)n3O6HxOM4`D3-&m_N6)}{=On>0w4D$L_UP7a zLbr+C0x$^;4z_|lQek;8AsKlm=AF(3j)Ciw$HA!3*%O2b-Z=xUZrvt#3&Q2j2?VZB zMonEVwysYe4zgV-53WGXRAf+eR%T3uSE@f{@+3EUZOxcI> zq+nlCM8ST3il|uqyFp!?cMg{De0>Uw*j{<<1Ty%7_!!c2VLI48sNa}=t~~g2DE#S; z02Sgnyo)6sY`p?vwly43An=bK=fbP{2{LGn0gE4Vr59idHw4!XJi1VSgM0ZGK5=T{ zzf(N2_DyH*C}-!Jn_lGu!uH_4&d%4dxpj7`JC``SHao95+jMwiXM04-!|Hr`=R(cq zbPgsyQu11f^Oo~c$s3 zC45Z1>I_z~@VPn;3u!yqM9bb(htsU6j;mC0pw3z5>;(rpcP@3_bavWvdpRZcm}L8^ z1Re6DP z2*ih=1V!Bj|8@nJ+C#O{>79e!i=eVTa2g;PH;L)m#Y5P|_K3b%acjV)HO^hml49pc zdwQ}xEZH8_2f|?rT+<6Y8Mf1VIZvL!zdA?%!)kCov9C_Chov~l_V^U%^%2esPVGqN zq_a2PxM5_Yej9c!mD(QB-yV=Ma;JTDvi%h>F~y#MhN441dCw`{7KYqP>?<&bxfr1o zPsUe!8uu1wi#<*y+GY>!=Zr?p!H_d2c!@nC;9wcC)t-c2aI3S#9-QJl<)DIqJviwz zrA~F#e<8xwQik>Qx)yP6an_;;*oAMdOfam+4QyP=O)7_!_m^l5I0Qab2bo}Z1&uHS zPDydwuk-6VXE)U81NK$A;!#D{CLH_h>=bA25S<7Hj01cY?EXBu`s90?-m=H0ID64m znfg7LXx|b5|Jj!%2fNtg0#HKAwW%}oaj06Q#2$EFXS+Pb9+2#e3Rc=fq7C%CN6`4e zDev2tsu4$x;E>GD!Nkr|?D1fgljR!I1zLOYopxql=i<#v!cK~FuRW~~<^{d+YC8if zNL>el#c6`3`ID%y zJrXs*DDSrQ(f#4lRO^%kyV_F&PsEsM~$Nm;O%V98warUxaU^<-jvNL*l0^@o)k3rpl`px!K@KQ34 z&@48+H{|i!UNBi@cdP0(;JY_E+r#?=E7O&g&^(;~;rr2s&fh!nXO?Q`IcOI2e0v9@a zN^cBY)7v=)ZSJid5iKFTZ_x`mraEoM(QL~h^JGPR7JRYaYa@2Oo$H^TCkBPlvPv&`+F?d6{N&m zJ-HRr@=MFD(((dS9Lgp2RzXQcX+a3%rdE`eS6P^QL1|fDWktmzE3{}qer0h*ZpA{_ z&}88rCsJQlQC^&;UhruM?k@@zrWKUrS6b!aMGHceHx;3cRk;I_#xsr8mDud`#4Kv`9lS5{g7gFC{k^3a{r@)w0vdGg9Ds`JRH zXem@x-hztqa245VQB$<4N-8R=(_+k}WV-Byt``=EtEmBm3a>9$)uWoNYS}1e6^08+ zmRZH2>Z#DkEjJ~&xER`RbzVt+S(%kLE$60dr{v`2RfQMiU7vU5*s-I>=8ed6r}za{ zNojG(ELCB}6=j9c3`2Kfi>WGI9;#lpIE3ZI+-Fum>rw6x>6WVd2HB_@8AMmYMmp_$ zYub&o)2614NgtO!HVyXNjU932sL^SIZ-%ar4O;>gA2w>-khEcos>9`>tBXVBp~}(% z2Yd?)hC87K>J$h6@nU``g zipnbTp%be{pQTG4UR(%WRgVbO71x#J7kdVh+{*l_5-Y!O33viVs7gI5L0fbyU5x}w zO3NT!$f^!4g05T+{#Gpmn|!qAVYi)9P!0PJs~`u^tMXFgff~P%D(k5)fOs|yZB^XI zbIxf)E#|AG<=}0oP#l!1^2?ThDR2_XhelHjqsF4pEHxUbj(lAOM5*#)8=&R@ zR;reWy*U%TZIxDGcen|=I2H(H7lie|T(zjQ8k#EXq^vH@FN21qIu12_$gZ*wN6^yp z!q8GK5m`Hm-bY7oN((G#083z~4gm`7Wa7%UTHS_s_4Id2kEDC;spodKD?viXO@cT)((#4kOI5T=I}bS=4fw+G z_6u(M70BUG4^BBg_)KRMz`VDrSXeE=)qgj>OOWIDQoLGqcjH$EFg^|9j#IpPI>_-^ zwZUMq64B+O6)5$@k7eu`u8nCFUxd2c_3JiVdKks= z=%XIW%_@(9wC16n8?j7qmRk>*6tAArxbf+3d?CfF=Q12`pKxugqxf-X564$UeYlJeNxW}-1u|c@?}!I zTEBPW(-N=*X<%O=#jC|sjz=H=Rhg({){=}`|7MwNkeQI;`e_Hrs5M`f3668^JnWZG z@TBX9Hi}oPu5S7oH@-VPe^BeE9Iv|ql*0d51-?zNK2m!!r9{x8#wQ|zhTUgD+WF)a zM-2hs8Mpxx4p@U!2kvJ@K7u%}`&~?Yu;5n`&w%w=Jeu{JH3QyJk40RyL14EL--a76 z;mFo+Ryn+*{CwgW#8(lYNnCA(0k)ZVhTz+Yk0Z|Z?;*|`q}iTd5y$6>c(8mUoTEJr z#996X@fzZTA&f^59E$SWNWmeEtrX&E#1|7EM7&XLF@inp#PKbtH*R?d?4u%i-eB2C zvDw5MI%~jo-bQ>IamwCWLcE4}8tK_Ye6f(8ht3mLg#Q8eL`ZI`UfIe@&dBkf3U(Wgk-^}{q-K*yb;+T(@?;&0z z_^ZSl1V2t3npTXSzYynk$mK#g^h1r1Pa@tR_$9=-tFoSP#51U0FwY@gBlvB^8w9Up z{nYPR&poVP@Xf4W@b9sH!STn@vAo>WS^uwDzZjR^Vf})mbA#5o+R5TIXyK<5;*X%- z&=?mH)cfFkIM1eIqk{U$W-NqI(1OR2K1WbL8IOs1W`xAuZ~;z)@=SoE}bxgI?rc z;6x4%-kbC_=!eL+->5l1DZbdCe~^Kv8+ZuRqW&xBy3adz{)7199y;G5{bmgydj{b| z0uJ7%umsLg&rX_e@J_@X#NQx2>iz&&29@`#X%K*ecQ#EY{XfppoFBa33qjO>A?Z=~ zDZt(!{w=D^%XBiUfq0ObG;afJCjKJH^9HXq?fHN{ zz@zRPAl*#j_YF{L+&x&>ZczU2ftvGme--hc5@-K^oA`Jt5buG)kN2aVm4mb%-ph2D zc*W(Kt2sQJUP=BepRPIYllV`P|L0K6yVH35Iq@zdH0QlINu(!zjOJV~V+`$Tyn$yK zxRsYz3=1|R(hDl|VkU=qNsYrX3pWhKDgt9(W#llflBl&02D})-;h4n|hH8lo7fTp; zS38--E>|**E-5kL1yBxqR!A7R3oHygi!+Se)m#R=0Jj^U+EtX+)1&bD@I3jkrim7L1o)Io9iL_)~Or5&x+nmn3Gdb-@6w1S65!Tv7+Y6)4joq zv>?f;#2^8x=~)E}_zpIC={^G!pB9%C$LJdDbFWov$dc zW`)Y&iPS7yt6pTy3|Ffs9d}g0Qv&N|_2|Qb1!!1+h03g=K`9T7;`2qJ%HmL7eqkXD z)pS`=w*?6ho$9R|LJIOaJE{!ZbS z0l~3F$PXnwj~e(v;!;m8T)*&OI|q`UJOjt;uUCE&&4VHazL_}Ydkg%r{SOQIOw#kX zfj{lh^Hq3Pk-j|-kl^7tVwJlGG+@&4V*t4TiDz;V9kl`kZDys!7;Jiowb z^wB($&ld8`za@AX$$!_t-xPcW$^Y5FKNY-=te@RKC}O#^Qd{1nOm)xaO1bpdWy-D#Zsj)6Z*9Q`oYB>NlzaGFA@9{tv6R0_+H|;-Y^sXxZV#FM|-~J;m3rY6!QPO z2Hxz^GtZ+Z2{VKP_2b$*=bKNQ%bP&@%M5%3m5=4Sll(*jzeDg;l3!uq4#l(nffPUj^Sy z@}C>{1=Oz5&iNiYhY@H0A0|EH419{<`$?YXYpjR)Do?)Nes`bHbCmQvXy97~KTh&L zFz`mf3rW7!!2d4zJd(F*iIdC4JefH9bAiX71B84v=}9;634)iAe3pUFC64(Pc=9b3 z@^z%A+Q4fBUqSNq2L2P`m~Wvc-#tQp9qIYGfxqd|62#w2il;(>)4E!3w zx03vH179Kdc9Q>wf&WbK9VEZsz&{myH^~Ro2ePC7XFghRo_|j^@TJ7DT@}M0&y&9` z|9sYP6C=v3hq^HWjR|!6l zG{5a4^M-{aIpMIlAn;Ka2&r* z@KYrJ6$4-5;drUxep+kbTRa@gc8b<9A2sk@g6pq>gMAzZepvACWdEB6-Yj?u$$w(t z2^U-HV1K5Pe4>G;2|keIuQ2dQf)6G6X$C$=@G&G`VBpn)Pa^rd4Sb{EnI!)o2EIe^ z9FqU3fgch)m*jtE;7x+hBl*7?xOGWveHD^?Hv>-iI ze6iqlB!8EIuM>P7$$!hhpAdWt$v+2mMKa})*XyBg;o=ft9!Ljx;znVDayU3I8VIe<;^t@@{PYsFHKZ)d@H}JOw&m{R~ z1OJRT+F9nYv-9P#`R0(Go(6u2;PXg+n1Np@_&}1MV&FFumv(+#$QP2HQUm{n;45g~ zzyk*U2yxkdo)GeNq~{p}Z}jM?^!WKNLVg|TX*cjLSLk|??Wz}X?(bVjPnv;`6nrbm zPcrZj&^#>yGY1yCp}9Iyw0O1LVhpl`JRFA_UM`G(etv9-%Wa6 zGw?qNzMte<4E%3`HcpK&W8v}0>{1nOm-N1Vdi}mwyG#HLF10PBp#fspMuNPB= zJpL*u9yc2Je8JmDexZTa34W5~?>F!t2%bWIc-p}C34V(7A2#sM1y3OToziu=x!p4F zD|mO3A7J2f1y3dULIYnW_!yF}Gw{uV4@e`(3!X#rjRxK>_&kyij)*NU^YaCtMD6V| z10O{k#k~D4ab&E1{G1*h{SADl;JGBf$H4aso=Nh*Ht^n7ICrv%?m^5=|EZg&05`~ty`lKfx; zpC&kdt{9J-4gBlGQLT5J*(~InNY5h%zDw|vB>#ee9~7Lwlj64q{tx14X94{2_+XEP z036&tPf@<-8hC%=QqSc=zB~DOtbtDvJb~nM47`vyiWR~i+g~l@2a=w<4ScUhPo+oC zej%SidVX!-#|2L%`40@d=arBd9PH31$K^MQgVko<51pGq8cd)I}g3;FJ(XSRWtdh~e5 zvFC(*3hCKr;J*?aKgWy59}N6M!3UE3-wZr+oYu#FgD+-P$4v&lK=4Tfv>Dbe1OE+i^jR4G*q?6;`Q46`kPeF&^FULbgPk}o&#{}4Qt#GBUmD5*XQF{m6MV1E&brya zi-^neE)w#Yl`WlRAp<`u_C4zfBPG^C;ge17GFQ z4)|lg9ToCrlX zZQVh7t}yVc1V66TTGtx*T;iy^8veMw%@^{!ZLMgbf!`^36Xko4fq#!U=3C{-_eVm0 zudNk5YvB6?Z=-w<8~A&~F<a5b zHyZeC!S|B){*>k240&JE5DB9HyHTCf^Q-D#|`}Ff=?p( zUm5s2#IYSNfIlAh{wm}%Nzdm7{^uE5056xQi^QzI82D{B#>(gFpjBevn+2ao@{bt! zuLVyb`L_&w!A-IDU>WdOWZ+8#XTPmB@B@N(*Xpg`7}vZzG;0< zl&_(11HDW6Mh{2%Z4`#DNLGiGPxEk;ZwzX=3=j8~cfNx>;V9pD4km(pJlrea z=;0{Ozx$z_3*k8Xl@U?@Z*x$)<+ckcKVQh#bkXuP9`3bgn}_3R1IagdxL3Z>!|{}V z7scwN^O5$XdALg2Rm){~xL5yt4@Y_aot7F8_sVbcaFplYdui}+uY9A2qdfm^j79At z&VCO^`T1x>;V92P3DV%LQ;2IAcBS&v2I!eAkv zL41VZHN?jW-atG!>hit(!u+rd|DR>R>If6G3pD(yY{i;Op4C0FguOYrv@CM>F zf?L$?*9x9Ne52qs#2*s8f%rDTEoui(2%bTFm*6$T`)c>8=GPm}k5M?y!t(m#^gZrlVb6OZ+;)yAem5@nHKC$N@KN>~i?obal)T`~~7)7o67{ z3kClHwcFbTUq#`?g7f!lFA@BA!GB41t`+=Q(z8MELu4o4zp#I%5Pw+6 zUrPSmCipI@&;8_W!3#;xhk_5Fd_NVOfA_>DdpX~FlItP(P~!as-$3EZ1fNEJ8zs0y;mLyk z7s*c-{Bz3p7QwHg@B+bqPx9r0^K+}a1n*4kVXffrkl!8@{B`p4cLo0~$v-7{kmPxP z8T&bv?0i?qmy$h~kUp00N#P-aZBRIE@0>N*j z^4>1^9i-y$PJ77Pk3k}3=AbE5jovIWs2|f2w_>hptwLd)g_k39Y z7_yVw3+sPei(5aW`eFIKRNiNZvpoL(5FW1ydG3$L1m}F;7yJb2IVt#CTD>)x>}7kN zA^B0n*&hD=tLugQC!}YN;HKGz!rx=U zgZ11=Vg8&VbGD~S$X`I=RrJpK`FFY=6!NTx{m1&Vv>Dbep@)Be?4Z!Y>E95X^}i=L zKVSQs;C$V&sNb{w{Cj16h_jvS|H}mDe6JMz_oxt#DMCO0E*bw`0PE-WUo7-+zDoq> zd>;^8=W1Es6`ZewJBf37`S;WI3whRmRPY~Dx!w_a_;=Ml74od-BAQ=wdAVMO3;rbjcgP5~^zF%g}zwg5L#muKtzWloe zY(M{A+~>m1r>XyUq5B%v!}*R9oPVceis0oK`Lh0C7cIf^Jt^NF#5v!u zrfIoLh5RezpRt19N%g|tugQA&_x)xGdG^l&!P%dcg5O33TSlDq^X~+16!NV9QNbhB z-kuV?g{}+F3H|(ggTEB=tpB*+Z2xD1Uq^o9?xK1SE;#ESFL)o) zf4$)Nd&zk4_r7z!D+g)5P{?z>%LTuW+DSxk?ne(1XZ^n-{m%*c2guI{1y3OUTcL-4 zr?ExIvz_gNm+N9#=XBF27>)Pr?-B1UIA0(6_cd6a%Qc4Nxm+1nXhr!#PbvAiOvv-^ zM)L1*uzt4x0ilQM@iD>qes!1NZ2!xGv;8fCCsO-ANu0~Yzhl|0yDp!!v%lb+?-0Q` zU;cd!)>A~|!!#lP72<`0PoVm$AkKF3?`qyF0@w@CkXAy3;UtY-x0a=k4$ zm+LQrf1B)VC(d^A@4hCU8|zP=pIjt3&xeN#&hz1G1n2qiO@gx@@&xB{RS2F&{&`yP zKTC(icp z?;-Q=XmGz^J>3&^IheCO=L^p5WSrn5=(;e8IOogH$7y=2u4~ykEA^U0=Pb`rw0*(7 z|6-m-CwQ5lONAmCg7f;oe8C^5aE;)6zrRgzzVB`jobPiR1?T(31S}97Y$xB}4HTU3 z*D?j?`>8^~`97#laK0beE;!#`>=&Hx3z`Jyc|Ko<*?yjf4<@HG=lQVr_X;tN=Zz&o zp67vU1?TzO6N2-+>yY3)UuqVd=Q9qqM~uclo<9s0oUhB-g7bB-L~y?D@IF@7&*S_q zAk8E4^yjqU!tw@LpZ1-%I$cGE|nIUL9ImZKW6HSLa*l z3#zKDbVVyGG*JQk?bE#c%F6s@6pL{vmkz(CnqMX$2SW?O#qhJKMHQf3o#!uDP#Ibh z6P;g~UtS#IOtn~9X?ci~fTb4xV)dd>IT%@9Q5{O3cH`_}Rn_?g3rSI^B(JD4e^ChP z?7!nk10~qRdHi9W8FVsnCKLTm-NA+D!x>gZhD-FxoQ?W@&kX&J&!;dg-ELWZHMTAz zPSs4*vhEW3a)iu(C`6!6nZAb7&!PDSr%&S(dcP9hQ75(|@4@M>6&bSqEQ?>iNWau6P)_xzmf9i^q4>1>ajY`zZ95X{@ZSa2sjq&H}^HoJ<}(J z@aC6)cB_uhCV9*sr}8rYrNBfLs}xCJQ*YKybiLN0c-bn5@XLQA<)7ADr^Nhm3Mccg z1Ll{1-t9Ua|L(31#mj!nkp8+donizhq<5Lu1Hk?4-xbi3oF45@f@fUG5y z{{c>b5DqE(ePDk1H&XuGPB8!T;E&ZY|0(HYJ0Yl!N%$oIaHNQVjq~UCS3m~OW%`+S zVQR}t*Kh7Cr{nk6A%@RgAvjq@>AeikrEDXyxbcV5^Yaf(iwBoqhb-%laN_5`cJd#0 zZ1i6rPkQzr+9UG@WIb^=zQT9xV5fnjKm5&vKhB@iW1p5|2O!I;SFhGBbU&g)@#V*T T4u0v|6SSv3%>oTe literal 52256 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 mOn9tQmPF-0XQ_H~9>By|j^`iK+47W diff --git a/dominion/randomtestcard1.c b/dominion/randomtestcard1.c new file mode 100644 index 000000000..8ced8f990 --- /dev/null +++ b/dominion/randomtestcard1.c @@ -0,0 +1,123 @@ +#include +#include +#include +#include +#include "dominion.h" + +int baronEffect(struct gameState *state, int choiceDiscardCard); +int updateCoins(int player, struct gameState *state, int bonus); + +void assert(int a, unsigned int* counter) { + if (!a) { + (*counter)++; + } +} + +void assertEqual(int a, int b, unsigned int* counter) { + if (a != b) { + (*counter)++; + } +} + +int containsCard(int *container, int size, int card) { + for (int i=0; i < size; i++) { + if (container[i] == card) { + return 1; + } + } + return 0; +} + +int cardCount(int *container, int size, int card) { + int count = 0; + + for (int i=0; i < size; i++) { + if (container[i] == card) { + count++; + } + } + return count; +} + +int main() { + int seed = 47; + int numPlayers; + int currentPlayer; + int choice1; + int baronPosition; + int estatePosition; + int estateInHand; + time_t start; + time_t duration = 5; + unsigned int numTests = 0; + unsigned int buyFails = 0; + unsigned int estateDiscardFails = 0; + unsigned int baronDiscardFails = 0; + unsigned int estateGainFails = 0; + unsigned int coinIncreaseFails = 0; + + // card array + int k[10] = { adventurer, council_room, feast, gardens, mine + , remodel, smithy, village, baron, great_hall }; + + // declare the game state + struct gameState G, G2; + + // Initialize random number generator + srand(time(0)); + + printf("\nBegin Testing baronEffect():\n\n"); + start = time(NULL); + while (time(NULL) - start < duration) { + numTests++; + printf("baronEffect test #%d\n", numTests); + numPlayers = rand() % 3 + 2; // random number of players: 2-4 + initializeGame(numPlayers, k, seed, &G); + + currentPlayer = rand() % numPlayers; // random current player: 0-numPlayers + G.whoseTurn = currentPlayer; + + // Generate 5 random cards for the player's hand + for (int i=0; i < 5; i++) { + G.hand[currentPlayer][i] = rand() % baron; // choose cards between curse and village + } + + baronPosition = rand() % 5; // random position for Baron card + G.hand[currentPlayer][baronPosition] = baron; + + //estateInHand = rand() % 2; // choose whether an estate card is in hand + estateInHand = 1; // always put estate in hand to work around infinite loop bug in teammate's code + if (estateInHand) { + while (1) { + estatePosition = rand() % 5; // random position for Estate card + if (estatePosition != baronPosition) + break; + } + G.hand[currentPlayer][estatePosition] = estate; + } + updateCoins(currentPlayer, &G, 0); + + memcpy(&G2, &G, sizeof(G)); + choice1 = rand() % 2; // choose whether to discard or gain estate card + baronEffect(&G2, choice1); + + assertEqual(G2.numBuys, G.numBuys + 1, &buyFails); + if (choice1 && estateInHand) { + assertEqual(cardCount(G2.hand[currentPlayer], G2.handCount[currentPlayer], estate), + cardCount(G.hand[currentPlayer], G.handCount[currentPlayer], estate) - 1, &estateDiscardFails); + assertEqual(G2.coins, G.coins + 4, &coinIncreaseFails); + } + assert(containsCard(G2.playedCards, G2.playedCardCount, baron), &baronDiscardFails); + if (!choice1) + assert(containsCard(G2.discard[currentPlayer], G2.discardCount[currentPlayer], estate), &estateGainFails); + } + printf("Number of tests run: %d\n", numTests); + printf("Number of times numBuys was not increased by 1: %d\n", buyFails); + printf("Number of times Estate card was not discarded: %d\n", estateDiscardFails); + printf("Number of times Baron card was not discarded: %d\n", baronDiscardFails); + printf("Number of times Estate card was not gained: %d\n", estateGainFails); + printf("Number of times coins was not increased by 4: %d\n", coinIncreaseFails); + + printf("End of baronEffect() Tests\n\n"); + return 0; +} diff --git a/dominion/randomtestcard2.c b/dominion/randomtestcard2.c new file mode 100644 index 000000000..d2825ca28 --- /dev/null +++ b/dominion/randomtestcard2.c @@ -0,0 +1,120 @@ +#include +#include +#include +#include +#include "dominion.h" + +int minionEffect(struct gameState *state, int choiceGainCoins, int choiceDiscard, int handPos); +int updateCoins(int player, struct gameState *state, int bonus); + +void assert(int a, unsigned int* counter) { + if (!a) { + (*counter)++; + } +} + +void assertEqual(int a, int b, unsigned int* counter) { + if (a != b) { + (*counter)++; + } +} + +int containsCard(int *container, int size, int card) { + for (int i=0; i < size; i++) { + if (container[i] == card) { + return 1; + } + } + return 0; +} + +int main() { + int seed = 47; + int numPlayers; + int currentPlayer; + int choice1; + int choice2; + int minionPosition; + time_t start; + time_t duration = 5; + unsigned int numTests = 0; + unsigned int actionFails = 0; + unsigned int minionDiscardFails = 0; + unsigned int curPlayerDiscardFails = 0; + unsigned int shouldDiscardFails = 0; + unsigned int shouldNotDiscardFails = 0; + unsigned int coinIncreaseFails = 0; + + // card array + int k[10] = { adventurer, council_room, feast, gardens, mine + , remodel, smithy, village, minion, great_hall }; + + // declare the game state + struct gameState G, G2; + + // Initialize random number generator + srand(time(0)); + + printf("\nBegin Testing minionEffect():\n\n"); + start = time(NULL); + while (time(NULL) - start < duration) { + numTests++; + numPlayers = rand() % 3 + 2; // random number of players: 2-4 + initializeGame(numPlayers, k, seed, &G); + + currentPlayer = rand() % numPlayers; // random current player: 0-numPlayers + G.whoseTurn = currentPlayer; + + // Generate 5 random cards for the player's hand + for (int i=0; i < 5; i++) { + G.hand[currentPlayer][i] = rand() % baron; // choose cards between curse and village + } + + minionPosition = rand() % 5; // random position for Minion card + G.hand[currentPlayer][minionPosition] = minion; + updateCoins(currentPlayer, &G, 0); + + if (rand() % 2 == 1) { + choice1 = 1; + choice2 = 0; + } + else { + choice1 = 0; + choice2 = 1; + for (int i=0; i < numPlayers; i++) { + if (i != currentPlayer) { + G.handCount[i] = rand() % 4 + 3; + } + } + } + + memcpy(&G2, &G, sizeof(G)); + minionEffect(&G2, choice1, choice2, minionPosition); + assertEqual(G2.numActions, G.numActions + 1, &actionFails); + assert(containsCard(G2.playedCards, G2.playedCardCount, minion), &minionDiscardFails); + if (choice1) { + assertEqual(G2.coins, G.coins + 2, &coinIncreaseFails); + } + else { + assertEqual(G2.handCount[currentPlayer], 4, &curPlayerDiscardFails); + for (int i=0; i < numPlayers; i++) { + if (i != currentPlayer) { + if (G.handCount[i] > 4) + assertEqual(G2.handCount[i], 4, &shouldDiscardFails); + else + assertEqual(G2.handCount[i], G.handCount[i], &shouldNotDiscardFails); + } + } + } + } + printf("Number of tests run: %d\n", numTests); + printf("Number of times numActions was not increased by 1: %d\n", actionFails); + printf("Number of times Minion card was not discarded: %d\n", minionDiscardFails); + printf("Number of times current player didn't discard hand correctly: %d\n", curPlayerDiscardFails); + printf("Number of times a player with 5 or more cards didn't discard: %d\n", shouldDiscardFails); + printf("Number of times a player with less than 5 cards did discard: %d\n", shouldNotDiscardFails); + printf("Number of times coins was not increased by 2: %d\n", coinIncreaseFails); + + printf("End of minionEffect() Tests\n\n"); + return 0; +} diff --git a/dominion/randomtestcard3.c b/dominion/randomtestcard3.c new file mode 100644 index 000000000..b8b3c4720 --- /dev/null +++ b/dominion/randomtestcard3.c @@ -0,0 +1,157 @@ +#include +#include +#include +#include +#include "dominion.h" + +int tributeEffect(struct gameState *state, int handPos); +int updateCoins(int player, struct gameState *state, int bonus); + +void assert(int a, unsigned int* counter) { + if (!a) { + (*counter)++; + } +} + +void assertEqual(int a, int b, unsigned int* counter) { + if (a != b) { + (*counter)++; + } +} + +int containsCard(int *container, int size, int card) { + for (int i=0; i < size; i++) { + if (container[i] == card) { + return 1; + } + } + return 0; +} + +int cardCount(int *container, int size, int card) { + int count = 0; + + for (int i=0; i < size; i++) { + if (container[i] == card) { + count++; + } + } + return count; +} + +int main() { + int seed = 47; + int numPlayers; + int currentPlayer; + int nextPlayer; + int tributePosition; + int tributeRevealedCards[2]; + int numDeckCards; + int numDiscardCards; + int maxTributeCards; + int numExpectedCardEffects; + int numCardEffects; + int result; + time_t start; + time_t duration = 5; + unsigned int numTests = 0; + unsigned int numEffectsFails = 0; + unsigned int numActionFails = 0; + unsigned int numTreasureFails = 0; + unsigned int numVictoryFails = 0; + unsigned int tributeDiscardFails = 0; + + // card array + int k[10] = { adventurer, council_room, feast, gardens, mine + , remodel, smithy, village, tribute, great_hall }; + + // declare the game state + struct gameState G, G2; + + // Initialize random number generator + srand(time(0)); + + printf("\nBegin Testing tributeEffect():\n\n"); + start = time(NULL); + while (time(NULL) - start < duration) { + numTests++; + numPlayers = rand() % 3 + 2; // random number of players: 2-4 + initializeGame(numPlayers, k, seed, &G); + + currentPlayer = rand() % numPlayers; // random current player: 0-numPlayers + G.whoseTurn = currentPlayer; + nextPlayer = (currentPlayer + 1) % numPlayers; + + // Generate 5 random cards for the player's hand + for (int i=0; i < 5; i++) { + G.hand[currentPlayer][i] = rand() % baron; // choose cards between curse and village + } + + tributePosition = rand() % 5; // random position for Tribute card + G.hand[currentPlayer][tributePosition] = tribute; + updateCoins(currentPlayer, &G, 0); + + numDeckCards = rand() % 6; + numDiscardCards = rand() % 6; + maxTributeCards = numDeckCards + numDiscardCards; + // Generate random cards for the next player's deck + for (int i=0; i < numDeckCards; i++) { + G.deck[nextPlayer][i] = rand() % baron; // choose cards between curse and village + } + G.deckCount[nextPlayer] = numDeckCards; + // Generate random cards for the next player's discard + for (int i=0; i < numDiscardCards; i++) { + G.discard[nextPlayer][i] = rand() % baron; // choose cards between curse and village + } + G.discardCount[nextPlayer] = numDiscardCards; + + memcpy(&G2, &G, sizeof(G)); + tributeEffect(&G2, tributePosition); + tributeRevealedCards[0] = G2.discard[nextPlayer][G2.discardCount[nextPlayer]-1]; + tributeRevealedCards[1] = G2.discard[nextPlayer][G2.discardCount[nextPlayer]-2]; + + // Calculate the number of expected card effects + if (maxTributeCards < 2) { + numExpectedCardEffects = maxTributeCards; + } + else if (tributeRevealedCards[0] == tributeRevealedCards[1]) { + numExpectedCardEffects = 1; + } + else { + numExpectedCardEffects = 2; + } + numCardEffects = 0; + if (G2.deckCount[currentPlayer] != G.deckCount[currentPlayer]) + numCardEffects++; + if (G2.coins != G.coins) + numCardEffects++; + if (G2.numActions != G.numActions) + numCardEffects++; + assertEqual(numCardEffects, numExpectedCardEffects, &numEffectsFails); + for (int i=0; i < numExpectedCardEffects; i++) { + // Check for Victory card + if (tributeRevealedCards[i] < copper) { + assertEqual(G2.deckCount[currentPlayer], G.deckCount[currentPlayer]-2, &numVictoryFails); + } + // Check for Treasure card + else if (tributeRevealedCards[i] <= gold) { + assertEqual(G2.coins, G.coins+2, &numTreasureFails); + } + // Else it must be an Action card + else { + assertEqual(G2.numActions, G.numActions+2, &numActionFails); + } + } + result = containsCard(G2.playedCards, G2.playedCardCount, tribute); + assert(result, &tributeDiscardFails); + } + printf("Number of tests run: %d\n", numTests); + printf("Number of times the number of effects was incorrect: %d\n", numEffectsFails); + printf("Number of times two cards weren't drawn correctly: %d\n", numVictoryFails); + printf("Number of times coins didn't increase by 2, when it should: %d\n", numTreasureFails); + printf("Number of times numActions didn't increase by 2, when it should: %d\n", numActionFails); + printf("Number of times Tribute card was not discarded: %d\n", tributeDiscardFails); + + printf("End of tributeEffect() Tests\n\n"); + return 0; +} diff --git a/dominion/rngs.gcda b/dominion/rngs.gcda index d4c1edc67aabd56a12aec9dc821e2ebf9f2394c0..a192edd9c8c46e6366b1ae355b781665b7b96398 100644 GIT binary patch literal 900 zcmYdHNlp*4FfeJIykY|b1Hb{i-@7B%g7De+TC1LQVPxWnQS z>NR+L!}vfYV7;Jt`s5|&vZL8x2}mzYA5a(sz-mDLXKIN_?>2a#3Q{8h;)7&?07gT2 zR3*W7gUq*Y4|ouE%E<*}Hz@tU`~ah282}b{FmaGlklR80gAe|>i%nI04Kf4dXBdE` HGY}sD_Qo*z literal 2632 zcmd5-eN5F=7(N&91N^!g6v!enQT$j@UD2>F6%w?TLP8QaK|VxS*@uNGYecAJTHevB zl_cO4>1(3SYi?0(Y~fT^jLcy{+E^6LXi(DvJJ0j-Ug*{zZS_ZIaGv)(=Y8Mbd*1W> zem5&;O@8vc7+2rkfj5jXH3#jqqiIx8y~7y$XYvMuqbwN5s>>sWqrbz9wrf{Od!K7I zHhe}Lf_=tScC9pQ46Flb4I#KIgPfwDUHi8RSyU%kFrT?yY(=cUXF1n&w8@yN zq$n1Jss5QDa*BBF{XdN*mmfBn2(I~*)H-F)wd4>xtwB1c2(GX=jQfhH{6wY1Y)Nb8 z9{d`a1c;kT&z zRpyB|Zd@5gO|_lYuZ?xTZ-Wr`wP)@uY_ycrGMD0@mYucpf4w6E4nAWptNJq;Y?n&I z#=!cYYWd`NiJlRG>ZPA!4)9oJTZ(9Jg5|$>n#VE)cc;(~QM#{)4C%3=vkkvH=?6t@ z`bBisc1A++PZTtLLRPW498KD_-V=7V4NS+>-K z|5(mFRGXPDn%b2#&g)mUcp>*+dT2vIDdH^~(I++3ovUIj&i3vn#q>)r?;&C% zqo<6vA~@H@HgbyKvN}7-DS}Js60Iwu=DfBfY?&1aZm-V1+w%x7L=g__4u3^X5nRAK zOZkCNM9sHtiDRCz0T<-Owt75n`P17j-+06ZAujM}ge?XomKQB2w$il#+b@GZ08+o?y0{~fK2v7h3 delta 21 dcmX>ge?XomKQB2w$il$n>ym%7H}Y)Z2LN952@(JR diff --git a/dominion/rngs.o b/dominion/rngs.o index 6a9e8488b8e9a2c75bdaac18b2282902f224eee0..824e908fc840eb6ec9a0a09c773444ae476d75f4 100644 GIT binary patch delta 3510 zcmbtWeQX@X6`$EVuh%#}`?9gmA0)AzIL^i1JLANz1K9aM)CqBm6Q`=90+;pO`fkm6 zFS^~sX)1c6h^l;4;h2=Fl0!-nRa#+@Z~_S;l>E_FxD`Szg8Tsp)T%;4q90OFMXM@( zZ)Vn<_ur1R^WOWt_kQzcc6N52zVAm%Pw$MqwTG;={ao8mx=82ceb2Sbj3n=x**!XJ ze0_N6w!Ma#UoagrXBwvK+F57Oay(-=d8$}gu+pBJ^xer!VbON%f|D#dSvQeQXG~6e z?dHv!A0J@B46`WqU4j9t70$P^$gO=lEB!aP)?gjEJNl^?I?ChruD8w%CX zR1{%_C8!Fp4n-(jXFDEIG;YZ}POO}J0COpi=1AyB9uOW#cfW(#vh`3x%Ba(2gw>;j z-u^x)N+qWrBlHfTpHw|U@8qPFSs0OX)}zgzKN~{ig>zDEQPpB&3NzrJa!a9RxG9+6)o@tcY)@TNi&zO<=iW9dlzd zREA_5AVt=KLo_A8?C;nkqk)%@2&IR0ET_2##!oiFsz6;eNn{X~N4zDzRdL~XtNG^G zzw4XIiyQeHSk;5#{ zUbH~tLpO*5ARshGk39OA@*TaT-B8AKWl|4qcu8A*^oQjO6>a58MO)>*-zy_cL~CbPF0k9b?t(3Lf5WqS!J89m3V;m9Ei{x&?(vvpbu;F*sJ5h|EgBiu7?^D zT1DyAQC_(MZmMc8soILRGOC@M(pD~L*OmG0z^MIJIOkREGi~(-M#ykDX5=WS)eNEx zZ_-v1_b3rqu;Z5N9Wxy`7m1rI6uoXdo?QEkh08)Fzxl21yV&>i-g39G=#?C6JZm{t z(N2SD7Sp-$(_^E?=$>vP+ikdBW<0%jZ?`dj3jOnN_|DsT%YZl+Ob-S!(uIetqL~F^ z%bT&R3}5k-M{Fl!ohGu5e8I_zGQ6T?E|M85Zza>-jIc@$9`IJCJDoF&Q0Z6tng^!9 zuC{C`|9`&-xgNEwM2v}rrzWTFJ$PU$m2yjSsl%z!k&)dasiBnIR$LrRlj*$a@QJ#F z&uSf6rcj#8TO^gjZO0eE_G~i`Yo8(0C7#9#`facetLOC-A+{s7k$tjBWsz7rZH7Nn zYbZpbQtDE+O4%mmrfPre;V|9KUhJBrebvvqUZ!*hJHPoV?PvFINzt9`%`JbY@#@M} zaP+eKdzK*fy&i~Vn|mi|53_pDLg*L0OLP}o+%^f`SE27^|Al@RyLGPYGFGEA0d6m%n?;~ViAU-E~k08#X zuy2nCB3=gvwv!Ua1UUoFG7I_PS8rZIA9o|~_4yd;5jL~lt zt-P7YSaYRp%68@pMC#_;T+w=nBx>Ad(R8wwyAI3Sj^(GgUXk_1A7p3aC!$)97V}(-ho1NTB4Wa?AqDu1BEzAikL%wEJ%D4{tdzBaN%|yYdrPA*yTs%KVV2E4f=3ux zzApJU8z|xf6cL!LEoHDdK`M-ykryZ=I{A#O)Z}flLYoWZa#$GUC*M_aXH?j%s=S_& zQE~EBmHmuLlc%c2Gb&I1s`{Q$W%E-tpoHw?sT$=#wY-`@wUa}Eq|D^Gn*Bhfx?1Io zs*{&$xdUb20!i7)rrPd6ky`Ejj4G3Db^3wiS)F)B_077v-x(P-CadZzZ?-TNXPi9G zBy%!{X@uYfNpMgw81O)7fz5@c`iz1MY7njjgklhwywNOQPy#Btff1^BvY~mt;0bjI z&jX>>T%0ox$O9=en0(P(oKbJ`L22R1dn|ca%R%D6kPv2?Ck&*-CSQ%2;E?Y(1Jip aX7X1nZKeW=$x7CCoI9Xer-2;_bPE8}Gk&%J diff --git a/dominion/unittest1.c b/dominion/unittest1.c new file mode 100644 index 000000000..2fe020854 --- /dev/null +++ b/dominion/unittest1.c @@ -0,0 +1,99 @@ +#include +#include +#include +#include "dominion.h" + +int baronEffect(struct gameState *state, int choiceDiscardCard); + +void assert(int a, char *s) { + if (!a) { + printf("Assert failed: %s\n", s); + } +} + +void assertEqual(int a, int b, char *s) { + if (a != b) { + printf("Assert failed: %s\n", s); + } +} + +int containsCard(int *container, int size, int card) { + for (int i=0; i < size; i++) { + if (container[i] == card) { + return 1; + } + } + return 0; +} + +int cardCount(int *container, int size, int card) { + int count = 0; + + for (int i=0; i < size; i++) { + if (container[i] == card) { + count++; + } + } + return count; +} + +int main() { + int seed = 47; + int p; + int choice1; + + // card array + int k[10] = { adventurer, council_room, feast, gardens, mine + , remodel, smithy, village, baron, great_hall }; + + // declare the game state + struct gameState G, G2; + + printf("\nBegin Testing baronEffect():\n\n"); + initializeGame(2, k, seed, &G); + G.whoseTurn = 0; + + printf("Test 1\n"); + memcpy(&G2, &G, sizeof(G)); + p = 0; + G2.hand[p][0] = baron; + choice1 = 0; // choose to gain an estate card + baronEffect(&G2, choice1); + assertEqual(G2.numBuys, G.numBuys + 1, "Number of buys not increased by 1"); + assert(containsCard(G2.discard[p], G2.discardCount[p], estate), "Estate card not gained"); + assert(containsCard(G2.playedCards, G2.playedCardCount, baron), "Baron card not discarded"); + + printf("Test 2\n"); + memcpy(&G2, &G, sizeof(G)); + p = 0; + G2.hand[p][0] = baron; + G2.hand[p][1] = estate; + choice1 = 1; // choose to discard an estate card + baronEffect(&G2, choice1); + assertEqual(G2.numBuys, G.numBuys + 1, "Number of buys not increased by 1"); + assertEqual(G2.coins, G.coins + 4, "Coins not increased by 4"); + assertEqual(cardCount(G2.hand[p], G2.handCount[p], estate), + cardCount(G.hand[p], G.handCount[p], estate) - 1, "Estate card not discarded"); + assertEqual(cardCount(G2.hand[p], G2.handCount[p], baron), + cardCount(G.hand[p], G.handCount[p], baron) - 1, "Baron card not discarded"); + + printf("Test 3\n"); + memcpy(&G2, &G, sizeof(G)); + p = 0; + G2.hand[p][0] = estate; + G2.hand[p][1] = baron; + G2.hand[p][2] = copper; + G2.hand[p][3] = copper; + G2.hand[p][4] = copper; + choice1 = 1; // choose to discard an estate card + baronEffect(&G2, choice1); + assertEqual(G2.numBuys, G.numBuys + 1, "Number of buys not increased by 1"); + assertEqual(G2.coins, G.coins + 4, "Coins not increased by 4"); + assertEqual(cardCount(G2.hand[p], G2.handCount[p], estate), + cardCount(G.hand[p], G.handCount[p], estate) - 1, "Estate card not discarded"); + assertEqual(cardCount(G2.hand[p], G2.handCount[p], baron), + cardCount(G.hand[p], G.handCount[p], baron) - 1, "Baron card not discarded"); + + printf("End of baronEffect() Tests\n\n"); + return 0; +} diff --git a/dominion/unittest2.c b/dominion/unittest2.c new file mode 100644 index 000000000..f83a8c163 --- /dev/null +++ b/dominion/unittest2.c @@ -0,0 +1,74 @@ +#include +#include +#include +#include "dominion.h" + +int minionEffect(struct gameState *state, int choiceGainCoins, int choiceDiscard, int handPos); + +void assert(int a, char *s) { + if (!a) { + printf("Assert failed: %s\n", s); + } +} + +void assertEqual(int a, int b, char *s) { + if (a != b) { + printf("Assert failed: %s\n", s); + } +} + +int containsCard(int *container, int size, int card) { + for (int i=0; i < size; i++) { + if (container[i] == card) { + return 1; + } + } + return 0; +} + +int main() { + int seed = 47; + int p; + int p2; + int choice1; + int choice2; + + // card array + int k[10] = { adventurer, council_room, feast, gardens, mine + , remodel, smithy, village, minion, great_hall }; + + // declare the game state + struct gameState G, G2; + + printf("\nBegin Testing minionEffect():\n\n"); + initializeGame(4, k, seed, &G); // 4 players + G.whoseTurn = 0; + + printf("Test 1\n"); + memcpy(&G2, &G, sizeof(G)); + p = 0; + G2.hand[p][0] = minion; + choice1 = 1; // choose +2 coins + choice2 = 0; + minionEffect(&G2, choice1, choice2, 0); + assertEqual(G2.numActions, G.numActions + 1, "Number of actions not increased by 1"); + assertEqual(G2.coins, G.coins + 2, "Number of coins not increased by 2"); + assert(containsCard(G2.playedCards, G2.playedCardCount, minion), "Minion card not discarded"); + + printf("Test 2\n"); + memcpy(&G2, &G, sizeof(G)); + p = 0; + p2 = 2; // another player + G2.hand[p][0] = minion; + G2.handCount[p2] = 3; // change handcount from 5 to 3 + choice1 = 0; + choice2 = 1; // choose to redraw hand + minionEffect(&G2, choice1, choice2, 0); + assertEqual(G2.numActions, G.numActions + 1, "Number of actions not increased by 1"); + assertEqual(G2.handCount[p], 4, "Current player should have exactly 4 cards"); + assertEqual(G2.handCount[p2], 3, "A player with less than 5 cards discarded hand"); + assert(containsCard(G2.playedCards, G2.playedCardCount, minion), "Minion card not discarded"); + + printf("End of minionEffect() Tests\n\n"); + return 0; +} diff --git a/dominion/unittest3.c b/dominion/unittest3.c new file mode 100644 index 000000000..3d8068e58 --- /dev/null +++ b/dominion/unittest3.c @@ -0,0 +1,95 @@ +#include +#include +#include +#include "dominion.h" + +int ambassadorEffect(struct gameState *state, int cardToDiscard, int numberOfCardsToDiscard, int handPos); + +void assert(int a, char *s) { + if (!a) { + printf("Assert failed: %s\n", s); + } +} + +void assertEqual(int a, int b, char *s) { + if (a != b) { + printf("Assert failed: %s\n", s); + } +} + +int containsCard(int *container, int size, int card) { + for (int i=0; i < size; i++) { + if (container[i] == card) { + return 1; + } + } + return 0; +} + +int cardCount(int *container, int size, int card) { + int count = 0; + + for (int i=0; i < size; i++) { + if (container[i] == card) { + count++; + } + } + return count; +} + +int main() { + int seed = 47; + int p; + int p2; + int handPos; + int choice1; + int choice2; + int ret_val; + + // card array + int k[10] = { adventurer, council_room, feast, gardens, mine + , remodel, smithy, village, ambassador, great_hall }; + + // declare the game state + struct gameState G, G2; + + printf("\nBegin Testing ambassadorEffect():\n\n"); + initializeGame(2, k, seed, &G); + G.whoseTurn = 0; + + printf("Test 1\n"); + memcpy(&G2, &G, sizeof(G)); + p = 0; + p2 = 1; + G2.hand[p][0] = copper; + G2.hand[p][1] = smithy; + G2.hand[p][2] = copper; + G2.hand[p][3] = copper; + G2.hand[p][4] = ambassador; + choice1 = 0; // choose to discard copper + choice2 = 3; // choose to discard 3 of them + handPos = 4; // ambassador + ret_val = ambassadorEffect(&G2, choice1, choice2, handPos); + assertEqual(ret_val, -1, "Didn't return -1 when trying to discard too many cards"); + assertEqual(cardCount(G2.hand[p], G2.handCount[p], copper), + cardCount(G.hand[p], G.handCount[p], copper) - choice2, "Trashed the wrong number of cards"); + assert(containsCard(G2.playedCards, G2.playedCardCount, ambassador), "Ambassador card not discarded"); + assert(containsCard(G2.discard[p2], G2.discardCount[p2], copper), "Player 2 did not gain a copper"); + + printf("Test 2\n"); + memcpy(&G2, &G, sizeof(G)); + p = 0; + p2 = 1; + G2.hand[p][0] = ambassador; + G2.hand[p][1] = ambassador; + choice1 = 0; // choose to discard ambassador + choice2 = 1; // choose to discard 1 of them + handPos = 0; // ambassador + ret_val = ambassadorEffect(&G2, choice1, choice2, handPos); + assertEqual(ret_val, -1, "Didn't return -1 when trying to discard ambassador card"); + assert(containsCard(G2.playedCards, G2.playedCardCount, ambassador), "Ambassador card not discarded"); + assert(containsCard(G2.discard[p2], G2.discardCount[p2], ambassador), "Player 2 did not gain an ambassador card"); + + printf("End of ambassadorEffect() Tests\n\n"); + return 0; +} diff --git a/dominion/unittest4 b/dominion/unittest4 new file mode 100644 index 0000000000000000000000000000000000000000..afe4efd3713095cf1d1061dc19ff58f4ccfddd2b GIT binary patch literal 74640 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 literal 0 HcmV?d00001 diff --git a/dominion/unittest4.c b/dominion/unittest4.c new file mode 100644 index 000000000..054b2907e --- /dev/null +++ b/dominion/unittest4.c @@ -0,0 +1,128 @@ +#include +#include +#include +#include "dominion.h" + +int tributeEffect(struct gameState *state, int handPos); + +void assert(int a, char *s) { + if (!a) { + printf("Assert failed: %s\n", s); + } +} + +void assertEqual(int a, int b, char *s) { + if (a != b) { + printf("Assert failed: %s\n", s); + } +} + +int containsCard(int *container, int size, int card) { + for (int i=0; i < size; i++) { + if (container[i] == card) { + return 1; + } + } + return 0; +} + +int cardCount(int *container, int size, int card) { + int count = 0; + + for (int i=0; i < size; i++) { + if (container[i] == card) { + count++; + } + } + return count; +} + +int main() { + int seed = 47; + int p; + int p2; + //int tributeRevealedCards[2]; + int result; + + // card array + int k[10] = { adventurer, council_room, feast, gardens, mine + , remodel, smithy, village, tribute, great_hall }; + + // declare the game state + struct gameState G, G2; + + printf("\nBegin Testing tributeEffect():\n\n"); + initializeGame(2, k, seed, &G); + G.whoseTurn = 1; + + // Debug test + memcpy(&G2, &G, sizeof(G)); + p = 1; + p2 = 0; + G2.hand[p][0] = tribute; + G2.deck[p2][G2.deckCount[p2]-2] = smithy; + G2.deck[p2][G2.deckCount[p2]-1] = estate; + tributeEffect(&G2, 0); + result = containsCard(G2.playedCards, G2.playedCardCount, tribute); + assert(result, "Tribute card not discarded"); + if (result) + assertEqual(G2.handCount[p], G.handCount[p]+1, "Didn't draw 2 cards"); + else + assertEqual(G2.handCount[p], G.handCount[p]+2, "Didn't draw 2 cards"); + assertEqual(G2.numActions, G.numActions+2, "Actions didn't increase by 2"); + +/* + printf("Test 1\n"); + memcpy(&G2, &G, sizeof(G)); + p = 0; + p2 = 1; + G2.hand[p][0] = tribute; + G2.deckCount[p2] = 0; + G2.discardCount[p2] = 2; + G2.discard[p2][G2.discardCount[p2]-2] = copper; + G2.discard[p2][G2.discardCount[p2]-1] = estate; + tributeEffect(&G2, 0); + result = containsCard(G2.playedCards, G2.playedCardCount, tribute); + assert(result, "Tribute card not discarded"); + if (result) + assertEqual(G2.handCount[p], G.handCount[p]+1, "Didn't draw 2 cards"); + else + assertEqual(G2.handCount[p], G.handCount[p]+2, "Didn't draw 2 cards"); + assertEqual(G2.coins, G.coins+2, "Coins didn't increase by 2"); + + printf("Test 2\n"); + memcpy(&G2, &G, sizeof(G)); + p = 0; + p2 = 1; + G2.hand[p][0] = tribute; + G2.deck[p2][G2.deckCount[p2]-2] = smithy; + G2.deck[p2][G2.deckCount[p2]-1] = estate; + tributeEffect(&G2, 0); + result = containsCard(G2.playedCards, G2.playedCardCount, tribute); + assert(result, "Tribute card not discarded"); + if (result) + assertEqual(G2.handCount[p], G.handCount[p]+1, "Didn't draw 2 cards"); + else + assertEqual(G2.handCount[p], G.handCount[p]+2, "Didn't draw 2 cards"); + assertEqual(G2.numActions, G.numActions+2, "Actions didn't increase by 2"); + + printf("Test 3\n"); + memcpy(&G2, &G, sizeof(G)); + p = 0; + p2 = 1; + G2.hand[p][0] = tribute; + G2.deckCount[p2] = 0; + G2.discardCount[p2] = 1; + G2.discard[p2][0] = estate; + tributeEffect(&G2, 0); + result = containsCard(G2.playedCards, G2.playedCardCount, tribute); + assert(result, "Tribute card not discarded"); + if (result) + assertEqual(G2.handCount[p], G.handCount[p]+1, "Didn't draw 2 cards"); + else + assertEqual(G2.handCount[p], G.handCount[p]+2, "Didn't draw 2 cards"); +*/ + + printf("End of tributeEffect() Tests\n\n"); + return 0; +} diff --git a/dominion/unittest4.gcda b/dominion/unittest4.gcda new file mode 100644 index 0000000000000000000000000000000000000000..62ce12b1d8b282867b559076846a60493b009621 GIT binary patch literal 736 zcmYdHNlp*4FfehSvSI@R1H3T3~uWVjzG{ X1BJkPKxQRpysk&qgT;K15nuoSLhmbK literal 0 HcmV?d00001 diff --git a/dominion/unittest4.gcno b/dominion/unittest4.gcno new file mode 100644 index 0000000000000000000000000000000000000000..2331b99ef5ca4fcbeaec2a765615bf025d104bc3 GIT binary patch literal 2628 zcmd6pxo#9e5QclqeIvvnSppdl5)dFuSYU)X*2BoeyumWIV1=2Ly|XD!h!6n*k3c|z zjEHyzUVsP^QbbBjeO*&KJ3R-IMLmJ-51$6t;ivu0)p$70 za%qR-&-#%)e-?c6uc3N}RZGPMS>h-oVmG^x5K6Yus`i_a0)~yNOrP8`J vIZ+a6`TswxD}DNNi`ub2tzBIs{a*aPbz^ +#include +#include +#include "dominion.h" + +int mineEffect(struct gameState *state, int treasureToTrash, int treasureToGain, int handPos); + +void assert(int a, char *s) { + if (!a) { + printf("Assert failed: %s\n", s); + } +} + +void assertEqual(int a, int b, char *s) { + if (a != b) { + printf("Assert failed: %s\n", s); + } +} + +int containsCard(int *container, int size, int card) { + for (int i=0; i < size; i++) { + if (container[i] == card) { + return 1; + } + } + return 0; +} + +int cardCount(int *container, int size, int card) { + int count = 0; + + for (int i=0; i < size; i++) { + if (container[i] == card) { + count++; + } + } + return count; +} + +int main() { + int seed = 47; + int p; + int handPos; + int choice1; + int choice2; + int ret_val; + + // card array + int k[10] = { adventurer, council_room, feast, gardens, mine + , remodel, smithy, village, ambassador, great_hall }; + + // declare the game state + struct gameState G, G2; + + printf("\nBegin Testing mineEffect():\n\n"); + initializeGame(2, k, seed, &G); + G.whoseTurn = 0; + + printf("Test 1\n"); + memcpy(&G2, &G, sizeof(G)); + p = 0; + G2.hand[p][0] = curse; + G2.hand[p][1] = mine; + choice1 = 0; // choose to trash curse + choice2 = silver; // choose to gain a silver + handPos = 1; // mine + ret_val = mineEffect(&G2, choice1, choice2, handPos); + assertEqual(ret_val, -1, "Didn't return -1 when trying to trash a curse"); + + printf("Test 2\n"); + memcpy(&G2, &G, sizeof(G)); + p = 0; + G2.hand[p][0] = copper; + G2.hand[p][1] = mine; + G2.hand[p][2] = copper; + G2.hand[p][3] = estate; + G2.hand[p][4] = estate; + choice1 = 0; // choose to trash copper + choice2 = silver; // choose to gain a silver + handPos = 1; // mine + ret_val = mineEffect(&G2, choice1, choice2, handPos); + assert(containsCard(G2.playedCards, G2.playedCardCount, mine), "Mine card not discarded"); + assert(containsCard(G2.hand[p], G2.handCount[p], silver), "Silver not gained to hand"); + assert(containsCard(G2.playedCards, G2.playedCardCount, copper), "Copper card not discarded"); + + printf("Test 3\n"); + memcpy(&G2, &G, sizeof(G)); + p = 0; + G2.hand[p][0] = smithy; + G2.hand[p][1] = mine; + choice1 = 0; // choose to trash smithy + choice2 = silver; // choose to gain a silver + handPos = 1; // mine + ret_val = mineEffect(&G2, choice1, choice2, handPos); + assertEqual(ret_val, -1, "Didn't return -1 when trying to trash a smithy"); + + printf("End of mineEffect() Tests\n\n"); + return 0; +} From 36b4ed59a7cebc5f2e5497aa32d832dc85d653b1 Mon Sep 17 00:00:00 2001 From: zee100100 Date: Wed, 27 Nov 2019 23:41:27 -0800 Subject: [PATCH 10/15] Create hw.c --- dominion/as3/hw.c | 1 + 1 file changed, 1 insertion(+) create mode 100644 dominion/as3/hw.c diff --git a/dominion/as3/hw.c b/dominion/as3/hw.c new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/dominion/as3/hw.c @@ -0,0 +1 @@ + From bc765357ca736ac061e872974a0a4e2e6b51219c Mon Sep 17 00:00:00 2001 From: zee100100 Date: Wed, 27 Nov 2019 23:42:12 -0800 Subject: [PATCH 11/15] Add files via upload --- dominion/as3/dominion.c | 1420 +++++++++++++++++++++ dominion/as3/dominion.c.gcov | 1961 ++++++++++++++++++++++++++++++ dominion/as3/dominion.gcda | Bin 0 -> 5848 bytes dominion/as3/dominion.gcno | Bin 0 -> 41668 bytes dominion/as3/dominion.h | 131 ++ dominion/as3/dominion.o | Bin 0 -> 53784 bytes dominion/as3/dominion_helpers.h | 15 + dominion/as3/rngs.c | 183 +++ dominion/as3/rngs.gcda | Bin 0 -> 2664 bytes dominion/as3/rngs.gcno | Bin 0 -> 4032 bytes dominion/as3/rngs.h | 19 + dominion/as3/rngs.o | Bin 0 -> 11728 bytes dominion/as3/unittest1 | Bin 0 -> 62552 bytes dominion/as3/unittest1.gcda | Bin 0 -> 936 bytes dominion/as3/unittest1.gcno | Bin 0 -> 3924 bytes dominion/as3/unittest2 | Bin 0 -> 62352 bytes dominion/as3/unittest2.gcda | Bin 0 -> 792 bytes dominion/as3/unittest2.gcno | Bin 0 -> 2512 bytes dominion/as3/unittest3 | Bin 0 -> 62552 bytes dominion/as3/unittest3.gcda | Bin 0 -> 836 bytes dominion/as3/unittest3.gcno | Bin 0 -> 3216 bytes dominion/as3/unittest4 | Bin 0 -> 62552 bytes dominion/as3/unittest4.gcda | Bin 0 -> 904 bytes dominion/as3/unittest4.gcno | Bin 0 -> 3900 bytes dominion/as3/unittest5 | Bin 0 -> 62552 bytes dominion/as3/unittest5.gcda | Bin 0 -> 812 bytes dominion/as3/unittest5.gcno | Bin 0 -> 3096 bytes dominion/as3/unittestresults.out | 963 +++++++++++++++ 28 files changed, 4692 insertions(+) create mode 100644 dominion/as3/dominion.c create mode 100644 dominion/as3/dominion.c.gcov create mode 100644 dominion/as3/dominion.gcda create mode 100644 dominion/as3/dominion.gcno create mode 100644 dominion/as3/dominion.h create mode 100644 dominion/as3/dominion.o create mode 100644 dominion/as3/dominion_helpers.h create mode 100644 dominion/as3/rngs.c create mode 100644 dominion/as3/rngs.gcda create mode 100644 dominion/as3/rngs.gcno create mode 100644 dominion/as3/rngs.h create mode 100644 dominion/as3/rngs.o create mode 100644 dominion/as3/unittest1 create mode 100644 dominion/as3/unittest1.gcda create mode 100644 dominion/as3/unittest1.gcno create mode 100644 dominion/as3/unittest2 create mode 100644 dominion/as3/unittest2.gcda create mode 100644 dominion/as3/unittest2.gcno create mode 100644 dominion/as3/unittest3 create mode 100644 dominion/as3/unittest3.gcda create mode 100644 dominion/as3/unittest3.gcno create mode 100644 dominion/as3/unittest4 create mode 100644 dominion/as3/unittest4.gcda create mode 100644 dominion/as3/unittest4.gcno create mode 100644 dominion/as3/unittest5 create mode 100644 dominion/as3/unittest5.gcda create mode 100644 dominion/as3/unittest5.gcno create mode 100644 dominion/as3/unittestresults.out diff --git a/dominion/as3/dominion.c b/dominion/as3/dominion.c new file mode 100644 index 000000000..0c865f97e --- /dev/null +++ b/dominion/as3/dominion.c @@ -0,0 +1,1420 @@ +#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 doMine(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) +{ + int i; + int j; + + 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; +} + +void getEstateCard(struct gameState *state, int currentPlayer) +{ + 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); + } + } +} + +void doBaron(int choice1, struct gameState *state, int currentPlayer) +{ + state->numBuys++;//Increase buys by 1! + state->numBuys++;//Increase buys by 1! + if (choice1 > 0) { //Boolean true or going to discard an estate + int p = 1; //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"); + } + getEstateCard(state, currentPlayer); + card_not_discarded = 0;//Exit the loop + } + + else { + p++;//Next card + } + } + } + + else { + getEstateCard(state, currentPlayer); + } +} + +void doMinion(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) +{ + int i; + int j; + + //+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) > 1 /*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); + } + } + } + } + } +} + +void printDeck(struct gameState *state, int p) { + printf("Deck:"); + for (int i=0; i < state->deckCount[p]; i++) + printf(" %d", state->deck[p][i]); + printf("\n"); +} + +void printHand(struct gameState *state, int p) { + printf("Hand:"); + for (int i=0; i < state->handCount[p]; i++) + printf(" %d", state->hand[p][i]); + printf("\n"); +} + +void doTribute(struct gameState *state, int currentPlayer, int nextPlayer, int tributeRevealedCards[2]) +{ + int i; + + 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]; + tributeRevealedCards[1] = state->deck[nextPlayer][state->deckCount[nextPlayer]-2]; + //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->numActions = state->numActions + 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->coins += 2; + } + } +} + +int doAmbassador(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) +{ + int i; + int j; + + j = 0; //used to check if player has enough cards to discard + + if (choice2 > 3 || choice2 < 0) + { + return -1; + } + +/* + if (choice1 == handPos) + { + return -1; + } + */ + + for (i = 0; i < state->handCount[currentPlayer]; i++) + { + if (i != handPos && state->hand[currentPlayer][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; +} + +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: + return doMine(choice1, choice2, state, handPos, currentPlayer); + + 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: + doBaron(choice1, state, currentPlayer); + 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: + doMinion(choice1, choice2, state, handPos, currentPlayer); + 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: + doTribute(state, currentPlayer, nextPlayer, tributeRevealedCards); + return 0; + + case ambassador: + return doAmbassador(choice1, choice2, state, handPos, currentPlayer); + + 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/dominion/as3/dominion.c.gcov b/dominion/as3/dominion.c.gcov new file mode 100644 index 000000000..3292286c4 --- /dev/null +++ b/dominion/as3/dominion.c.gcov @@ -0,0 +1,1961 @@ + -: 0:Source:dominion.c + -: 0:Graph:dominion.gcno + -: 0:Data:dominion.gcda + -: 0:Runs:5 + -: 0:Programs:5 + -: 1:#include "dominion.h" + -: 2:#include "dominion_helpers.h" + -: 3:#include "rngs.h" + -: 4:#include + -: 5:#include + -: 6:#include + -: 7: +function compare called 180 returned 100% blocks executed 83% + 180: 8:int compare(const void* a, const void* b) { + 180: 9: if (*(int*)a > *(int*)b) +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + #####: 10: return 1; + 180: 11: if (*(int*)a < *(int*)b) +branch 0 taken 27% (fallthrough) +branch 1 taken 73% + 48: 12: return -1; + 132: 13: return 0; + -: 14:} + -: 15: +function newGame called 0 returned 0% blocks executed 0% + #####: 16:struct gameState* newGame() { + #####: 17: struct gameState* g = malloc(sizeof(struct gameState)); + #####: 18: return g; + -: 19:} + -: 20: +function kingdomCards called 0 returned 0% blocks executed 0% + #####: 21:int* kingdomCards(int k1, int k2, int k3, int k4, int k5, int k6, int k7, + -: 22: int k8, int k9, int k10) { + #####: 23: int* k = malloc(10 * sizeof(int)); + #####: 24: k[0] = k1; + #####: 25: k[1] = k2; + #####: 26: k[2] = k3; + #####: 27: k[3] = k4; + #####: 28: k[4] = k5; + #####: 29: k[5] = k6; + #####: 30: k[6] = k7; + #####: 31: k[7] = k8; + #####: 32: k[8] = k9; + #####: 33: k[9] = k10; + #####: 34: return k; + -: 35:} + -: 36: +function initializeGame called 5 returned 100% blocks executed 94% + 5: 37:int initializeGame(int numPlayers, int kingdomCards[10], int randomSeed, + -: 38: struct gameState *state) { + -: 39: int i; + -: 40: int j; + -: 41: int it; + -: 42: + -: 43: //set up random number generator + 5: 44: SelectStream(1); +call 0 returned 100% + 5: 45: PutSeed((long)randomSeed); +call 0 returned 100% + -: 46: + -: 47: //check number of players + 5: 48: if (numPlayers > MAX_PLAYERS || numPlayers < 2) +branch 0 taken 100% (fallthrough) +branch 1 taken 0% +branch 2 taken 0% (fallthrough) +branch 3 taken 100% + -: 49: { + #####: 50: return -1; + -: 51: } + -: 52: + -: 53: //set number of players + 5: 54: state->numPlayers = numPlayers; + -: 55: + -: 56: //check selected kingdom cards are different + 55: 57: for (i = 0; i < 10; i++) +branch 0 taken 91% +branch 1 taken 9% (fallthrough) + -: 58: { + 550: 59: for (j = 0; j < 10; j++) +branch 0 taken 91% +branch 1 taken 9% (fallthrough) + -: 60: { + 500: 61: if (j != i && kingdomCards[j] == kingdomCards[i]) +branch 0 taken 90% (fallthrough) +branch 1 taken 10% +branch 2 taken 0% (fallthrough) +branch 3 taken 100% + -: 62: { + #####: 63: return -1; + -: 64: } + -: 65: } + -: 66: } + -: 67: + -: 68: + -: 69: //initialize supply + -: 70: /////////////////////////////// + -: 71: + -: 72: //set number of Curse cards + 5: 73: if (numPlayers == 2) +branch 0 taken 80% (fallthrough) +branch 1 taken 20% + -: 74: { + 4: 75: state->supplyCount[curse] = 10; + -: 76: } + 1: 77: else if (numPlayers == 3) +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + -: 78: { + #####: 79: state->supplyCount[curse] = 20; + -: 80: } + -: 81: else + -: 82: { + 1: 83: state->supplyCount[curse] = 30; + -: 84: } + -: 85: + -: 86: //set number of Victory cards + 5: 87: if (numPlayers == 2) +branch 0 taken 80% (fallthrough) +branch 1 taken 20% + -: 88: { + 4: 89: state->supplyCount[estate] = 8; + 4: 90: state->supplyCount[duchy] = 8; + 4: 91: state->supplyCount[province] = 8; + -: 92: } + -: 93: else + -: 94: { + 1: 95: state->supplyCount[estate] = 12; + 1: 96: state->supplyCount[duchy] = 12; + 1: 97: state->supplyCount[province] = 12; + -: 98: } + -: 99: + -: 100: //set number of Treasure cards + 5: 101: state->supplyCount[copper] = 60 - (7 * numPlayers); + 5: 102: state->supplyCount[silver] = 40; + 5: 103: state->supplyCount[gold] = 30; + -: 104: + -: 105: //set number of Kingdom cards + 105: 106: for (i = adventurer; i <= treasure_map; i++) //loop all cards +branch 0 taken 95% +branch 1 taken 5% (fallthrough) + -: 107: { + 825: 108: for (j = 0; j < 10; j++) //loop chosen cards +branch 0 taken 94% +branch 1 taken 6% (fallthrough) + -: 109: { + 775: 110: if (kingdomCards[j] == i) +branch 0 taken 6% (fallthrough) +branch 1 taken 94% + -: 111: { + -: 112: //check if card is a 'Victory' Kingdom card + 50: 113: if (kingdomCards[j] == great_hall || kingdomCards[j] == gardens) +branch 0 taken 90% (fallthrough) +branch 1 taken 10% +branch 2 taken 11% (fallthrough) +branch 3 taken 89% + -: 114: { + 20: 115: if (numPlayers == 2) { +branch 0 taken 80% (fallthrough) +branch 1 taken 20% + 8: 116: state->supplyCount[i] = 8; + -: 117: } + -: 118: else { + 2: 119: state->supplyCount[i] = 12; + -: 120: } + -: 121: } + -: 122: else + -: 123: { + 40: 124: state->supplyCount[i] = 10; + -: 125: } + 50: 126: break; + -: 127: } + -: 128: else //card is not in the set choosen for the game + -: 129: { + 725: 130: state->supplyCount[i] = -1; + -: 131: } + -: 132: } + -: 133: + -: 134: } + -: 135: + -: 136: //////////////////////// + -: 137: //supply intilization complete + -: 138: + -: 139: //set player decks + 17: 140: for (i = 0; i < numPlayers; i++) +branch 0 taken 71% +branch 1 taken 29% (fallthrough) + -: 141: { + 12: 142: state->deckCount[i] = 0; + 48: 143: for (j = 0; j < 3; j++) +branch 0 taken 75% +branch 1 taken 25% (fallthrough) + -: 144: { + 36: 145: state->deck[i][j] = estate; + 36: 146: state->deckCount[i]++; + -: 147: } + 96: 148: for (j = 3; j < 10; j++) +branch 0 taken 88% +branch 1 taken 13% (fallthrough) + -: 149: { + 84: 150: state->deck[i][j] = copper; + 84: 151: state->deckCount[i]++; + -: 152: } + -: 153: } + -: 154: + -: 155: //shuffle player decks + 17: 156: for (i = 0; i < numPlayers; i++) +branch 0 taken 71% +branch 1 taken 29% (fallthrough) + -: 157: { + 12: 158: if ( shuffle(i, state) < 0 ) +call 0 returned 100% +branch 1 taken 0% (fallthrough) +branch 2 taken 100% + -: 159: { + #####: 160: return -1; + -: 161: } + -: 162: } + -: 163: + -: 164: //draw player hands + 17: 165: for (i = 0; i < numPlayers; i++) +branch 0 taken 71% +branch 1 taken 29% (fallthrough) + -: 166: { + -: 167: //initialize hand size to zero + 12: 168: state->handCount[i] = 0; + 12: 169: state->discardCount[i] = 0; + -: 170: //draw 5 cards + -: 171: // for (j = 0; j < 5; j++) + -: 172: // { + -: 173: // drawCard(i, state); + -: 174: // } + -: 175: } + -: 176: + -: 177: //set embargo tokens to 0 for all supply piles + 140: 178: for (i = 0; i <= treasure_map; i++) +branch 0 taken 96% +branch 1 taken 4% (fallthrough) + -: 179: { + 135: 180: state->embargoTokens[i] = 0; + -: 181: } + -: 182: + -: 183: //initialize first player's turn + 5: 184: state->outpostPlayed = 0; + 5: 185: state->phase = 0; + 5: 186: state->numActions = 1; + 5: 187: state->numBuys = 1; + 5: 188: state->playedCardCount = 0; + 5: 189: state->whoseTurn = 0; + 5: 190: state->handCount[state->whoseTurn] = 0; + -: 191: //int it; move to top + -: 192: + -: 193: //Moved draw cards to here, only drawing at the start of a turn + 30: 194: for (it = 0; it < 5; it++) { +branch 0 taken 83% +branch 1 taken 17% (fallthrough) + 25: 195: drawCard(state->whoseTurn, state); +call 0 returned 100% + -: 196: } + -: 197: + 5: 198: updateCoins(state->whoseTurn, state, 0); +call 0 returned 100% + -: 199: + 5: 200: return 0; + -: 201:} + -: 202: +function shuffle called 13 returned 100% blocks executed 94% + 13: 203:int shuffle(int player, struct gameState *state) { + -: 204: + -: 205: + -: 206: int newDeck[MAX_DECK]; + 13: 207: int newDeckPos = 0; + -: 208: int card; + -: 209: int i; + -: 210: + 13: 211: if (state->deckCount[player] < 1) +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + #####: 212: return -1; + 13: 213: qsort ((void*)(state->deck[player]), state->deckCount[player], sizeof(int), compare); +call 0 returned 100% + -: 214: /* SORT CARDS IN DECK TO ENSURE DETERMINISM! */ + -: 215: + 147: 216: while (state->deckCount[player] > 0) { +branch 0 taken 90% +branch 1 taken 10% (fallthrough) + 121: 217: card = floor(Random() * state->deckCount[player]); +call 0 returned 100% + 121: 218: newDeck[newDeckPos] = state->deck[player][card]; + 121: 219: newDeckPos++; + 442: 220: for (i = card; i < state->deckCount[player]-1; i++) { +branch 0 taken 73% +branch 1 taken 27% (fallthrough) + 321: 221: state->deck[player][i] = state->deck[player][i+1]; + -: 222: } + 121: 223: state->deckCount[player]--; + -: 224: } + 134: 225: for (i = 0; i < newDeckPos; i++) { +branch 0 taken 90% +branch 1 taken 10% (fallthrough) + 121: 226: state->deck[player][i] = newDeck[i]; + 121: 227: state->deckCount[player]++; + -: 228: } + -: 229: + 13: 230: return 0; + -: 231:} + -: 232: +function playCard called 0 returned 0% blocks executed 0% + #####: 233:int playCard(int handPos, int choice1, int choice2, int choice3, struct gameState *state) + -: 234:{ + -: 235: int card; + #####: 236: int coin_bonus = 0; //tracks coins gain from actions + -: 237: + -: 238: //check if it is the right phase + #####: 239: if (state->phase != 0) +branch 0 never executed +branch 1 never executed + -: 240: { + #####: 241: return -1; + -: 242: } + -: 243: + -: 244: //check if player has enough actions + #####: 245: if ( state->numActions < 1 ) +branch 0 never executed +branch 1 never executed + -: 246: { + #####: 247: return -1; + -: 248: } + -: 249: + -: 250: //get card played + #####: 251: card = handCard(handPos, state); +call 0 never executed + -: 252: + -: 253: //check if selected card is an action + #####: 254: if ( card < adventurer || card > treasure_map ) +branch 0 never executed +branch 1 never executed +branch 2 never executed +branch 3 never executed + -: 255: { + #####: 256: return -1; + -: 257: } + -: 258: + -: 259: //play card + #####: 260: if ( cardEffect(card, choice1, choice2, choice3, state, handPos, &coin_bonus) < 0 ) +call 0 never executed +branch 1 never executed +branch 2 never executed + -: 261: { + #####: 262: return -1; + -: 263: } + -: 264: + -: 265: //reduce number of actions + #####: 266: state->numActions--; + -: 267: + -: 268: //update coins (Treasure cards may be added with card draws) + #####: 269: updateCoins(state->whoseTurn, state, coin_bonus); +call 0 never executed + -: 270: + #####: 271: return 0; + -: 272:} + -: 273: +function buyCard called 0 returned 0% blocks executed 0% + #####: 274:int buyCard(int supplyPos, struct gameState *state) { + -: 275: int who; + -: 276: if (DEBUG) { + -: 277: printf("Entering buyCard...\n"); + -: 278: } + -: 279: + -: 280: // I don't know what to do about the phase thing. + -: 281: + #####: 282: who = state->whoseTurn; + -: 283: + #####: 284: if (state->numBuys < 1) { +branch 0 never executed +branch 1 never executed + -: 285: if (DEBUG) + -: 286: printf("You do not have any buys left\n"); + #####: 287: return -1; + #####: 288: } else if (supplyCount(supplyPos, state) <1) { +call 0 never executed +branch 1 never executed +branch 2 never executed + -: 289: if (DEBUG) + -: 290: printf("There are not any of that type of card left\n"); + #####: 291: return -1; + #####: 292: } else if (state->coins < getCost(supplyPos)) { +call 0 never executed +branch 1 never executed +branch 2 never executed + -: 293: if (DEBUG) + -: 294: printf("You do not have enough money to buy that. You have %d coins.\n", state->coins); + #####: 295: return -1; + -: 296: } else { + #####: 297: state->phase=1; + -: 298: //state->supplyCount[supplyPos]--; + #####: 299: gainCard(supplyPos, state, 0, who); //card goes in discard, this might be wrong.. (2 means goes into hand, 0 goes into discard) +call 0 never executed + -: 300: + #####: 301: state->coins = (state->coins) - (getCost(supplyPos)); +call 0 never executed + #####: 302: state->numBuys--; + -: 303: if (DEBUG) + -: 304: 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); + -: 305: } + -: 306: + -: 307: //state->discard[who][state->discardCount[who]] = supplyPos; + -: 308: //state->discardCount[who]++; + -: 309: + #####: 310: return 0; + -: 311:} + -: 312: +function numHandCards called 4 returned 100% blocks executed 100% + 4: 313:int numHandCards(struct gameState *state) { + 4: 314: return state->handCount[ whoseTurn(state) ]; +call 0 returned 100% + -: 315:} + -: 316: +function handCard called 0 returned 0% blocks executed 0% + #####: 317:int handCard(int handPos, struct gameState *state) { + #####: 318: int currentPlayer = whoseTurn(state); +call 0 never executed + #####: 319: return state->hand[currentPlayer][handPos]; + -: 320:} + -: 321: +function supplyCount called 8 returned 100% blocks executed 100% + 8: 322:int supplyCount(int card, struct gameState *state) { + 8: 323: return state->supplyCount[card]; + -: 324:} + -: 325: +function fullDeckCount called 0 returned 0% blocks executed 0% + #####: 326:int fullDeckCount(int player, int card, struct gameState *state) { + -: 327: int i; + #####: 328: int count = 0; + -: 329: + #####: 330: for (i = 0; i < state->deckCount[player]; i++) +branch 0 never executed +branch 1 never executed + -: 331: { + #####: 332: if (state->deck[player][i] == card) count++; +branch 0 never executed +branch 1 never executed + -: 333: } + -: 334: + #####: 335: for (i = 0; i < state->handCount[player]; i++) +branch 0 never executed +branch 1 never executed + -: 336: { + #####: 337: if (state->hand[player][i] == card) count++; +branch 0 never executed +branch 1 never executed + -: 338: } + -: 339: + #####: 340: for (i = 0; i < state->discardCount[player]; i++) +branch 0 never executed +branch 1 never executed + -: 341: { + #####: 342: if (state->discard[player][i] == card) count++; +branch 0 never executed +branch 1 never executed + -: 343: } + -: 344: + #####: 345: return count; + -: 346:} + -: 347: +function whoseTurn called 4 returned 100% blocks executed 100% + 4: 348:int whoseTurn(struct gameState *state) { + 4: 349: return state->whoseTurn; + -: 350:} + -: 351: +function endTurn called 0 returned 0% blocks executed 0% + #####: 352:int endTurn(struct gameState *state) { + -: 353: int k; + -: 354: int i; + #####: 355: int currentPlayer = whoseTurn(state); +call 0 never executed + -: 356: + -: 357: //Discard hand + #####: 358: for (i = 0; i < state->handCount[currentPlayer]; i++) { +branch 0 never executed +branch 1 never executed + #####: 359: state->discard[currentPlayer][state->discardCount[currentPlayer]++] = state->hand[currentPlayer][i];//Discard + #####: 360: state->hand[currentPlayer][i] = -1;//Set card to -1 + -: 361: } + #####: 362: state->handCount[currentPlayer] = 0;//Reset hand count + -: 363: + -: 364: //Code for determining the player + #####: 365: if (currentPlayer < (state->numPlayers - 1)) { +branch 0 never executed +branch 1 never executed + #####: 366: state->whoseTurn = currentPlayer + 1;//Still safe to increment + -: 367: } + -: 368: else { + #####: 369: state->whoseTurn = 0;//Max player has been reached, loop back around to player 1 + -: 370: } + -: 371: + #####: 372: state->outpostPlayed = 0; + #####: 373: state->phase = 0; + #####: 374: state->numActions = 1; + #####: 375: state->coins = 0; + #####: 376: state->numBuys = 1; + #####: 377: state->playedCardCount = 0; + #####: 378: state->handCount[state->whoseTurn] = 0; + -: 379: + -: 380: //int k; move to top + -: 381: //Next player draws hand + #####: 382: for (k = 0; k < 5; k++) { +branch 0 never executed +branch 1 never executed + #####: 383: drawCard(state->whoseTurn, state);//Draw a card +call 0 never executed + -: 384: } + -: 385: + -: 386: //Update money + #####: 387: updateCoins(state->whoseTurn, state, 0); +call 0 never executed + -: 388: + #####: 389: return 0; + -: 390:} + -: 391: +function isGameOver called 0 returned 0% blocks executed 0% + #####: 392:int isGameOver(struct gameState *state) { + -: 393: int i; + -: 394: int j; + -: 395: + -: 396: //if stack of Province cards is empty, the game ends + #####: 397: if (state->supplyCount[province] == 0) +branch 0 never executed +branch 1 never executed + -: 398: { + #####: 399: return 1; + -: 400: } + -: 401: + -: 402: //if three supply pile are at 0, the game ends + #####: 403: j = 0; + #####: 404: for (i = 0; i < 25; i++) +branch 0 never executed +branch 1 never executed + -: 405: { + #####: 406: if (state->supplyCount[i] == 0) +branch 0 never executed +branch 1 never executed + -: 407: { + #####: 408: j++; + -: 409: } + -: 410: } + #####: 411: if ( j >= 3) +branch 0 never executed +branch 1 never executed + -: 412: { + #####: 413: return 1; + -: 414: } + -: 415: + #####: 416: return 0; + -: 417:} + -: 418: +function scoreFor called 0 returned 0% blocks executed 0% + #####: 419:int scoreFor (int player, struct gameState *state) { + -: 420: + -: 421: int i; + #####: 422: int score = 0; + -: 423: //score from hand + #####: 424: for (i = 0; i < state->handCount[player]; i++) +branch 0 never executed +branch 1 never executed + -: 425: { + #####: 426: if (state->hand[player][i] == curse) { +branch 0 never executed +branch 1 never executed + #####: 427: score = score - 1; + -: 428: }; + #####: 429: if (state->hand[player][i] == estate) { +branch 0 never executed +branch 1 never executed + #####: 430: score = score + 1; + -: 431: }; + #####: 432: if (state->hand[player][i] == duchy) { +branch 0 never executed +branch 1 never executed + #####: 433: score = score + 3; + -: 434: }; + #####: 435: if (state->hand[player][i] == province) { +branch 0 never executed +branch 1 never executed + #####: 436: score = score + 6; + -: 437: }; + #####: 438: if (state->hand[player][i] == great_hall) { +branch 0 never executed +branch 1 never executed + #####: 439: score = score + 1; + -: 440: }; + #####: 441: if (state->hand[player][i] == gardens) { +branch 0 never executed +branch 1 never executed + #####: 442: score = score + ( fullDeckCount(player, 0, state) / 10 ); +call 0 never executed + -: 443: }; + -: 444: } + -: 445: + -: 446: //score from discard + #####: 447: for (i = 0; i < state->discardCount[player]; i++) +branch 0 never executed +branch 1 never executed + -: 448: { + #####: 449: if (state->discard[player][i] == curse) { +branch 0 never executed +branch 1 never executed + #####: 450: score = score - 1; + -: 451: }; + #####: 452: if (state->discard[player][i] == estate) { +branch 0 never executed +branch 1 never executed + #####: 453: score = score + 1; + -: 454: }; + #####: 455: if (state->discard[player][i] == duchy) { +branch 0 never executed +branch 1 never executed + #####: 456: score = score + 3; + -: 457: }; + #####: 458: if (state->discard[player][i] == province) { +branch 0 never executed +branch 1 never executed + #####: 459: score = score + 6; + -: 460: }; + #####: 461: if (state->discard[player][i] == great_hall) { +branch 0 never executed +branch 1 never executed + #####: 462: score = score + 1; + -: 463: }; + #####: 464: if (state->discard[player][i] == gardens) { +branch 0 never executed +branch 1 never executed + #####: 465: score = score + ( fullDeckCount(player, 0, state) / 10 ); +call 0 never executed + -: 466: }; + -: 467: } + -: 468: + -: 469: //score from deck + #####: 470: for (i = 0; i < state->discardCount[player]; i++) +branch 0 never executed +branch 1 never executed + -: 471: { + #####: 472: if (state->deck[player][i] == curse) { +branch 0 never executed +branch 1 never executed + #####: 473: score = score - 1; + -: 474: }; + #####: 475: if (state->deck[player][i] == estate) { +branch 0 never executed +branch 1 never executed + #####: 476: score = score + 1; + -: 477: }; + #####: 478: if (state->deck[player][i] == duchy) { +branch 0 never executed +branch 1 never executed + #####: 479: score = score + 3; + -: 480: }; + #####: 481: if (state->deck[player][i] == province) { +branch 0 never executed +branch 1 never executed + #####: 482: score = score + 6; + -: 483: }; + #####: 484: if (state->deck[player][i] == great_hall) { +branch 0 never executed +branch 1 never executed + #####: 485: score = score + 1; + -: 486: }; + #####: 487: if (state->deck[player][i] == gardens) { +branch 0 never executed +branch 1 never executed + #####: 488: score = score + ( fullDeckCount(player, 0, state) / 10 ); +call 0 never executed + -: 489: }; + -: 490: } + -: 491: + #####: 492: return score; + -: 493:} + -: 494: +function getWinners called 0 returned 0% blocks executed 0% + #####: 495:int getWinners(int players[MAX_PLAYERS], struct gameState *state) { + -: 496: int i; + -: 497: int j; + -: 498: int highScore; + -: 499: int currentPlayer; + -: 500: + -: 501: //get score for each player + #####: 502: for (i = 0; i < MAX_PLAYERS; i++) +branch 0 never executed +branch 1 never executed + -: 503: { + -: 504: //set unused player scores to -9999 + #####: 505: if (i >= state->numPlayers) +branch 0 never executed +branch 1 never executed + -: 506: { + #####: 507: players[i] = -9999; + -: 508: } + -: 509: else + -: 510: { + #####: 511: players[i] = scoreFor (i, state); +call 0 never executed + -: 512: } + -: 513: } + -: 514: + -: 515: //find highest score + #####: 516: j = 0; + #####: 517: for (i = 0; i < MAX_PLAYERS; i++) +branch 0 never executed +branch 1 never executed + -: 518: { + #####: 519: if (players[i] > players[j]) +branch 0 never executed +branch 1 never executed + -: 520: { + #####: 521: j = i; + -: 522: } + -: 523: } + #####: 524: highScore = players[j]; + -: 525: + -: 526: //add 1 to players who had less turns + #####: 527: currentPlayer = whoseTurn(state); +call 0 never executed + #####: 528: for (i = 0; i < MAX_PLAYERS; i++) +branch 0 never executed +branch 1 never executed + -: 529: { + #####: 530: if ( players[i] == highScore && i > currentPlayer ) +branch 0 never executed +branch 1 never executed +branch 2 never executed +branch 3 never executed + -: 531: { + #####: 532: players[i]++; + -: 533: } + -: 534: } + -: 535: + -: 536: //find new highest score + #####: 537: j = 0; + #####: 538: for (i = 0; i < MAX_PLAYERS; i++) +branch 0 never executed +branch 1 never executed + -: 539: { + #####: 540: if ( players[i] > players[j] ) +branch 0 never executed +branch 1 never executed + -: 541: { + #####: 542: j = i; + -: 543: } + -: 544: } + #####: 545: highScore = players[j]; + -: 546: + -: 547: //set winners in array to 1 and rest to 0 + #####: 548: for (i = 0; i < MAX_PLAYERS; i++) +branch 0 never executed +branch 1 never executed + -: 549: { + #####: 550: if ( players[i] == highScore ) +branch 0 never executed +branch 1 never executed + -: 551: { + #####: 552: players[i] = 1; + -: 553: } + -: 554: else + -: 555: { + #####: 556: players[i] = 0; + -: 557: } + -: 558: } + -: 559: + #####: 560: return 0; + -: 561:} + -: 562: +function drawCard called 43 returned 100% blocks executed 38% + 43: 563:int drawCard(int player, struct gameState *state) + -: 564:{ int count; + -: 565: int deckCounter; + 43: 566: if (state->deckCount[player] <= 0) { //Deck is empty +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + -: 567: + -: 568: //Step 1 Shuffle the discard pile back into a deck + -: 569: int i; + -: 570: //Move discard to deck + #####: 571: for (i = 0; i < state->discardCount[player]; i++) { +branch 0 never executed +branch 1 never executed + #####: 572: state->deck[player][i] = state->discard[player][i]; + #####: 573: state->discard[player][i] = -1; + -: 574: } + -: 575: + #####: 576: state->deckCount[player] = state->discardCount[player]; + #####: 577: state->discardCount[player] = 0;//Reset discard + -: 578: + -: 579: //Shufffle the deck + #####: 580: shuffle(player, state);//Shuffle the deck up and make it so that we can draw +call 0 never executed + -: 581: + -: 582: if (DEBUG) { //Debug statements + -: 583: printf("Deck count now: %d\n", state->deckCount[player]); + -: 584: } + -: 585: + #####: 586: state->discardCount[player] = 0; + -: 587: + -: 588: //Step 2 Draw Card + #####: 589: count = state->handCount[player];//Get current player's hand count + -: 590: + -: 591: if (DEBUG) { //Debug statements + -: 592: printf("Current hand count: %d\n", count); + -: 593: } + -: 594: + #####: 595: deckCounter = state->deckCount[player];//Create a holder for the deck count + -: 596: + #####: 597: if (deckCounter == 0) +branch 0 never executed +branch 1 never executed + #####: 598: return -1; + -: 599: + #####: 600: state->hand[player][count] = state->deck[player][deckCounter - 1];//Add card to hand + #####: 601: state->deckCount[player]--; + #####: 602: state->handCount[player]++;//Increment hand count + -: 603: } + -: 604: + -: 605: else { + 43: 606: int count = state->handCount[player];//Get current hand count for player + -: 607: int deckCounter; + -: 608: if (DEBUG) { //Debug statements + -: 609: printf("Current hand count: %d\n", count); + -: 610: } + -: 611: + 43: 612: deckCounter = state->deckCount[player];//Create holder for the deck count + 43: 613: state->hand[player][count] = state->deck[player][deckCounter - 1];//Add card to the hand + 43: 614: state->deckCount[player]--; + 43: 615: state->handCount[player]++;//Increment hand count + -: 616: } + -: 617: + 43: 618: return 0; + -: 619:} + -: 620: +function getCost called 4 returned 100% blocks executed 17% + 4: 621:int getCost(int cardNumber) + -: 622:{ + 4: 623: switch( cardNumber ) +branch 0 taken 25% +branch 1 taken 0% +branch 2 taken 0% +branch 3 taken 0% +branch 4 taken 25% +branch 5 taken 50% +branch 6 taken 0% +branch 7 taken 0% +branch 8 taken 0% +branch 9 taken 0% +branch 10 taken 0% +branch 11 taken 0% +branch 12 taken 0% +branch 13 taken 0% +branch 14 taken 0% +branch 15 taken 0% +branch 16 taken 0% +branch 17 taken 0% +branch 18 taken 0% +branch 19 taken 0% +branch 20 taken 0% +branch 21 taken 0% +branch 22 taken 0% +branch 23 taken 0% +branch 24 taken 0% +branch 25 taken 0% +branch 26 taken 0% +branch 27 taken 0% + -: 624: { + -: 625: case curse: + 1: 626: return 0; + -: 627: case estate: + #####: 628: return 2; + -: 629: case duchy: + #####: 630: return 5; + -: 631: case province: + #####: 632: return 8; + -: 633: case copper: + 1: 634: return 0; + -: 635: case silver: + 2: 636: return 3; + -: 637: case gold: + #####: 638: return 6; + -: 639: case adventurer: + #####: 640: return 6; + -: 641: case council_room: + #####: 642: return 5; + -: 643: case feast: + #####: 644: return 4; + -: 645: case gardens: + #####: 646: return 4; + -: 647: case mine: + #####: 648: return 5; + -: 649: case remodel: + #####: 650: return 4; + -: 651: case smithy: + #####: 652: return 4; + -: 653: case village: + #####: 654: return 3; + -: 655: case baron: + #####: 656: return 4; + -: 657: case great_hall: + #####: 658: return 3; + -: 659: case minion: + #####: 660: return 5; + -: 661: case steward: + #####: 662: return 3; + -: 663: case tribute: + #####: 664: return 5; + -: 665: case ambassador: + #####: 666: return 3; + -: 667: case cutpurse: + #####: 668: return 4; + -: 669: case embargo: + #####: 670: return 2; + -: 671: case outpost: + #####: 672: return 5; + -: 673: case salvager: + #####: 674: return 4; + -: 675: case sea_hag: + #####: 676: return 4; + -: 677: case treasure_map: + #####: 678: return 4; + -: 679: } + -: 680: + #####: 681: return -1; + -: 682:} + -: 683: +function doMine called 3 returned 100% blocks executed 83% + 3: 684:int doMine(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) + -: 685:{ + -: 686: int i; + -: 687: int j; + -: 688: + 3: 689: j = state->hand[currentPlayer][choice1]; //store card we will trash + -: 690: + 3: 691: if (/*state->hand[currentPlayer][choice1] < copper ||*/ state->hand[currentPlayer][choice1] > gold) +branch 0 taken 33% (fallthrough) +branch 1 taken 67% + -: 692: { + 1: 693: return -1; + -: 694: } + -: 695: + 2: 696: if (choice2 > treasure_map || choice2 < curse) +branch 0 taken 100% (fallthrough) +branch 1 taken 0% +branch 2 taken 0% (fallthrough) +branch 3 taken 100% + -: 697: { + #####: 698: return -1; + -: 699: } + -: 700: + 2: 701: if ( (getCost(state->hand[currentPlayer][choice1]) + 3) > getCost(choice2) ) +call 0 returned 100% +call 1 returned 100% +branch 2 taken 0% (fallthrough) +branch 3 taken 100% + -: 702: { + #####: 703: return -1; + -: 704: } + -: 705: + -: 706: //gainCard(choice2, state, 2, currentPlayer); + -: 707: + -: 708: //discard card from hand + 2: 709: discardCard(handPos, currentPlayer, state, 0); +call 0 returned 100% + -: 710: + -: 711: //discard trashed card + 2: 712: for (i = 0; i < state->handCount[currentPlayer]; i++) +branch 0 taken 100% +branch 1 taken 0% (fallthrough) + -: 713: { + 2: 714: if (state->hand[currentPlayer][i] == j) +branch 0 taken 100% (fallthrough) +branch 1 taken 0% + -: 715: { + 2: 716: discardCard(i, currentPlayer, state, 0); +call 0 returned 100% + 2: 717: break; + -: 718: } + -: 719: } + -: 720: + 2: 721: return 0; + -: 722:} + -: 723: +function getEstateCard called 2 returned 100% blocks executed 86% + 2: 724:void getEstateCard(struct gameState *state, int currentPlayer) + -: 725:{ + 2: 726: if (supplyCount(estate, state) > 0) { +call 0 returned 100% +branch 1 taken 100% (fallthrough) +branch 2 taken 0% + 2: 727: gainCard(estate, state, 0, currentPlayer);//Gain an estate +call 0 returned 100% + -: 728: + 2: 729: state->supplyCount[estate]--;//Decrement Estates + 2: 730: if (supplyCount(estate, state) == 0) { +call 0 returned 100% +branch 1 taken 0% (fallthrough) +branch 2 taken 100% + #####: 731: isGameOver(state); +call 0 never executed + -: 732: } + -: 733: } + 2: 734:} + -: 735: +function doBaron called 3 returned 100% blocks executed 100% + 3: 736:void doBaron(int choice1, struct gameState *state, int currentPlayer) + -: 737:{ + 3: 738: state->numBuys++;//Increase buys by 1! + 3: 739: state->numBuys++;//Increase buys by 1! + 3: 740: if (choice1 > 0) { //Boolean true or going to discard an estate +branch 0 taken 67% (fallthrough) +branch 1 taken 33% + 2: 741: int p = 1; //0;//Iterator for hand! + 2: 742: int card_not_discarded = 1;//Flag for discard set! + 11: 743: while(card_not_discarded) { +branch 0 taken 78% +branch 1 taken 22% (fallthrough) + 7: 744: if (state->hand[currentPlayer][p] == estate) { //Found an estate card! +branch 0 taken 14% (fallthrough) +branch 1 taken 86% + 1: 745: state->coins += 4;//Add 4 coins to the amount of coins + 1: 746: state->discard[currentPlayer][state->discardCount[currentPlayer]] = state->hand[currentPlayer][p]; + 1: 747: state->discardCount[currentPlayer]++; + 5: 748: for (; p < state->handCount[currentPlayer]; p++) { +branch 0 taken 80% +branch 1 taken 20% (fallthrough) + 4: 749: state->hand[currentPlayer][p] = state->hand[currentPlayer][p+1]; + -: 750: } + 1: 751: state->hand[currentPlayer][state->handCount[currentPlayer]] = -1; + 1: 752: state->handCount[currentPlayer]--; + 1: 753: card_not_discarded = 0;//Exit the loop + -: 754: } + 6: 755: else if (p > state->handCount[currentPlayer]) { +branch 0 taken 17% (fallthrough) +branch 1 taken 83% + -: 756: if(DEBUG) { + -: 757: printf("No estate cards in your hand, invalid choice\n"); + -: 758: printf("Must gain an estate if there are any\n"); + -: 759: } + 1: 760: getEstateCard(state, currentPlayer); +call 0 returned 100% + 1: 761: card_not_discarded = 0;//Exit the loop + -: 762: } + -: 763: + -: 764: else { + 5: 765: p++;//Next card + -: 766: } + -: 767: } + -: 768: } + -: 769: + -: 770: else { + 1: 771: getEstateCard(state, currentPlayer); +call 0 returned 100% + -: 772: } + 3: 773:} + -: 774: +function doMinion called 2 returned 100% blocks executed 100% + 2: 775:void doMinion(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) + -: 776:{ + -: 777: int i; + -: 778: int j; + -: 779: + -: 780: //+1 action + 2: 781: state->numActions++; + -: 782: + -: 783: //discard card from hand + 2: 784: discardCard(handPos, currentPlayer, state, 0); +call 0 returned 100% + -: 785: + 2: 786: if (choice1) +branch 0 taken 50% (fallthrough) +branch 1 taken 50% + -: 787: { + 1: 788: state->coins = state->coins + 2; + -: 789: } + 1: 790: else if (choice2) //discard hand, redraw 4, other players with 5+ cards discard hand and draw 4 +branch 0 taken 100% (fallthrough) +branch 1 taken 0% + -: 791: { + -: 792: //discard hand + 5: 793: while(numHandCards(state) > 1 /*0*/) +call 0 returned 100% +branch 1 taken 75% +branch 2 taken 25% (fallthrough) + -: 794: { + 3: 795: discardCard(handPos, currentPlayer, state, 0); +call 0 returned 100% + -: 796: } + -: 797: + -: 798: //draw 4 + 5: 799: for (i = 0; i < 4; i++) +branch 0 taken 80% +branch 1 taken 20% (fallthrough) + -: 800: { + 4: 801: drawCard(currentPlayer, state); +call 0 returned 100% + -: 802: } + -: 803: + -: 804: //other players discard hand and redraw if hand size > 4 + 5: 805: for (i = 0; i < state->numPlayers; i++) +branch 0 taken 80% +branch 1 taken 20% (fallthrough) + -: 806: { + 4: 807: if (i != currentPlayer) +branch 0 taken 75% (fallthrough) +branch 1 taken 25% + -: 808: { + -: 809: //if ( state->handCount[i] > 4 ) + -: 810: { + -: 811: //discard hand + 9: 812: while( state->handCount[i] > 0 ) +branch 0 taken 50% +branch 1 taken 50% (fallthrough) + -: 813: { + 3: 814: discardCard(handPos, i, state, 0); +call 0 returned 100% + -: 815: } + -: 816: + -: 817: //draw 4 + 15: 818: for (j = 0; j < 4; j++) +branch 0 taken 80% +branch 1 taken 20% (fallthrough) + -: 819: { + 12: 820: drawCard(i, state); +call 0 returned 100% + -: 821: } + -: 822: } + -: 823: } + -: 824: } + -: 825: } + 2: 826:} + -: 827: +function printDeck called 0 returned 0% blocks executed 0% + #####: 828:void printDeck(struct gameState *state, int p) { + #####: 829: printf("Deck:"); +call 0 never executed + #####: 830: for (int i=0; i < state->deckCount[p]; i++) +branch 0 never executed +branch 1 never executed + #####: 831: printf(" %d", state->deck[p][i]); +call 0 never executed + #####: 832: printf("\n"); +call 0 never executed + #####: 833:} + -: 834: +function printHand called 0 returned 0% blocks executed 0% + #####: 835:void printHand(struct gameState *state, int p) { + #####: 836: printf("Hand:"); +call 0 never executed + #####: 837: for (int i=0; i < state->handCount[p]; i++) +branch 0 never executed +branch 1 never executed + #####: 838: printf(" %d", state->hand[p][i]); +call 0 never executed + #####: 839: printf("\n"); +call 0 never executed + #####: 840:} + -: 841: +function doTribute called 3 returned 100% blocks executed 93% + 3: 842:void doTribute(struct gameState *state, int currentPlayer, int nextPlayer, int tributeRevealedCards[2]) + -: 843:{ + -: 844: int i; + -: 845: + 3: 846: if ((state->discardCount[nextPlayer] + state->deckCount[nextPlayer]) <= 1) { +branch 0 taken 33% (fallthrough) +branch 1 taken 67% + 1: 847: if (state->deckCount[nextPlayer] > 0) { +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + #####: 848: tributeRevealedCards[0] = state->deck[nextPlayer][state->deckCount[nextPlayer]-1]; + #####: 849: state->deckCount[nextPlayer]--; + -: 850: } + 1: 851: else if (state->discardCount[nextPlayer] > 0) { +branch 0 taken 100% (fallthrough) +branch 1 taken 0% + 1: 852: tributeRevealedCards[0] = state->discard[nextPlayer][state->discardCount[nextPlayer]-1]; + 1: 853: state->discardCount[nextPlayer]--; + -: 854: } + -: 855: else { + -: 856: //No Card to Reveal + -: 857: if (DEBUG) { + -: 858: printf("No cards to reveal\n"); + -: 859: } + -: 860: } + -: 861: } + -: 862: + -: 863: else { + 2: 864: if (state->deckCount[nextPlayer] == 0) { +branch 0 taken 50% (fallthrough) +branch 1 taken 50% + 2: 865: for (i = 0; i < state->discardCount[nextPlayer]; i++) { +branch 0 taken 50% +branch 1 taken 50% (fallthrough) + 1: 866: state->deck[nextPlayer][i] = state->discard[nextPlayer][i];//Move to deck + 1: 867: state->deckCount[nextPlayer]++; + 1: 868: state->discard[nextPlayer][i] = -1; + 1: 869: state->discardCount[nextPlayer]--; + -: 870: } + -: 871: + 1: 872: shuffle(nextPlayer,state);//Shuffle the deck +call 0 returned 100% + -: 873: } + 2: 874: tributeRevealedCards[0] = state->deck[nextPlayer][state->deckCount[nextPlayer]-1]; + -: 875: //state->deck[nextPlayer][state->deckCount[nextPlayer]--] = -1; + -: 876: //state->deckCount[nextPlayer]--; + -: 877: //tributeRevealedCards[1] = state->deck[nextPlayer][state->deckCount[nextPlayer]-1]; + 2: 878: tributeRevealedCards[1] = state->deck[nextPlayer][state->deckCount[nextPlayer]-2]; + -: 879: //state->deck[nextPlayer][state->deckCount[nextPlayer]--] = -1; + -: 880: //state->deckCount[nextPlayer]--; + -: 881: } + -: 882: + 3: 883: if (tributeRevealedCards[0] == tributeRevealedCards[1]) { //If we have a duplicate card, just drop one +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + #####: 884: state->playedCards[state->playedCardCount] = tributeRevealedCards[1]; + #####: 885: state->playedCardCount++; + #####: 886: tributeRevealedCards[1] = -1; + -: 887: } + -: 888: + 9: 889: for (i = 0; i < 2; i ++) { +branch 0 taken 67% +branch 1 taken 33% (fallthrough) + 6: 890: if (tributeRevealedCards[i] == copper || tributeRevealedCards[i] == silver || tributeRevealedCards[i] == gold) { //Treasure cards +branch 0 taken 83% (fallthrough) +branch 1 taken 17% +branch 2 taken 100% (fallthrough) +branch 3 taken 0% +branch 4 taken 0% (fallthrough) +branch 5 taken 100% + 1: 891: state->numActions = state->numActions + 2; + -: 892: } + -: 893: + 5: 894: else if (tributeRevealedCards[i] == estate || tributeRevealedCards[i] == duchy || tributeRevealedCards[i] == province || tributeRevealedCards[i] == gardens || tributeRevealedCards[i] == great_hall) { //Victory Card Found +branch 0 taken 60% (fallthrough) +branch 1 taken 40% +branch 2 taken 100% (fallthrough) +branch 3 taken 0% +branch 4 taken 100% (fallthrough) +branch 5 taken 0% +branch 6 taken 100% (fallthrough) +branch 7 taken 0% +branch 8 taken 0% (fallthrough) +branch 9 taken 100% + 2: 895: drawCard(currentPlayer, state); +call 0 returned 100% + -: 896: //drawCard(currentPlayer, state); + -: 897: } + -: 898: else { //Action Card + 3: 899: state->coins += 2; + -: 900: } + -: 901: } + 3: 902:} + -: 903: +function doAmbassador called 2 returned 100% blocks executed 89% + 2: 904:int doAmbassador(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) + -: 905:{ + -: 906: int i; + -: 907: int j; + -: 908: + 2: 909: j = 0; //used to check if player has enough cards to discard + -: 910: + 2: 911: if (choice2 > 3 || choice2 < 0) +branch 0 taken 100% (fallthrough) +branch 1 taken 0% +branch 2 taken 0% (fallthrough) +branch 3 taken 100% + -: 912: { + #####: 913: return -1; + -: 914: } + -: 915: + -: 916:/* + -: 917: if (choice1 == handPos) + -: 918: { + -: 919: return -1; + -: 920: } + -: 921: */ + -: 922: + 12: 923: for (i = 0; i < state->handCount[currentPlayer]; i++) +branch 0 taken 83% +branch 1 taken 17% (fallthrough) + -: 924: { + 10: 925: if (i != handPos && state->hand[currentPlayer][i] == state->hand[currentPlayer][choice1] /*&& i != choice1*/) +branch 0 taken 80% (fallthrough) +branch 1 taken 20% +branch 2 taken 50% (fallthrough) +branch 3 taken 50% + -: 926: { + 4: 927: j++; + -: 928: } + -: 929: } + 2: 930: if (j < choice2) +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + -: 931: { + #####: 932: return -1; + -: 933: } + -: 934: + -: 935: if (DEBUG) + -: 936: printf("Player %d reveals card number: %d\n", currentPlayer, state->hand[currentPlayer][choice1]); + -: 937: + -: 938: //increase supply count for choosen card by amount being discarded + 2: 939: state->supplyCount[state->hand[currentPlayer][choice1]] += choice2; + -: 940: + -: 941: //each other player gains a copy of revealed card + 6: 942: for (i = 0; i < state->numPlayers; i++) +branch 0 taken 67% +branch 1 taken 33% (fallthrough) + -: 943: { + 4: 944: if (i != currentPlayer) +branch 0 taken 50% (fallthrough) +branch 1 taken 50% + -: 945: { + 2: 946: gainCard(state->hand[currentPlayer][choice1], state, 0, i); +call 0 returned 100% + -: 947: } + -: 948: } + -: 949: + -: 950: //discard played card from hand + 2: 951: discardCard(handPos, currentPlayer, state, 0); +call 0 returned 100% + -: 952: + -: 953: //trash copies of cards returned to supply + 6: 954: for (j = 0; j < choice2; j++) +branch 0 taken 67% +branch 1 taken 33% (fallthrough) + -: 955: { + 4: 956: for (i = 0; i < state->handCount[currentPlayer]; i++) +branch 0 taken 100% +branch 1 taken 0% (fallthrough) + -: 957: { + 4: 958: if (state->hand[currentPlayer][i] == state->hand[currentPlayer][choice1]) +branch 0 taken 100% (fallthrough) +branch 1 taken 0% + -: 959: { + 4: 960: discardCard(i, currentPlayer, state, 1); +call 0 returned 100% + 4: 961: break; + -: 962: } + -: 963: } + -: 964: } + -: 965: + 2: 966: return 0; + -: 967:} + -: 968: +function cardEffect called 0 returned 0% blocks executed 0% + #####: 969:int cardEffect(int card, int choice1, int choice2, int choice3, struct gameState *state, int handPos, int *bonus) + -: 970:{ + -: 971: int i; + -: 972: int j; + -: 973: int k; + -: 974: int x; + -: 975: int index; + #####: 976: int currentPlayer = whoseTurn(state); +call 0 never executed + #####: 977: int nextPlayer = currentPlayer + 1; + -: 978: + #####: 979: int tributeRevealedCards[2] = {-1, -1}; + -: 980: int temphand[MAX_HAND];// moved above the if statement + #####: 981: int drawntreasure=0; + -: 982: int cardDrawn; + #####: 983: int z = 0;// this is the counter for the temp hand + #####: 984: if (nextPlayer > (state->numPlayers - 1)) { +branch 0 never executed +branch 1 never executed + #####: 985: nextPlayer = 0; + -: 986: } + -: 987: + -: 988: + -: 989: //uses switch to select card and perform actions + #####: 990: switch( card ) +branch 0 never executed +branch 1 never executed +branch 2 never executed +branch 3 never executed +branch 4 never executed +branch 5 never executed +branch 6 never executed +branch 7 never executed +branch 8 never executed +branch 9 never executed +branch 10 never executed +branch 11 never executed +branch 12 never executed +branch 13 never executed +branch 14 never executed +branch 15 never executed +branch 16 never executed +branch 17 never executed +branch 18 never executed +branch 19 never executed +branch 20 never executed + -: 991: { + -: 992: case adventurer: + #####: 993: while(drawntreasure<2) { +branch 0 never executed +branch 1 never executed + #####: 994: if (state->deckCount[currentPlayer] <1) { //if the deck is empty we need to shuffle discard and add to deck +branch 0 never executed +branch 1 never executed + #####: 995: shuffle(currentPlayer, state); +call 0 never executed + -: 996: } + #####: 997: drawCard(currentPlayer, state); +call 0 never executed + #####: 998: cardDrawn = state->hand[currentPlayer][state->handCount[currentPlayer]-1];//top card of hand is most recently drawn card. + #####: 999: if (cardDrawn == copper || cardDrawn == silver || cardDrawn == gold) +branch 0 never executed +branch 1 never executed +branch 2 never executed +branch 3 never executed +branch 4 never executed +branch 5 never executed + #####: 1000: drawntreasure++; + -: 1001: else { + #####: 1002: temphand[z]=cardDrawn; + #####: 1003: state->handCount[currentPlayer]--; //this should just remove the top card (the most recently drawn one). + #####: 1004: z++; + -: 1005: } + -: 1006: } + #####: 1007: while(z-1>=0) { +branch 0 never executed +branch 1 never executed + #####: 1008: state->discard[currentPlayer][state->discardCount[currentPlayer]++]=temphand[z-1]; // discard all cards in play that have been drawn + #####: 1009: z=z-1; + -: 1010: } + #####: 1011: return 0; + -: 1012: + -: 1013: case council_room: + -: 1014: //+4 Cards + #####: 1015: for (i = 0; i < 4; i++) +branch 0 never executed +branch 1 never executed + -: 1016: { + #####: 1017: drawCard(currentPlayer, state); +call 0 never executed + -: 1018: } + -: 1019: + -: 1020: //+1 Buy + #####: 1021: state->numBuys++; + -: 1022: + -: 1023: //Each other player draws a card + #####: 1024: for (i = 0; i < state->numPlayers; i++) +branch 0 never executed +branch 1 never executed + -: 1025: { + #####: 1026: if ( i != currentPlayer ) +branch 0 never executed +branch 1 never executed + -: 1027: { + #####: 1028: drawCard(i, state); +call 0 never executed + -: 1029: } + -: 1030: } + -: 1031: + -: 1032: //put played card in played card pile + #####: 1033: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + -: 1034: + #####: 1035: return 0; + -: 1036: + -: 1037: case feast: + -: 1038: //gain card with cost up to 5 + -: 1039: //Backup hand + #####: 1040: for (i = 0; i <= state->handCount[currentPlayer]; i++) { +branch 0 never executed +branch 1 never executed + #####: 1041: temphand[i] = state->hand[currentPlayer][i];//Backup card + #####: 1042: state->hand[currentPlayer][i] = -1;//Set to nothing + -: 1043: } + -: 1044: //Backup hand + -: 1045: + -: 1046: //Update Coins for Buy + #####: 1047: updateCoins(currentPlayer, state, 5); +call 0 never executed + #####: 1048: x = 1;//Condition to loop on + #####: 1049: while( x == 1) {//Buy one card +branch 0 never executed +branch 1 never executed + #####: 1050: if (supplyCount(choice1, state) <= 0) { +call 0 never executed +branch 1 never executed +branch 2 never executed + -: 1051: if (DEBUG) + -: 1052: printf("None of that card left, sorry!\n"); + -: 1053: + -: 1054: if (DEBUG) { + -: 1055: printf("Cards Left: %d\n", supplyCount(choice1, state)); + -: 1056: } + -: 1057: } + #####: 1058: else if (state->coins < getCost(choice1)) { +call 0 never executed +branch 1 never executed +branch 2 never executed + #####: 1059: printf("That card is too expensive!\n"); +call 0 never executed + -: 1060: + -: 1061: if (DEBUG) { + -: 1062: printf("Coins: %d < %d\n", state->coins, getCost(choice1)); + -: 1063: } + -: 1064: } + -: 1065: else { + -: 1066: + -: 1067: if (DEBUG) { + -: 1068: printf("Deck Count: %d\n", state->handCount[currentPlayer] + state->deckCount[currentPlayer] + state->discardCount[currentPlayer]); + -: 1069: } + -: 1070: + #####: 1071: gainCard(choice1, state, 0, currentPlayer);//Gain the card +call 0 never executed + #####: 1072: x = 0;//No more buying cards + -: 1073: + -: 1074: if (DEBUG) { + -: 1075: printf("Deck Count: %d\n", state->handCount[currentPlayer] + state->deckCount[currentPlayer] + state->discardCount[currentPlayer]); + -: 1076: } + -: 1077: + -: 1078: } + -: 1079: } + -: 1080: + -: 1081: //Reset Hand + #####: 1082: for (i = 0; i <= state->handCount[currentPlayer]; i++) { +branch 0 never executed +branch 1 never executed + #####: 1083: state->hand[currentPlayer][i] = temphand[i]; + #####: 1084: temphand[i] = -1; + -: 1085: } + -: 1086: //Reset Hand + -: 1087: + #####: 1088: return 0; + -: 1089: + -: 1090: case gardens: + #####: 1091: return -1; + -: 1092: + -: 1093: case mine: + #####: 1094: return doMine(choice1, choice2, state, handPos, currentPlayer); +call 0 never executed + -: 1095: + -: 1096: case remodel: + #####: 1097: j = state->hand[currentPlayer][choice1]; //store card we will trash + -: 1098: + #####: 1099: if ( (getCost(state->hand[currentPlayer][choice1]) + 2) > getCost(choice2) ) +call 0 never executed +call 1 never executed +branch 2 never executed +branch 3 never executed + -: 1100: { + #####: 1101: return -1; + -: 1102: } + -: 1103: + #####: 1104: gainCard(choice2, state, 0, currentPlayer); +call 0 never executed + -: 1105: + -: 1106: //discard card from hand + #####: 1107: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + -: 1108: + -: 1109: //discard trashed card + #####: 1110: for (i = 0; i < state->handCount[currentPlayer]; i++) +branch 0 never executed +branch 1 never executed + -: 1111: { + #####: 1112: if (state->hand[currentPlayer][i] == j) +branch 0 never executed +branch 1 never executed + -: 1113: { + #####: 1114: discardCard(i, currentPlayer, state, 0); +call 0 never executed + #####: 1115: break; + -: 1116: } + -: 1117: } + -: 1118: + -: 1119: + #####: 1120: return 0; + -: 1121: + -: 1122: case smithy: + -: 1123: //+3 Cards + #####: 1124: for (i = 0; i < 3; i++) +branch 0 never executed +branch 1 never executed + -: 1125: { + #####: 1126: drawCard(currentPlayer, state); +call 0 never executed + -: 1127: } + -: 1128: + -: 1129: //discard card from hand + #####: 1130: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + #####: 1131: return 0; + -: 1132: + -: 1133: case village: + -: 1134: //+1 Card + #####: 1135: drawCard(currentPlayer, state); +call 0 never executed + -: 1136: + -: 1137: //+2 Actions + #####: 1138: state->numActions = state->numActions + 2; + -: 1139: + -: 1140: //discard played card from hand + #####: 1141: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + #####: 1142: return 0; + -: 1143: + -: 1144: case baron: + #####: 1145: doBaron(choice1, state, currentPlayer); +call 0 never executed + #####: 1146: return 0; + -: 1147: + -: 1148: case great_hall: + -: 1149: //+1 Card + #####: 1150: drawCard(currentPlayer, state); +call 0 never executed + -: 1151: + -: 1152: //+1 Actions + #####: 1153: state->numActions++; + -: 1154: + -: 1155: //discard card from hand + #####: 1156: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + #####: 1157: return 0; + -: 1158: + -: 1159: case minion: + #####: 1160: doMinion(choice1, choice2, state, handPos, currentPlayer); +call 0 never executed + #####: 1161: return 0; + -: 1162: + -: 1163: case steward: + #####: 1164: if (choice1 == 1) +branch 0 never executed +branch 1 never executed + -: 1165: { + -: 1166: //+2 cards + #####: 1167: drawCard(currentPlayer, state); +call 0 never executed + #####: 1168: drawCard(currentPlayer, state); +call 0 never executed + -: 1169: } + #####: 1170: else if (choice1 == 2) +branch 0 never executed +branch 1 never executed + -: 1171: { + -: 1172: //+2 coins + #####: 1173: state->coins = state->coins + 2; + -: 1174: } + -: 1175: else + -: 1176: { + -: 1177: //trash 2 cards in hand + #####: 1178: discardCard(choice2, currentPlayer, state, 1); +call 0 never executed + #####: 1179: discardCard(choice3, currentPlayer, state, 1); +call 0 never executed + -: 1180: } + -: 1181: + -: 1182: //discard card from hand + #####: 1183: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + #####: 1184: return 0; + -: 1185: + -: 1186: case tribute: + #####: 1187: doTribute(state, currentPlayer, nextPlayer, tributeRevealedCards); +call 0 never executed + #####: 1188: return 0; + -: 1189: + -: 1190: case ambassador: + #####: 1191: return doAmbassador(choice1, choice2, state, handPos, currentPlayer); +call 0 never executed + -: 1192: + -: 1193: case cutpurse: + -: 1194: + #####: 1195: updateCoins(currentPlayer, state, 2); +call 0 never executed + #####: 1196: for (i = 0; i < state->numPlayers; i++) +branch 0 never executed +branch 1 never executed + -: 1197: { + #####: 1198: if (i != currentPlayer) +branch 0 never executed +branch 1 never executed + -: 1199: { + #####: 1200: for (j = 0; j < state->handCount[i]; j++) +branch 0 never executed +branch 1 never executed + -: 1201: { + #####: 1202: if (state->hand[i][j] == copper) +branch 0 never executed +branch 1 never executed + -: 1203: { + #####: 1204: discardCard(j, i, state, 0); +call 0 never executed + #####: 1205: break; + -: 1206: } + #####: 1207: if (j == state->handCount[i]) +branch 0 never executed +branch 1 never executed + -: 1208: { + #####: 1209: for (k = 0; k < state->handCount[i]; k++) +branch 0 never executed +branch 1 never executed + -: 1210: { + -: 1211: if (DEBUG) + -: 1212: printf("Player %d reveals card number %d\n", i, state->hand[i][k]); + -: 1213: } + #####: 1214: break; + -: 1215: } + -: 1216: } + -: 1217: + -: 1218: } + -: 1219: + -: 1220: } + -: 1221: + -: 1222: //discard played card from hand + #####: 1223: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + -: 1224: + #####: 1225: return 0; + -: 1226: + -: 1227: + -: 1228: case embargo: + -: 1229: //+2 Coins + #####: 1230: state->coins = state->coins + 2; + -: 1231: + -: 1232: //see if selected pile is in play + #####: 1233: if ( state->supplyCount[choice1] == -1 ) +branch 0 never executed +branch 1 never executed + -: 1234: { + #####: 1235: return -1; + -: 1236: } + -: 1237: + -: 1238: //add embargo token to selected supply pile + #####: 1239: state->embargoTokens[choice1]++; + -: 1240: + -: 1241: //trash card + #####: 1242: discardCard(handPos, currentPlayer, state, 1); +call 0 never executed + #####: 1243: return 0; + -: 1244: + -: 1245: case outpost: + -: 1246: //set outpost flag + #####: 1247: state->outpostPlayed++; + -: 1248: + -: 1249: //discard card + #####: 1250: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + #####: 1251: return 0; + -: 1252: + -: 1253: case salvager: + -: 1254: //+1 buy + #####: 1255: state->numBuys++; + -: 1256: + #####: 1257: if (choice1) +branch 0 never executed +branch 1 never executed + -: 1258: { + -: 1259: //gain coins equal to trashed card + #####: 1260: state->coins = state->coins + getCost( handCard(choice1, state) ); +call 0 never executed +call 1 never executed + -: 1261: //trash card + #####: 1262: discardCard(choice1, currentPlayer, state, 1); +call 0 never executed + -: 1263: } + -: 1264: + -: 1265: //discard card + #####: 1266: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + #####: 1267: return 0; + -: 1268: + -: 1269: case sea_hag: + #####: 1270: for (i = 0; i < state->numPlayers; i++) { +branch 0 never executed +branch 1 never executed + #####: 1271: if (i != currentPlayer) { +branch 0 never executed +branch 1 never executed + #####: 1272: state->discard[i][state->discardCount[i]] = state->deck[i][state->deckCount[i]--]; + #####: 1273: state->deckCount[i]--; + #####: 1274: state->discardCount[i]++; + #####: 1275: state->deck[i][state->deckCount[i]--] = curse;//Top card now a curse + -: 1276: } + -: 1277: } + #####: 1278: return 0; + -: 1279: + -: 1280: case treasure_map: + -: 1281: //search hand for another treasure_map + #####: 1282: index = -1; + #####: 1283: for (i = 0; i < state->handCount[currentPlayer]; i++) +branch 0 never executed +branch 1 never executed + -: 1284: { + #####: 1285: if (state->hand[currentPlayer][i] == treasure_map && i != handPos) +branch 0 never executed +branch 1 never executed +branch 2 never executed +branch 3 never executed + -: 1286: { + #####: 1287: index = i; + #####: 1288: break; + -: 1289: } + -: 1290: } + #####: 1291: if (index > -1) +branch 0 never executed +branch 1 never executed + -: 1292: { + -: 1293: //trash both treasure cards + #####: 1294: discardCard(handPos, currentPlayer, state, 1); +call 0 never executed + #####: 1295: discardCard(index, currentPlayer, state, 1); +call 0 never executed + -: 1296: + -: 1297: //gain 4 Gold cards + #####: 1298: for (i = 0; i < 4; i++) +branch 0 never executed +branch 1 never executed + -: 1299: { + #####: 1300: gainCard(gold, state, 1, currentPlayer); +call 0 never executed + -: 1301: } + -: 1302: + -: 1303: //return success + #####: 1304: return 1; + -: 1305: } + -: 1306: + -: 1307: //no second treasure_map found in hand + #####: 1308: return -1; + -: 1309: } + -: 1310: + #####: 1311: return -1; + -: 1312:} + -: 1313: +function discardCard called 18 returned 100% blocks executed 89% + 18: 1314:int discardCard(int handPos, int currentPlayer, struct gameState *state, int trashFlag) + -: 1315:{ + -: 1316: + -: 1317: //if card is not trashed, added to Played pile + 18: 1318: if (trashFlag < 1) +branch 0 taken 78% (fallthrough) +branch 1 taken 22% + -: 1319: { + -: 1320: //add card to played pile + 14: 1321: state->playedCards[state->playedCardCount] = state->hand[currentPlayer][handPos]; + 14: 1322: state->playedCardCount++; + -: 1323: } + -: 1324: + -: 1325: //set played card to -1 + 18: 1326: state->hand[currentPlayer][handPos] = -1; + -: 1327: + -: 1328: //remove card from player's hand + 18: 1329: if ( handPos == (state->handCount[currentPlayer] - 1) ) //last card in hand array is played +branch 0 taken 11% (fallthrough) +branch 1 taken 89% + -: 1330: { + -: 1331: //reduce number of cards in hand + 2: 1332: state->handCount[currentPlayer]--; + -: 1333: } + 16: 1334: else if ( state->handCount[currentPlayer] == 1 ) //only one card in hand +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + -: 1335: { + -: 1336: //reduce number of cards in hand + #####: 1337: state->handCount[currentPlayer]--; + -: 1338: } + -: 1339: else + -: 1340: { + -: 1341: //replace discarded card with last card in hand + 16: 1342: state->hand[currentPlayer][handPos] = state->hand[currentPlayer][ (state->handCount[currentPlayer] - 1)]; + -: 1343: //set last card to -1 + 16: 1344: state->hand[currentPlayer][state->handCount[currentPlayer] - 1] = -1; + -: 1345: //reduce number of cards in hand + 16: 1346: state->handCount[currentPlayer]--; + -: 1347: } + -: 1348: + 18: 1349: return 0; + -: 1350:} + -: 1351: +function gainCard called 4 returned 100% blocks executed 70% + 4: 1352:int gainCard(int supplyPos, struct gameState *state, int toFlag, int player) + -: 1353:{ + -: 1354: //Note: supplyPos is enum of choosen card + -: 1355: + -: 1356: //check if supply pile is empty (0) or card is not used in game (-1) + 4: 1357: if ( supplyCount(supplyPos, state) < 1 ) +call 0 returned 100% +branch 1 taken 0% (fallthrough) +branch 2 taken 100% + -: 1358: { + #####: 1359: return -1; + -: 1360: } + -: 1361: + -: 1362: //added card for [whoseTurn] current player: + -: 1363: // toFlag = 0 : add to discard + -: 1364: // toFlag = 1 : add to deck + -: 1365: // toFlag = 2 : add to hand + -: 1366: + 4: 1367: if (toFlag == 1) +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + -: 1368: { + #####: 1369: state->deck[ player ][ state->deckCount[player] ] = supplyPos; + #####: 1370: state->deckCount[player]++; + -: 1371: } + 4: 1372: else if (toFlag == 2) +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + -: 1373: { + #####: 1374: state->hand[ player ][ state->handCount[player] ] = supplyPos; + #####: 1375: state->handCount[player]++; + -: 1376: } + -: 1377: else + -: 1378: { + 4: 1379: state->discard[player][ state->discardCount[player] ] = supplyPos; + 4: 1380: state->discardCount[player]++; + -: 1381: } + -: 1382: + -: 1383: //decrease number in supply pile + 4: 1384: state->supplyCount[supplyPos]--; + -: 1385: + 4: 1386: return 0; + -: 1387:} + -: 1388: +function updateCoins called 5 returned 100% blocks executed 82% + 5: 1389:int updateCoins(int player, struct gameState *state, int bonus) + -: 1390:{ + -: 1391: int i; + -: 1392: + -: 1393: //reset coin count + 5: 1394: state->coins = 0; + -: 1395: + -: 1396: //add coins for each Treasure card in player's hand + 30: 1397: for (i = 0; i < state->handCount[player]; i++) +branch 0 taken 83% +branch 1 taken 17% (fallthrough) + -: 1398: { + 25: 1399: if (state->hand[player][i] == copper) +branch 0 taken 60% (fallthrough) +branch 1 taken 40% + -: 1400: { + 15: 1401: state->coins += 1; + -: 1402: } + 10: 1403: else if (state->hand[player][i] == silver) +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + -: 1404: { + #####: 1405: state->coins += 2; + -: 1406: } + 10: 1407: else if (state->hand[player][i] == gold) +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + -: 1408: { + #####: 1409: state->coins += 3; + -: 1410: } + -: 1411: } + -: 1412: + -: 1413: //add bonus + 5: 1414: state->coins += bonus; + -: 1415: + 5: 1416: return 0; + -: 1417:} + -: 1418: + -: 1419: + -: 1420://end of dominion.c diff --git a/dominion/as3/dominion.gcda b/dominion/as3/dominion.gcda new file mode 100644 index 0000000000000000000000000000000000000000..231f0fbf2c6b2f6e5027184f02bb224b2e86d00a GIT binary patch literal 5848 zcmeHLTWnNS6ul!LOcfcR*h+y2jHRIui;vLM+GweUA(0Sm2qEwR9SS&Lq$U!pSRVuo ziO+}{KLi4aC9S*+(Ud4nWBq^zI$D+C*ur*#6;7b&Rys1 zv-djZo^{VT_jXybapjX$l@C;Wn0U_fyqzhz^zZJ89gKLM{CPhNmy6h-4*_0Ht%#Z{ zEhLca*!@zc8)eu8`Q4%=&zot880$8`Tg5lR+NT&I27Xwf56VB%%3&O3zK0CaXP%Yw z4bkr%Rwja~;@DrUwIPoB5#gI;?L>^F#C*Mmh@*Z)jF0-A zu((`wY?7S3^5hroLJs~tHhHd&t*K;29p@q0v8ht08)aC5{HSAvdi*+d#Ip~B4%G2( zIKokGc@yqdvr3^ugXZ zdg8#8{Xzt;9e<1EEknGq!Ql}ebSh{sKTKv>!hDQ0CQ6H|E>(vMM&$Y*S2N!v! zh5Ddo)CA*Y4l%6R%a)5cYDI*PS`p!+Rz&!y6)_jhnk0W*&xnuOga}+4Y@%{qQ}dDR zSh3XUMj3{=!T4a@GY~_~h!}P(`M@49dwbuy=-o;s`{>-9n zP8==8nBr;1ggp@EVu(xIxn~g>&odz#@*E&C9$ll1Z=elJ244HR=2fBg_fhTm`Yy_W zcfwJh{$BD=IPMgVHPO7`(dM$Xu8zEC7kMv4R~N>!oyaqh=;p~#^u8uY;pfWg<8ME_ z=zEL_-v{Jm4(mkf#P=iW$#!z%%>S%u)i>Sej{N~{oEePGh7#(Uj(5Cx2io80-`(2z z3^*~T?APTaK{kJeIPDW>T5sQA^`=KsUFZ|vZ0wV{F0!3{yY2shy59R(8R*9=;&n3% zpODw0%xgzB0yUyklmpMyn4bFahZpTR3J!ih`qBT|RmU<$x;s(PHK$-s-6t4}yjcC8 zOz#ov?DG4iy?d86%Ikb)&C=Ywa^QO^(RJv{!m@j7!QsB|rOC_WQcmne`Rlr)7cMUS z37l9P++(DuF}F$K)OQQ7{MvC~%gyQ+XW{Bt-^OsiJTKWV{&6tSy*%>Uyw6`kzoBtS zOJF)i8}*Zf(lU#~k2UjF|jV7#${a^t+)5<9)Vzc%tMxI^#W zH^%zcEbRk({d@0tXU^AeZKfW0Heiq1CijA0^;~2eQNolHb5wAlqpG2O;Z|@~OPyzm zi$?8rTVGcUxo(M!U; literal 0 HcmV?d00001 diff --git a/dominion/as3/dominion.gcno b/dominion/as3/dominion.gcno new file mode 100644 index 0000000000000000000000000000000000000000..53cd4ee4f2bbe7c18a9a960172cfddfb41f65e0e GIT binary patch literal 41668 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 literal 0 HcmV?d00001 diff --git a/dominion/as3/dominion.h b/dominion/as3/dominion.h new file mode 100644 index 000000000..f9d9039b8 --- /dev/null +++ b/dominion/as3/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/dominion/as3/dominion.o b/dominion/as3/dominion.o new file mode 100644 index 0000000000000000000000000000000000000000..81ae495872eaf1634fdc4f966be5455639ae2c5c GIT binary patch literal 53784 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 literal 0 HcmV?d00001 diff --git a/dominion/as3/dominion_helpers.h b/dominion/as3/dominion_helpers.h new file mode 100644 index 000000000..0887fda15 --- /dev/null +++ b/dominion/as3/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/dominion/as3/rngs.c b/dominion/as3/rngs.c new file mode 100644 index 000000000..a85bbc961 --- /dev/null +++ b/dominion/as3/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/dominion/as3/rngs.gcda b/dominion/as3/rngs.gcda new file mode 100644 index 0000000000000000000000000000000000000000..e0619095e55deb95836cfd95fb950e6e6c7e4c50 GIT binary patch literal 2664 zcmd6py=xRv6vbzv>qjsW7C+(#OQQJ@ab-b;fTAD~O$w193Sy&CCWv6Xzc=@+!>~pdQsj`GbLYH!?|bvkydhVTYvZGX zmBWQ6!#ATSnyT7mVP?MbO&mq`7kyf57sFCY4PLBX-{?|P8m2ghLv}Bj7;Lp)TZp1) zzcV>LZG+dDR`BtXGdbv>E2YqXy~kPJ;M!4V=4|(Pi!<|X_E=1Rjn^`HyF3r426!sDw45k$Pl#i;Vf7UBf$&qJzFPeGAoSLtfLIeFeL-dEq z(|pH$j6C@#M%(SHo?%FYn{sYO<`4 zBNXS*WA~DY!FKz}$Advh@8u)!KEMb0*o|OdOg`#7Qm2|CNrq-VlBct$TGpmBC#IJ? zt62=llUHIioi8z(d=aC`A8{-G@NMka`L*=g8qsU=Fa9k3!=LjM=g?>Ol8HgHbJk(H z{22&Ysb}&>XXbzX;rVs;wD0s%pFNp5AV;2wS%xpA@vY*l@B=$i3cc7< zpzj=YE8$NqbWNW@zKB_~d=aC`7cpAmeZ(#J6SE&Y-^7=h(Qk9{MLSh-x81J-gtg(v z^Lw+OyM7eS&dHd4*Ex_^dA5{Li%;K2N<*{vE7R2Ky)YSs9G<`J!R7Hsm3kjJ{2!zK zVv<)FVQ$uQ;^Ddah4&|in49_X&r2G E4U(X2kN^Mx literal 0 HcmV?d00001 diff --git a/dominion/as3/rngs.gcno b/dominion/as3/rngs.gcno new file mode 100644 index 0000000000000000000000000000000000000000..f05d60f398fd41c66d260b99fc2ff1b903c8838c GIT binary patch literal 4032 zcmcJS%WG9h5XR5({Td(ffh)m-F@%a=-_bAj`r;f z9~_v-vMgUNW|8Ra|E79AyvzINOZjjy(d-!*9U428W%HyyJ~}+Hbuh~wN;%6K`G)ZQ zUZx{w4hUl}2&ImEVXV^zmWwJ++YE>2+YDbSIBi*`e9EjlM6u+%u< zjN|8Aj+HNi89_AQNJ$m)uQlx8}S2gi*3XK z3=WuIEA_PzTPI%?jW_su(bQVurrH<>oO$Y8J9A=2ULf_{d?eW8&|;=DXHW2hc>WWG zqE()*rOJDn;1MIl`+KHPwCayMLOk!eLeVOZoI*TrN}*_#$6652OU;iMA)fcULeX~S zF z#PjYeWHy{{{CzyQY5&`6?T_Jh70uqF7^?KU5_&Xd-U@SI_Y-yc>fCg#)LG|TYsL3< z(Ho*p!rX}6ykCzE-)x`Wg1_#`*>fvGr$%l$>3n=+aqiq8#D*g>P|%L!G;cGUwHN(GQ%r!t=R%>@D>E>2GgheQfIfP2~QtacJW#a`#a7 zZOj4O-aU(ne+w-p_69On{|4fdHxP_+ea_&l31R)VR>rn?=v-UBUxjeTL{E#BqUT2A zUp+VDB}q!H&*4OZ#~Kjw*M8eI17b$~rQW4UqlB;WQt#541kYmR$32_irQWY|30~^` zI-lUNuZSP_fiI@n{x^DZhBt@7A!#PjOwWv%Qz;(3>(emS5sCj176v*)+&>ArvW z?PtHcM+Qd2%_1A<`*($IjnHSt!&epNzB|ac-cqdFgWr-|PjL<)-bq;l`(KdFpeCcH-$V>ONn1I~WV$ oYj+}R*eSY8bhqdp(NbFH%HEPBCFSY(RsZ`EJY7$f*Wq|y049j=G5`Po literal 0 HcmV?d00001 diff --git a/dominion/as3/rngs.h b/dominion/as3/rngs.h new file mode 100644 index 000000000..c9f3f451a --- /dev/null +++ b/dominion/as3/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/dominion/as3/rngs.o b/dominion/as3/rngs.o new file mode 100644 index 0000000000000000000000000000000000000000..4f59e8b8858b66e06efab315b3b5fba6fc2bf7e7 GIT binary patch literal 11728 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 C!5^{! literal 0 HcmV?d00001 diff --git a/dominion/as3/unittest1.gcda b/dominion/as3/unittest1.gcda new file mode 100644 index 0000000000000000000000000000000000000000..b7727784087622b716814eb741f67cf607b9134c GIT binary patch literal 936 zcmYdHNlp*4FfiFX-Lsg1fnjkrka)fFsK8c61_mHvxWWP?fZ#ubg45r#Q#qkRSSe4C zW;9?7IsoXTg^YF}2_Oc6kw$~O3fb>0Js!h6ccgK2|9-t5ypob$+5Nr=9uHx27bUQ7v iX@Tj1We$*?AONF*Ot2o1S#Pdw%SF}$%LiEOVE_O+PAiT8 literal 0 HcmV?d00001 diff --git a/dominion/as3/unittest1.gcno b/dominion/as3/unittest1.gcno new file mode 100644 index 0000000000000000000000000000000000000000..f88979db76f3fd158b74f43d7fde9fe185b0ced7 GIT binary patch literal 3924 zcmd6q+iDa+5Qb;s`Fz%BG;RU`^&%)nj2e~Ay2g0G7|$Am>l!3rHkjR9dgqjQWv zDkz9g;+29A;6qs7RJXfZyS0J{T2M7TfBiGl-8KDB&wQo)Xma@A(8rhK)g(#MH4>JI z4~!jn)%#|mr%T#%rP+!ck|pAcmDyTtrdm5RSWflzy3< z1}6u;(aC{ta&q9CogDZUCkMXO$$@Wka^TyY9QY0=2j1=Ez;`-1@Lf(0yvNCb?{;$F zdz>72uag7c>*T<5;=JFDYlU?J-Y3p`#`*!{93Gw|#guo7^@fqRy0KrdLGdB+x)oF2 zZ}^zK?uf!6Dp&i^$~|hhyvK|Mv-ceq?3nm*@e|@B;&s#Ku$D1YZ$ZKyuu+CQ`RN(k6G@hU5H<;z#Q8+~9qCc4B zPAMFsa?vBqa_=e}qH@t7%yOp{4pF&i5@xyg6b@0j=n!VP_cJsG<>tbv<(48%kC`^1 z8@(^eQ*S@a9)@2oEj%pDFIH;Ow%2Qa^O-j3Eq)i9_aLe}ilK>UNyIqvJo-Z$R}EEu z#5qQ-g=6o*IrqWPA2^ZUxYvjndkmhV&njm7K2NV1Ki`U+c-?f)<1_7?_0@^eQm&4n zb$-Q|5{WFAnm_u`o8*9Nla(^&f z*H`C%jL3(p{9@XvCiE|UN2Mv&xhC;D+Q{{462GI$)&D{I^yAB?Ip&V>>D;x}h e5^I>9HidsXZ}hKu9e18LYEZY%8W#6k@P7idJtGDH literal 0 HcmV?d00001 diff --git a/dominion/as3/unittest2 b/dominion/as3/unittest2 new file mode 100644 index 0000000000000000000000000000000000000000..f7d8220357f8a8b7268449702c7ba5b31c522acb GIT binary patch literal 62352 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 literal 0 HcmV?d00001 diff --git a/dominion/as3/unittest2.gcda b/dominion/as3/unittest2.gcda new file mode 100644 index 0000000000000000000000000000000000000000..afbec273256495ff84f4e27bcecfc2e0852828af GIT binary patch literal 792 zcmYdHNlp*4FfjQ(-Lsg1fnjk0kkIw8QCY&szyL%H^I3re5d4QwaC-muBu=OhR>~Em z84V}{`7mJ+8w9w3mz77i1^QJ{7PG#JvJgHjD4BvKm>w7nR0`Gu T@^7YdQ!=t1BsFN(FfafBe(@&b literal 0 HcmV?d00001 diff --git a/dominion/as3/unittest2.gcno b/dominion/as3/unittest2.gcno new file mode 100644 index 0000000000000000000000000000000000000000..4fc66e70d95c0ce7eb1f89899db80bb458f74f0a GIT binary patch literal 2512 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⋙zyNW9uVS9*Rf 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 F{Q=Nw^K1YB literal 0 HcmV?d00001 diff --git a/dominion/as3/unittest4 b/dominion/as3/unittest4 new file mode 100644 index 0000000000000000000000000000000000000000..19ad1d52e84065def9ab7ce0cbad4222350de986 GIT binary patch literal 62552 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 literal 0 HcmV?d00001 diff --git a/dominion/as3/unittest4.gcno b/dominion/as3/unittest4.gcno new file mode 100644 index 0000000000000000000000000000000000000000..c33bc567f3f44aee445d14a7d696678d93e4efd0 GIT binary patch literal 3900 zcmd6qId4-z6oubo-}f~vN)Sjufg*ue!;%;yBKEKd#A=)nq69}^r>3C-egHp!7Db|> zqUS$ALyKssxu4HW;#|LRK@+ZY?i-&uv)(uNjVEi>(V^qLM;adn>sglNE6pu7EOfo0o>fo0q>fo0dXz%9&zudrhD-1Ht6P}n9%>`|$4t`al9sKG< z9sHU^9sJrv9sD{&(fZ)mhjtt6DbxDkHyVo8hc;CQzbVlUesiJ@eoLYberuu*ew(3a zeel~uyDodmv_AM9hNAVMP1V8gH2Cp&Z{c?t=#%#uj^DgjAj`@*G3GpA)cbRLz_?z+ zQNyg2bKW=fm~VGXbnwz@4(-|#PD`9w3+DShY1}D8pW(FOjNz=|oT1+^V3;+H%UQ#G zUnSAOOUv2Ay!O24;HBj(VqRMo9lW&c73Q@UL=JqJx(<<{PiQTc9PUU|xGqbnxnz9D{l7ebK>}bJj)9!Myf?aSsiT437;@ z3>CvuL)9>A8k78l`F@5)2QMx83iH|#(ZNeg{=&TWndso9C7)qlJ1RPOX=5(*+OYyH z`402ianZr6U-BR3wG*PFZ{|Sq)5P%G?9=D5!|1D(SHq>rsanIzzCAgV`%FC7&7U3J z+`EVJn>cbWIVy5I8ISo;2FlgaN1kWQ>1cc({H7m_yoM&~;~k^55Aqq~XsmMce#hLf zqV;o^>!xzXwC8b5-==3qM?qSR-`@Y80=P&lesWq0AiFJ%+{2k-)FR|wvl!`s;k9o?9W}V|6b5W}{ z75A8nTD4khdmM`9kcxZEFX}g&x%0gL{jzJ|W8WM0s#33yylRwRPE{t_VyBk?u(U@4hj=xjDS^zQwzl_M-E?#rqc8zwP5LjQ{`u literal 0 HcmV?d00001 diff --git a/dominion/as3/unittest5 b/dominion/as3/unittest5 new file mode 100644 index 0000000000000000000000000000000000000000..5855f8fc467f719037917ca6a50ceebd3deb8132 GIT binary patch literal 62552 zcmeFa34ByV_CI>FGz7$SP|%2=je-W1C5jFxXa~~Jae|^O;+n)P5D7_4x>-~NSx70Br!ThzMLObPkyWW-xEMil zWb4kSIEyr&0hO*v7x*E=M5^S-Jd#U!THsTj&SyZSP0}!xs`^pg=r>W;Z(^bwIm){! zF|zruPKlSU@%wy51h2Z6vq;?xs5D#ZQ>l`>0&-;M(Ozki@k&`D9TYYZ+c zz43yfgUgBrmX((KXAhh`?1F(83>{QmG3Z>bH|Zzdv6oHal9V4^$dS!G@S{FJ^yeS_ zw4rkOseRYX8`!dC!I0g}dw#4VS@i>W)YrSAa zv*O^V$H9+@gYO*2{_o=O9~*~%Rvi8rEg!(!VDT{*gF%8U!8bNsNO(J`TQD9R0)M z@c$_ee{&rC6yQ7Z!!F>v<9Eb`_%VaR#RW!Q-qaZt<$2Y5X(QBh@pTqwxZ zzN*5?IYx=ExU3AkrPURM!-wZp7Z#M47?plswc#tBQA|+bw1O(5(l@QDxS%L+hTm5_ zJFl#waJn&LdQoYWQE+2LmCu-3?5iv-GN98}QASBwak(+0ct&-x54wx1s>&-!sK8fR zQErq}7Z*=&r_o<7bQaHGqYBF^s*8;o1!cgJ^5XKD&{_mVP**Y=b@CY{v#Lsc#YPF) zWt3D_m6rQTjFO^?N)&x_HCa_sSnew`3JMF0tE&x|a-+Wl;^YG9l^F%4FsG`x80f;; z1$hOiTq#+ssyn@SPF^7jKsjS`b4HEMJ9p5zgU+|%KiN>`P-=-p{1bl(`t5(jmvjVA zGB6H_C5;LE&oC(NyYTb(D(ym%{u=Zzx)Pwng;dQuCzh5TOEY;1=!9E-*S(m&l8j23 z7xIa=eE6AsaEZB?<_&eV#Nba8tWN*BO7MX`FY(;K?`Y%80?Mxt3@{ zV(_u+kzq0T*!kEUgQv39<&D9swFA+{$Kc^e`XDF;897V({G*5@}@& z9t~k%vt#h7Hr6l}#NeGV_{A}J)wV>gjlsu`|NCO_v2kr>4F32S{g21sY0aRnRWbOU z3W;=04E}@|d|eD)F7=qYH3olD41Z$`o?@rEcE;dOR!F2xF?h9RC2}|h-zSE@B?f;= z48Ao6e`*Zgcs8GN)OTDAi9abZ_`Wgtv>1GBTuzU{pB}^Sioy4b!Dqza`^Vsi#Nf|} z!FvPyQ@oaA#ltSc8?5s=!q;Lnc>|kLHVUTb`FDd9?Y|s?rq9@-ze@ZqBcz zJazrZ5Y9hGdFt{J7w7*?dFtwsG|vBn^3=s62IudmJaz3z%P&;_yD9IYd=uyIq&#)y zNF(QOr~GM@ujBkJls}#Ft2lqw-(5yYE%JP2ewAZxzrkzn@doy`jGvg(Q0KnOZFn2% z8*3?PxVyXC2>%m?94K*~nvHnzmo53mB=5jlB;G)4s@L2%EAje`Ye*S&-~-pcMxEwT@CHUs`x_X1r`RU+nDmqWa-8v&v??|t4-k03FigfM(>85en){GHcOjUN7p}-hu{CE0xnc77F`og}qo|YaByPkQVG; zZCm~+z<{SU!Sb|{70*&Fte(4=fo*66C~a7{zwS+{nxnUt?+y@784Oz*JarVo8a$gQ za5Z?gQoL&LY@;yM;Ay1j)ZlrSf>MKLC&i)$&u$7q4W6bRob085gXX_)K3YEf6Sv39 zFW9C&O<*Ww{52Z2CLQ*MJayEO6Co3R$-#Cl*UTm}kDN-X9u%tPX=*i7gYI)thS0cn zT?tf}Z+Xpz@by1Oqtd@{3w&8x*NB>V6T;qsjoV${ z2Uv4kt#SLkp%qlFff0fucp=T%94%E?m63g&jPf9t@lv_v%kHeJHs~^##(9}1R3+~@M%2adoE)k?&~!K zhR&~=3zmlPdFTdcl37}587XDE9o^6cteT*gdyr_*ajo9M*S)2$b6;6l--3d?32%5q zm!_ik0>}OBZ^oD72?2^i|PUkJE*Arb0Wa33*s3og$R(dzPxtHTj6Z(D@(T z#x*GwO5bEU$Kef3ANelm;dzI+o-b+YlT3}*X)bR4-A+TJ`-qP5zdbyD#l$Lx$I05p zG=O4woPbKG;jvc?fS*^9C%C391cpYssHV#gMx!dsHZco3>pg%n(1%9mKj1RL&9e;^ z^vt=KUT7Ngv|4F2aahLi4f9Uokd8=s#d_Q4V*ob0+cM5QX$=irFb>g-{fY5JWyq1TN|WX9^*Mce=DEA8xupPS4{VJ|GlxI47gZo~ZmU!$NAo;lH=3FtFT z+X;~R!F?3DqgNPMUhGevpAM!in&}mQz$eV_t(xOmCUWyX1~76q7UOWmPIi!->zwAGUUad7<22i$1q>G@Q zr>PlK4##Z0G-KyuX?EBdTm{t~lLM`3zJcVAH7@0@bpYcrclEp3Rct=3PYQQ5WY;FM zZ_pp8XDOU?#!RhvI>6>L+Hz3?qWCGAYaDS6Z9caxAH^5yBj6pXc?STbUgKQ)74{X> zbI?zEIhWQWr@D84;jA;X)X4{DD|dqkfqGc39(3 zOPU1_kaA3a3pY^zARRy)soVk~Cxg{KR=n(Y#5J=AtWf(M3mFG)-diqD4P zE41POJ$`CiM*qb`uhp$c05l=Jq3}8oFTtE#q`<4dyetgxp?{ z5p}7h9O2Q0&;w$tBo~7;vpSw%jk=3@{c!@x4GVVo9|+Pa^79IzXd_bT;Cf@BCokR4T*HF z*9ub3TEQf)6pbb7bHTd#GQ2;B%?s>#Q!m$fT_0c6d!JTVx`P**p*!6!(z1ezA(eIq+ z)R~?Giha@n8uKAh$s>ooHL*5@=QwkD&;|QMFFb(dOmhVc*{xT(+i8{SX$_4>!?7j5 zt5=!8%WiA6FyWxL^q`15-+C9;Q{*uxF6Ka@*gI&DKsW&h1gseQuw!P?1)R&OIheH4D2OcL-tX9}m$x7C@)ny z>~ny_&L!pW#Tv2=eSZ?0#eM%$0`+;(m*&?1jL>akxOWVrIZR$eAV=H%V$|1TB$=MWh*F*A(c14U&3h_9j$XF@ zK1}5L90xG+6j#&n>oZU)g3I>+v$0ptr2sRo$(pp+@`tG-hiEr2q9208rn5M{+w1$C zEX_*a1lW8ntXQWtK1(2nE2?d1Jh~DVJGGRdi8CgUVe!k+r~7CfeF9qfY*y5Bj>eP& z6fH0T=WZG1+}&76H$r8jh>fOazsMYD=jZiLQ-#^&=Kw}d7k>U5quI~*5NJ(m#1=sK znO5PkO?9VMF`ra4p$Jrbx>k|TDqzcfEmT+RB^ts%9cLKBH_o*iWTMuRLt5?^TF%#6 z&XQUh7EmXG5wv#nT7I(3+|Dr@diPzzr5~&15~W;h>9?Wu0UOPa$SGzmS*6`08U|?c zmFoYSpMn>JpVl(CDdSqbP4m(Y5$iOju-C>BNb5wHbUAg*4V<%QHi`fkM1!>2(*fFp z$c3#OZH1up`zNVnRvIRdb_nD@H~_t!vgC#iR$YM&BV;LSSOquoQvgLN_Sr19v%D+? zb23c2RWnxt6qOV^OD~^(a=23Khsm(;B$i+cQwd~~XrW6dT^%e0$*PMyVLy%{dC9u{ z3A=_{0E!ins+L>}3Yo+6YgNG$Q1B`(_$Yz#3zoi!Ep@sU&hMyHKHXtU56{0xl}gpU zR1046+odktu-A!R+OE2ZTK>?#JE$%#+3f047qWVO0zTRM-UTQ-9(Ot%Nyybt&xM+6 zrsfLlccFXI!Qud>b32_vAZ?k^lU5(ycrzdzYIFdEk5fqAVhwZ-cof0?iBM&UY4<$nT)&=W(AStN%ogJ=B%^NzzQEU!9n7{aU2W)}%Iuw&s4 zxXN+(acTl~-nRrYJ!TaQZVF3u3EF-@6r@CsLJVCZN0CL-V%EfAORa*#x<<-o)d}4& zXRbDHP`itj9=dHsoH&LI*oy2TxVJbj<%$A}FzdU9SBMcB3ZQGg_c@<3r>$-wfwtVza zwhj@u!|*1f3|l;dL)*P1AbO2;RI-8A1iQKgT6pqN3MaB~60AN)3->)r;UpIB1mQ!E z*kReC5&0>oy;)<%b=;yl(bmw7hZj@<+CO z2)owbYrR}JF0A#5gRglC8s0LJW`uvEg{%ioCGwFa(;i9d)oH#}sQ zJb^&kSmE$^|9sr?*x%+*ekk$>i`~Ewz%0qcS%C_%?4P@Hyh^R zKF)q|f9+PSr;^HqB~7b^Yv#iba-Hxj#k_$X*A43oy07K<2%OTDZv(U|aC-+%+oE}25d|F4 zm~@Bccbzs<>zN)~<^xjpNEa!e%z?$@wX`Rm73`BZy)6NqwE3KlywX6Om^$!2+|raz z`3Ruxl!a=8`z|x^ka(TJ*bOf3Eb0S=NxQ{-s?Rc=%LXRW!tO8?riRR}|FKJKB#?%T zTsA>L?22B_hd3u>Ccb-M`N7ojN#5^j(%S=i)`p6e7PpxPuIBB5V}v#{(>61f-!_Y_ zURY1nrUS(zG^=I07~t}-AYtO+uh{ld#p3h|om-yE98JYq(7}%ALI00e48!c#`|M8t zJwP?MzF{;s)n0)10Suihz1hTuF$kGM5`nk zY$n=BO*@xp^jg`PPJ%W-(@r58y;7%WJvFT>(Rve2+L@qf2k!+9PxBjVl7-H%fRLSj z57G9b(<|DCn)Vjawh~S1+^lJ9iS}fS+_ReY7}08DXb)=I-9+;dP1fDiw0T6E5+mo= zw3~=FB1W!2(f7t715+W ze_3Js^E-f%g_A$WbTUB8@HQ`Mn+^DoQXu>)ohA6_Lns7f6 zPE^rtxh9wZ#gP{sZV$s;Wcsm4o78BI+lI$nw(6K+joaFGYLPo~UfHOC6OSp-+G(C0 zT>pEI?Ux+@Bg@eafw?<-@lz#RnaJlA>j469=$pK+XvtM1NiUipGCZJV?jq2RbMef< z^67o?OxMj?V+p{}lq9-u&=7tJ-=8oM<$EvuIEcNbJdiy|cE%d#9H~EqccokstP`SE& zS>vB3kX?cj+HThOJC{wvgr|bhau(uHYBIQKSi6IG6Q_!}uXvYT=yn46EPji4g6Nkp zPoVY8!m3^b7_4(H{U`T)$1_^^5rA~Q2zhyvfu1-;n;PL;&NQIcai?aUParrgcZ!&; zTFvn^*WxySl(}6LeFMvI(Gvh-GdTpB#%oO;sfkw6|FfUWbzG>ag8|BeH+_0Vk4@3u zhwr$HO9R4l3t2@hd4h%E>@a<^K+o4b5m zEY@P}6k~@j)*o&0wEk$m9(4;Yv+H&XKuo{VW4yfRpn77_)Fhs5!JWWZOTYEXwT0M` z(ya^7+jir_^G)HvSc+5{r%bhuJyMQqN6WmnB~k6<8D?|&5mb3kVJ@AxE?sI@KLC*I zrB-^M?+4(SSg8e^Wty`9V6%FD{5p-l0w7Lc4QH@HJefRR(>x?|KJ;|cxCDT0O1xM; zcduDa0BCn``CKC+ev>&44>jTm5z8?mWY-{*K=K9OMYelB1vCVuCd-c}a(1hrw74$? z^8JQykPs1_lpcY!JE@~(iLHAdz(_rJX~%Yr-U2W%H*7d-9u>6Bnzj~T^Mx?6UgKUQ z@CaKDyU0SvU7BwZ^NBlr4}FF^9IXlSSF5A);ozOCd8?F8_=6ApFaJ(FT>-YsG}~x^ zSZ5~9tCxB}zC@FU0*q{DS2?C=^f-VR6c>4RI%^&TwK)S~X`1dJkSlaJ#<^#6g{W5^ zZrlHHzxXxXry4EWzncLzQ^mGvTs?t&9DG<*Z05J>UXSBJ&2~3HbURc`9t7Q`X^U6| z4B;pImeC7Pc6Z|2VR)4Tg}!vBZOD@ZhDJU+9_t^}7tjB`VL!;zoDbgr(Y&<;>YEhf z_O^|N;&C?`Zu}-ok*)GRsFb#Pw6+UvZO}tOLv4F-TseOcN*6t+C83e#sb!`GwqJGtlyk(}8oPW-tg%HyWIBy$^e2A zVxEYWi+JaLzRyyY~)k^zm6R%81Jmvqza&OYaMX zy76k+TlhYLXR=zH(tQlCuE0ouV*TjL0p%1;Ii5gvT-+kDaw4}PzU$}uj!idIulaDk z?Wea0BxPcqH=9q!9a}ZSdS+<92?*c;aoKAk9~tB%#|v8KUjS9mSuCiFH1$^2_R}>bIssRB-v)@T_kYWu3PMa z8VR(RP8-O)59zMoHk>fQ4t@Z*4y9vHxk)7NqN;FkBPCKyK8m$-?n!trSl}JE>jGv0 zw1Q+|7bOJ+D>cIwzi9H>`;b*dxqw| zk-1k;tx**b=DId=-7nW%*&T3g*-KpP54#+-J*1+7Y$-W`5 zsCka<=O%!_JACLkj$InxDDa*9=>gBXblzkHu1&zxNSggx^G#gpyNKBLB4Rh+2I^Ezy^g?kKF~`hs1lC#!vV364&o3o@MQw6 z0GF%~mNFkbE6AMcNy3B*qj;D(VJ$I>$s!82QX6Eo%$Wk)JF3N znA^y7KA7B0ptMOfc61MoD!vi_H_dquK)xaVs;ZtoaAU8EGdEQZJu$jKOZx%hUe-mP zZ9cr~<(RA~errGXOrn7tACs4KKeqNw=&~q_W@J;CUy)2%9T2~7vcibgW zKWC@{jS7RNXoJSFK_NLf`Q>Wy$o$6$4EUM=g;Pij(h{cwjO-TZu^K&s6^YImq@X7T z`bRsc#GVId+AeAaNIS2;3Ke^q!p`}SKze;n0__mmc8EU)?XvYF3q&vZrE+=E&=)#qHzLIR@Vjc(h`+?xCFLVV{waz5cITJbq>nRK*_zU5&gSw{8 z9n{nzYPwT%z1acRCm*pt)@rV207f3im=k3s`ZI0sv;fP81=2f|han*?d^2K=xsbK(?o}$oxl}e>L%I9?a6A^kebgrv-!KrZ8h5g{(dw6@C}FG z+qAlyN!@axZiQBNCxMo|M8ICy5KDwtbX^(yB3SUwyv^h5 zVgL9B&t9`R^vwy7*|c$xhxTp zTLyfW7V8-!Mr%{&vcHMroNk&Yfq6QPb`gi}c%O1xa*uf*VB}fQlu7dDGEO4ej3-fT zdlJX%BZ1baeq`<;t#LVN%wvs?1&rp__Y)|qt<)e=_O_C1`S`eP0YovoVJ>V}8M&G7 z9aEWebkTjO=)K8Q8OK-CQJxr&dkB<8^ZWIDN-C=-7Ow4zp)PF`V1082>0_U5 z02rAoidm|Q3B(q202*S8p}dG)xV8BZGSt6VC3|NUfzm`?>8hH`d4^s)y0C%A=R|Et z4nPo6a4djz(`Zc?1~AkEk3Y9*LtROV*D8KBCb2QcvNRi$NML)y!~bn&VXd10s^MSERMF&W81f#LPtDrm?ZbK6LW?Tk70$w_cVUCL z&#*Q{;<5H_`(ET$uY(`!pGfb$u~u*4Tb3WvZEtSS9T0Jj{u@OfNfNg>+Tz>n#E&F( zB+@|zg^3HdhzdUUdlhWRz8zBsH{)d8AO8$6c0(be##BTN)qum9nfvr0fRTT3RK^NR z?{a3LpPr?4o=TwXr`&My4q5`Oz5M+l`|(ZGN4NvL1CTlZFT#AZp~aV!?6vKB&G;OF zs*sM>w)EIiVD4_ixwt{px>gGZSy*>{4jScCTX+pwe!bBgx1S!&m_HQjXf*cI1+OtLD}4cAW9w|ximx&4^ z1ltc}NI$U~fsb`#=uVE`lMc(foM`)4Nq$-j%PVS|7(DlhLufU6d(}U?4V_Pmf2+hx zM_^nWQJj6q%wJQ|#i>JFxaZv)ZTGwmuo?GlV(j91;kU}YlW)U!P;{FarJY7Goj3|~ z(US?(;}7dJyGPJ{cnBn`hCh#`xQ#LZin|r^g!UZW}%@P9XLQUbu{8-Z)dx6Rx~ z;8B>_$xk<1?J}^2iYa52*7qnteIrr!KGjY5Nrd-!eGXN8s}?(vgbiAmYJ_su$c<14 zP>#OP$O|UAjBx##hQi>c+SaGwC4BUB?6HP{@A1;gitf*EhV!sVbksn?OYb)P)q99O zq|)du-MVZYv7XhQ_3E~)&S&s?$bfpUxz$V0bJK0zd42JH44Uidoi}po?8ORajTZ7BoHq9az+BB;Xb|5 zlO4TKegd3^=k5UEt-9C9h2dFA2CQ&oYw_U(a#;;w`X7_%GmehknAI^FNI~R3_ydu? zTI2+Ph>DoU+PLG3D@l`VoEFhIp{q&b5v=RlvZ8UqcH`i&5Ihn;?-Yu=u`RQhW#}ti zXc;^d3ipH-Q=3Re+tYc(D4L~+T0uDWYJk+27tTE#MU9+GGk7WDxI(jx0cbxd;F90H zcvdfP9s{_=6D4?`s_mu<+y>q6+-Ir?8B>+Y1^?VqsC$rwmcPtXAU8u-C^cR}9 z(+8uy^d!G; ztqGR_TV_dT*NVkNnFK?2n>x(&OqP)U}cnfoHb{QrXQsFP6vo_IF*dRV2|y0 zY2$%JpOZa9e5~izX+VmORSD2?{F_7}X7|DmFDG3+5FF?M{xo|8^JmR1M=!0wNeb|C z`HOX?qY!E=M*;rgsebxK_)nx)6!Z<#vY18>AUi(Sv|RvS>-pxjox|_&Yafmsn$`f& z?$&fu_!Lb$9^e+wA=$s=TaBGG{b#It#rq2T=rL>c*h4^cmS6Om_&b2%3x1;SyXoLX z{jFZ}ya;f?+(QQ6nSNH|A0v?3UWGffnC}d9FN#0ml@Fm{`Fui+7Merg!nv)^Gifl( zdwf1kFC{P}9)=z*PLXcV)CmM)*7J^h`I>DfI+xci_8b!RoFsTJ)VzZM3fe5x4^=ut z(@rK(mhxXbzs}X8Jz-bP6BXM9lts}{eazkdd~cYS;@rdk3lN5|5^N6~?=gux@*4z( zMo#Y!kEH&M&1lfnbpV^GX`j%zl|rJFBz8Z@5)W$X-2i2$2#x$|G8%7~izZ_6{|9)j zWB-Z@Ob88Kk0vn8pHcMVK=3v&d@;93Yl5$9gJTh})JzF|Dgh1XQ;xsaZp5>RNGIU) zmARJVT7c%yBcq6uvrfR51usE9VWZh+G*WLU`*zp08(%Y$VdWwWOMH6-Xnf@DecIQg zT0Jvy&(Z98HjvF5!|y&o|4o3~m_+Y#rC2=;pz+=$>S7(640u3e@O9_XO|WNpD;YiT z9gwPLB=n>dN@vl-yTM052kj-`8XPa3Py4df?p=(eD1t&xVW zM01aP8df0ACMG#*Kpno(bliq?)`eEjN~8(zpiN0#MhHgs0wmZ>Vzb84zx~)fA_%rvaZj%VIvCs9*tkaR(gX`|1oAO{_h5vcdq|n%_Sgt1K(XTfF6OK z`Dvi_l3D35j|6hf#fIS?upLv-JKqGpND3w2v2lEO0QB4X7XEtWupvWz)65q7z+8Pe z-M!e?FKJ75zqFx?llz%1fVvN<52qnLZW#U?f92xrehFqveK-aG;{@PD{$CjSTuhCT z+b<1YChu~(VdR)iUTaupU3eV|%dCU5Ghj0O#gSuU$spT)>%`{QYIS~6=8g&Q9G+UD zHEM}Dv0tLMA-i7+Rh|GeHTvV{_oJNyBbQ=xXPDXj(w#vk+Fu-Qn4heD5t$M*x!;=+%@>|mX_arS)tmlv?#{PNY#kT*XGUyGvY zONZg_{)%IuVadKvQRP%r8MHh|Vfo=T9Y5TN)}G)EP3-3~KNcbCG*&tLGOsoA15h&$ zHaNaO%Kdf>lnUz?ZlZdlW6J-(1E(s4$gE?On@Y(6Gy254>`!Pjp(VT*)_5Bna{$u? z`U_z<;jEFRz@gjtig;u?N|2=rSUt-K+A(`*_@7|JcbAE;!Epf+x*8lKZ0KSM@qett z<>D~*=AT)8SJ0Z*srGDe94C1#M+zX(>biX=m_G}5R72WKzxD_^8eja!4_7jSxBh3B zIVG9+7LZkw%pXWaB0#E6_#EakrzOkroOM;!%5tnU{C_HG<{R1OmcZtO`Y#>teBNc~@<2U?Z(aJr zA89-4-z5zF*H6)CXyQ}dv&|t~HFJD&mUT|Q@Lj+QL`IfX)-NTzpe>?XxPlN=6*D6T z9BJVjG{Rf|iwo5ve0q3Hhj>?b5b$P(WX-Y$b8$I=hU9P$P{s}a#mw-B*ORf$PC0)B zHl_!@O7M-(wodm1_xiqJ5yYSL@TWi0bAYZ~tFT2>tPu!?fX%5t?8-LtlR<3_za%&b z2VI2ruc9HYLRMBDnoGtfG!hpP-UA^F4&SjB+>igCN!Y`&fip4uR4XNj%yILBVT|P79X^AU%9N0ijznfOWmP@M{ zXVvd@1b$9&*1QLXtWY+>(?`uGV4edqG~VT`p;bkexyfuaKeEnQ9@v-={L1$kcOKC` zS%FOn+rM%j+??P$khSpe&tP}nu^4}aVZY$k4mI*9D=ph>+Wr->W8dW-7aFl8%e=}J z?u|uUjyX0Xd^~_G^d4k}ID_ohwmm3wNAtQZosGyRV5CYmB$k+Ce_2~>D9jKYpH(R6%*?-J)EB8P4^OIefXtl6#WUS${>V!#tEi_(OI+mIQ$pC){1G!LRhhQd1;>f{WSgy?glJ|XWlF8}O*6|8tKuEuR^) z&98O*{tbTWcXU9PW4Whgg(krr!@Qv>DY>D3?_m0I*6c!|wYkGPJ8M1xlo`!DcvN<< z>|>CyW_4o$G5^5g>`bz~z1=j`U7Hh_jR|;SwlyoAWyXejWM-QOOKQ!ya-QHppUZ2_ za%I+GJYa*kB?k+};oH5=+&5^Smo^)HeGB-KboQBG6Oc>4@X1%G4^oLXh;8M};sZeLIA3U9HiF$`deuj`4 zKE4*UhSzJ#aC;S9tt(X)tCm0Cg{ImCf_Ebpc)`7Jj&nsY32LyDdW9rET*i`KbEC6n zb9W)N0@@bbmJ}Tfx27=fc=YIKDyUGkysifG+Jg0@1+PoDpe&3z=EHZZrns;)&Q5T7 z15G&S+yuCv6Kc{(P2f>VTD)lF;I}L$@JXVSzK##aQNw^oF$)xzx$pR+RoseWS;dP;hZlfjezW8 zGN{gXNv_4-Yfh!{iVg!Z&>15J`@hXRxFyM;&D4H0CY}{>*6hP4Pto2-w z$p!iQ=UM|NXSz_<3PNL5zYRk$vo6P)YlMG*VUapmBBr?$@a8giuCIZz5Wbx?djX9s zC@P%ltZ7A2P}Zf5vg#9TWsh?$+4pEA8YXxqSR@Z}y95vVyEgX~>w9y{T2vQZ;FEBz zC>1i}A>-d0KJ@_aMb1WH4-A3jA;&h90?S|RiA2`JnbRUGF+`NhMc4y~a?apqzfg^f zcU~*@oLPDLykR}HQMgA44k)0BF_;VqSY$K=T@uQ+j&)6T85F9P&gw!%k32BRWn}K4 zO->>x7@pW&?FEhn9Un_5+y^FQTdc@KUMz#_Wbd?AjG&GyLe=_X@IcF`gy0S{NLYV2 zF~^xJh7pgoq7s&P6IQrIZZ_qHuka!_x3kw|0Mzlw(=kI$Qzt5AJ&hJjw+Aq&Uile@ zWxYm!J(&kFy!t@})=RnO_dL-CY4kvZW2s{m$L0pC0)s=SC=qcp>#|JzHyR;AWm^Ms ztt-+z=GWuQ_b{{Ig96D|DV+)*!P_q-p_t&_*<*4F-$m1NxDNHW5~l)5-q45>EGLD7 z9T30<@`P}6PwL<12j0M!>DHy`M0*jmtib++tiWOP14KSD*MmL0#nCy({5aeEET`~o zoO)^RajYn>=2X-x{Y%*v;eVRuLPl5V3i!(bICRbFi-X z%GWh#`1J^_ub>-?eOo#{EYm=W67ZizQHsV(hfsj^CRh)WdT)TsOS$Okd=npoc!Xva zi)UQa%XimBqf`7#azoS88n}xiS_|blfz9dIRD@q>jwu7R5P>nvy1pg+SCBYNn(4?N z2%By4t>HPyo9Sx)5dOF{a9a}=Y&UQPJQQ&!fGgYlG{?F=rT)|I3+oNz?+F+@X3FSL zw@XZKa#m<;G&khinBwbC`@vl6B9^5kS@=Yj9hOrcb>$BKKHHp~?EeIYr{!Qbk`p+b z;x{d>6-AsTUX-ooCa`$A<#-!DoxaW^qq7LOk=0<$Dcl5aiV=%G7aD=Pgsdyq@}}e_ zU7q3@{;Ttj&*2aP0=FOZ12$qEl4I`l3^!oO^94v~3jkuC5g zpNm>or9_rNwdiN?n-RH(CL=K_ju;AJ{=ERNC36qQ+XSs(4voR&KRF>X=}R0Hj zH1*$%Q)`;~gATBSM^kQCcW2EZ@L*Ss=9=GyJKur2pc8_y z8mmVv8-T@O<~Pt0Sqp7C{_$e{T9ocih)jcKVc$WHt>|6l7*-aJ|HXPstt@7zhimW% zHLY$=gt00Dh~5_Y25PMJ6oJA^5lAAp!8>ALUjnra1}!o$u<6{EOOx8IDQV$Tz+k3F zMnD2sF=z39LqtGq0uZDyZ8aeLMGoVL2tkp!+@{v29)(M4b;{Wg}eq z1RnqArPhgL3&kk1ucKAS@X=|`;LYT`K6k^E;4bIVFUf!qM{C`avewZCJKI`KE^a~SUxfG6&@!S= z130|+mN2$sSSpaBT=P>jAFT6=A>g%6b}pL&x$xzfIoOH-8 zmcI1S#XxJ4Gk7+*FxmOKjvGF-pR*o7$l2;zUp-jJLV81a5WU?)y~|UAR*3djqO@3LmhA=tjYjRG?_DCrCO;T+(m|M)%o6vY>h@xxQA*yLH&RO#~v9BOQ zET-p}4WXNHV6-RMoA6Qab+0*Uh}mLZnlUa^)R5vkF8n^C2kpLbc-A^@_!s`K16&JC zZkzG@CB+%M0Q~_WU>H>9T3j#L;9gUD=}Kkm8!*r^pe`ZuHF}N}oCcxcL0XexFH1L< zMUc?l56fB#Any__xC0C96i8qf9QmOI`#9cAV-Z8UMXG${VPI*YY2l0vhf`iKdvM?3 zB1GYRr(;N2Jjr=O$9~Ow2i|_k@EZaKfp_LY#Dw<{uh4NLy`WCZYy=1Gf1oJqP-Al) z&iXP@cUkG&kYh0zJm#n1nGGJXJV#(ZMwcbGN8M2fbyM@>T=P))bm1N>0mz5=1{x-; z$Q4>MPK*ALWqykSPK2iBm2{q!`Fi98u)&0ta3qq2NJP)rOK%ra&sa%KZDb9{JuPSO zCvXe;CPk;tBdXC+ zktT0Y!V?5Z_`_NABdZl-uKx4x3%79Re#;rW3PogDL;HogT`;`f8T3+#)@}V#P;6RO z^gY^7d+9_ucnkHoz{sD*x(vg267I8mIkeR*g%2>GL&x^TK6Z9z37|P5eG%Ezlz9Fe zP-R0bo=<%)c7Gh%g*Jyj9Vnx1WQ&}RxegTi-+{$UCFZBdDVRa90P%o!51q}5840yC zA``ymxwpncv+FF;Qi;%<`FcrhWG5;JnQJ*g{xP9{I`Xt$p_5o~kK1eY>5RH!wd|~! z54B<*v_|LSFt-#-WIC1rKbD-?!wd6g;)U_i)2Mq{$&Kg;zR$hG)BT_3hNh)we#Pe( zx1Egz@QGR0B*fmiDVYap!Ae`7aLzn(>}H&a{o?k2pcKw}M$Ws};v{UB{|<5gi?;6@ zOJeV*^4(OrCI2V%*v{5inCI^*m~kTov*Y~q%pKt$J|&mX;~%%ChaaDd0xxp(9pf@) zV*Bh!2jH~^o%nm>~30u+s2vHw&T zdc_&w_#Y2u&&N=ua02l@3BLjx1eUZ!cBAa@7YIF5B6opQn>8^s2D`IKxIfa6LUr-= zk@Y^Cm-^c%Fehw=Nv$}T^@r&eRLt$=TI^@NYbMFdyZuXV-woaYA9&ZECoiwr>aG7K z(c8Dt+ZSl3yu1kwObH_Zw-Rw}g1oSf-+)I9hROR^xc_A0fIi2>LjXDEds!26L;YKN zyNpSAh#;j8?iAz>*q6Brcj%J%cICKRVJ>`liaHO?HNVU?ao`ZmiuTyeg9(oT;CTRY zs5*<;7}K8L$5f8j&mqSEY5_D}SFe?Z*}oS&hMN_dy12^c zDk&%}D=xaw)xWx{(REbu)Y5X-#NujSY57!FQN_5@^5TpE7j`uW<;rB??9!t0GkvbA zVxPaN+%+)MHEUXNxyx5IheUi8fC{Roxe8o`{;KL?A$YDqid=;SRYk7y3ZJW}w3^`J zB4a{n+05c9MoujNPZ4RDR#0AKjIOAx1f>HRw>IXzi$;QRW$<|yoICiu^9K9NOMO06|NKEy3yTU2W5OfR zXa#;2e*eU8BYvOY_cMMcJ{palhu`J+O~>yJ{2s>dHT-trcL=}ZAB#o@R)7d;gbuEiPH*v!X>5E@KlAXcy?uRd3EW` z;=aaZ>oD1_huo{t=t6v# zhNIc1minq)6;-aX;_B)Fu8S{r8U4$OWS8ukQ(o!!xhm*a;;JerpIYo1G-wd@ELQ<_ z4)~$Ognp1`c%jen*lzXKO%z*e=X5u-$wWK{cS%qXauW2mYco~o*f zsW9Q(h9i&xAcOu=5v=!+MSPG>l8O9!@!;o&qdS(jJ z50K7Adf9?#^gg7wAzg!X1QwnkX9r1q+ypm@n6yC5Tp-35si*Vy7=>nu%36HcD zsp}{BuN%riItA%Uq?JhN>LC&%;g&0ngxP5cCwJ?dQk&2@jqttkTZ6uJmgJ$NV}8Tv z2O9BbRKs@kH6t}`Oltb2&SPe!EHEzVb(zo`wq*rwM2zZ>-1+tBCQ^hbcdcvdt@d|Ll}o4yI?e}Mj3atuA`<78r> zI_$--__k;i&n#&9aV*aCWUM2v0)192J+aEx-w*VsK_3)LFV*tdpsxeHE|#A7iY;FR z`gL>BH_&%&`;(sUL=0qK4d@53QBTE~)buV%iv9@bdltbzNHu+K0@3>cwF&s_#nI@^ zv2;%$DQPORfJ3yye$Yc^G~<24AUnFDonHgJqz%2muE#l`JMa?Bz*zb;CUZS< zK|c<3`p*t*{YlH%2-05$`Xa=fGh*e1dX`@T`V!DfkZSpYMCFGkf!~1`^-8RK;)}L@ z+d!XzSk>9Kw$Kc%v(Nh{mY1N1R}5wTR;F~M$+p`g#ZA8W8! zJxPO@PUTDl{;mh3(LS;DpmL7qs@Ub+2EIiPMWa|k>-r|P*!6h;^lK4AKaJIswA=Q_ zI?#I~wqD+beyL604f>xEbN98;-(>4Q40;-3@t!vH|JwB4$?!Mmt%%v$58pe8f!cEf z=>JB{z6N?UeUj~m>pTTn4bLrv`jOu~r<}rXIuWdOQO96z^ZBz~dkEy`aTkP>4Bu|R9E6ZyQZcClcm^=5n!1}`Y;zyCH_&VX-gA5sp+AlQK_ya$=RtH ziyT?0Ljs)=$8}B3$VzpMN=*mPD5-(E%5umrfc#jJPXrMO+4&^!Yk&_D{<72|iPxp3 zOimp_Ib$e(+d$92+)p26k$xmQFHLPsNNlwY^&T@8@Mt#La}3uXYXUdc3JXcm_|&w- zQK zJ8ch2llGu=X-_Wfc{!nLM+S+0MCFx1U&aSGGo|vlpUt=X8MWUM(5Ha@B%UfUuAp_q zrN?%g}v87$0MgA-PSEYuq1=J_4BR43XcK zB%yCDN``j=)#7KL!gJ6QC(E-Vc;`>@1>A` zqO(hX?-fz#ks?!vlYK;QwPDsCBy8BL4{@eQ2skGb%({De26FKeUyi zt9|NXEY7@SI=-8mp<`vf>@Jb#Jsog6pUP*-$@~{*urgI^=T=Fl{Q+HSegDI+(F)4n zm*}R%z*d~E*`3^+V#~_cnnX9JI1c9PR%tMA!huPbc-k7pUUc-r*Q$I@)EYlu5@?-I z7q)tQ;fXK4T2kDcD*WRzuk7{;HUnD(zEt_RSI+hEO8%(Kt8!ap{y=B9l>C1uNqIWI z!-5ydcD`4pkID2!nQoEk`!fAprUzx(=~y@GJwc{t$n*l4j*;nPnU=_Orc4*f^j?`h zCes&Xx<#h%%k*=Z9+YXPR9U`E&yeW_G94q+$ucdG=}eg}lIguNeN3h=%CtkLb%1Po zE}yZ~pNqCmzkc&R&vZiY85GjGE%}sbEamx#j#(kBq2^m9ITYc^amnZ^kZaFTd({Tw86{l9lv7_mgeAapj{{Cs@ z`!{#_)B1A>q2!u=r~XR54`hm_=Tx0Mv&X%$@~*A_KYz+-FYkIYzvF@> zR+W$Uz>KmkU6Z?1oil?-s{Z*$DNpm+?jaYxy=>%^9VD;jpQfXfr}^!vl4+YZ?0fT9 zl2`MY>#cms#=VsN$Ae@46N{VwHGge6F&`r(@{dxU+H2eU(F+&3r`M6Fn*ZyLQocK6 z?l0~)>a6r}w~)MQzm;$2Q#S6U?5DGF=jQC=Uz_sue~39%N;Dm%Jhj*ML3N`~96jo9 zB&yas`HlIMjeDu`sl4x(pS|swg2E^s8ZRfWef*vF@@YpYPxYNqcUfj>VAM`3 zOpQO+QOeW$_0F`NvzjkX*h2DZy_kQL^3-4Mt~EaXB6~#@$=m)vN_mR+Cx)LKHt~tc zD@dN^6TaTbmq5pf@*k}i`mE|bzJ2?Jk5Zo6>((G8DbpsIx;6`ZzD!rjl$m4xv|m3uVayN7RpROONU(nSg%O5*> z^o6dBv6oF6;2Jt;*r4-W=MKp{f5-*rp6ANAvbf0Q#Tz$_A9(Jt0YWnV-z2p1utfI} z3`y|b#18REhOa|>vVC77R#_5SaZQK(oeXu~qAh=CqoecwBDeS)_9T?}=b_B1d`~=Zo*#>1ILSD{=;*#il5wIDex@USoDQz)2!E2{ zezqfgFJq;QYh0lGlVqG6n`M~BZL;w#pZUZRDSjjvN7{c9@QHLf<#flgvu45%X@?&q z`P<*mqac%DXggKBo51)Z{dtSjqwX6b%hw|OO)!pZm*b(Zqk28c{Jjiyt`E=h^@7B! z`vnTWRpKif@|jQJ|10t1+u^^F_&VwTT9(2ydPvDX>VD^O5`QY}Ou%WKx{tt<2WaO= zyt=QT@E1$Gy3e5S6C_^UcTo7LO8;~DT%y81iwUD6|IB3mUWPiiQ1x9T@#;JzMcRL_ z#H(`_g?~cnc}J8Rmi!wezD}MC4U_mC60gpiyb}MJ#H({Gx5R%h@#=g`&DSZIc&J|) zQoq8VB=PDzPuV$8;?+5!vS+l!tMf<2KS|=%xu)VTmUy>3FU*j3&X#y}4!c$2O^H|M zyOk3EfW)hFW2NUQiC5>*O_G1T(*IUIW2Q(vy+c8MQ0M2$&OH*Z&gI>b|2w7U&3wkp zmiQ#}6V@Z~%ATGQ-z4u(DEyfcukL%)N49ldkG#kdg%WbB)mG0Q+hs?cy&If@IOer z>xH&@Qj(?qcKALLug>$7p1~5Y&i52POXAgepTg58OxXU_ZObiE`rF~@!(_y-&IgsA zJC%NUE~xN-Rr=fE|E2V|!>?8P+u`3-`d?~m=f_HaJN&mwe>;2v7Nl%{JN)qyug)u# z{R1REU!GSg{78vc=a~wBnbO~mzfkFaxvl-xN`E_ijndx^zg+2Whkrupm*n{;C8#Pa*20K`~r!;5qKKc>UkkGt`{&r=2N+k zQ1;v-@oJx;@Q+Kp+IJ{Cz2isyP3=Pzeyh^IIiD?2_+1jO_9+VgCGZ`!%Xh$&{q71k z>k)r(-=MR=FOc}_n2LL265k~8yvYKM-f1B{jg>;fRLP$y@$Q=ieyqfglK5JQ4@&%G z;He#V%Jxc;_)NlYA7nj8 zuAd*1{Ob8GRrt${KXRSFjrF7-v98_&{BhJScez;wrbWKKW4z47B*!5B6aR!!ZpQAD zv`%oK>XQ=1NjmVZScHVXL_wtI^pS4H@VkP52FB4dDh_^99J~|#jr8xBCiL?=aM0h1 z8+|VH^Y;6QpV7d?|7btKe=t_X z-CyAU6GzXNQje=j@bkNo;O{H-Trcez2pnAp!B73I{kU!fjr!Y?G&ivsxAR|oe@XVY zp{KhU!|$L2N}_gwpIy>^+W+$<{rT)vH)r{sTR>0YNBY-01-_W6cBVR-vY!Rb6%v@Mej;K4;tZS6+cKt zcgN8)SN5O2MS`E-d4|j*Y)>y^tDH}j{uxsLzXu5ZSET-zB!83S&yWkR&62=YHejl>0Z?pU;u; zvrg*C2Y>fOoI5FhN<4k1gUU5zKkqK_^qpfWchPxn#!NxG(luDNZ?9}O=lR`wK#Qav zmyEZAnTlt_;@J5#@Z_KN^THv>QMq@^d4a!)0o+=tzjB$IHQ&O2@qGYk=P73j{23Cz zMe?^u{!1kOfjIWO69<2n)L%YC=;v=QKv$OZ!*Q1iJbyy~_%Gt<`6&**2M!!N>OV`B zpG$;({x$&g&y($Y#|Z*I3plz4#nCeg`0j~E&c6#}y^7Crvpj!u0?p1;`v z{8EYkRhB!5r3~Y19!E!>Z(oLTPm?^c$!Rivj=0IqX#VB^pmMS^mQlflRlaJUzocYP zp^=w&>F6u-a&sn3%*!*1imUJ$wrYG#E6+D0uduA5yto=1MHP8d%PMXxD9bCtr=6uv8`)|z4$-ChE^Upg!Z%Cg0)Ec>jipm=#_+^H^1{bR?Z%_xN=1FT~%~Lqr z4Dwt-Rk58fFP=3PUa|Aj@$n~o;fyLn&KK1t_mmctmEKa^hPQeeTCq&aR+bgaY2$?( z{cZE*{u%T=x3f(v`9G@*)Twc^B zUs_ET)2Fp;mTG+9tauE*u%&7@wb*x6X?Z!mP-dfwstRVcsR?*SS5)iP6rTvR`9b#J zQ+mGQHbO-eqYA1jv~etiub|mtl~wpu9963=hJ0jWiYg{nmEP#bC&ZM!MHN{yZbZi{ z_+O=5J%}Vl6fRbT3j{F`LcW-z2)Hqnh-w-O+L|xw|5oWBtq1k+bc)N1F#-(>>h5 zGV9h{xu+4TS3V5V&KrlD2m9OLYURMRO~|g`uz>0A8CTlg&QWbK?(Xg$cTdd8=GL7q z)sPSSv5BWMy9O)Fx^#5E)46?Te{0*U>vjDa*5WkvDaMSef$f8{^xVYOqoaan%ydOgfp2N@Kk(qFel2Xk$D+_i4o$yhZvXr%HxgAf_ft5~_W=lm!nb@bUWg zbU_X@D@uF_%fG_Crx%%@qT6}3nUF!;G%jZ!oZv{es74=hVDBn$orRF@B<_1yaFn+{Admy(^X)WEi;)FY74P=%%Sr&E8}Y>OCgYf(`g z!?CRogxA(`VSdH)$hi67GsD_U%lOtU1OLdQmI~ZdnUy=_J~`NCYvzx|;z(eaVHte9 z($n*ziu#D5JT@N49r^B^jFpC0*;H?C?XO{Waq4t5!-_i0leJ-@G^Gac_^fntK0_v?f5O1Abi@Bq&5u4(hD8 zL&*JGG1yQ|R19OtP*zktD72ht45*^jn!E?gJK1BzF93^IN&I)?!p2I+-fS@8MMti$ z#M=%pBY~}z8h^6VK?**r7{6*$%|-T^gmMEnZG5%Tu~`-4U$Lp?65@A|^)J2=7x^z% zI+pn&kpD?bZN5k1q&mb6wgPJTzgy`b1;22Nzr=e#1-vHPe!@1q4bO4>I$~mx`sF;^ zoB#;&-Mve>GUT4(H}Ruy-UTn`-u|IZLFl;%C+J)dK8epjrf=vaE$8F*SkQZnBXNjF zP<-#WcUe5VlVhfIf$m>#z>CchTu3z>A ze`5S+4+QCAsaL391b8_&n1AFruzl`@u>D^lm+F^h%K5@M<8R8qaVcSYz76nl4)Niq z4zMEyGd`^U`v5QJ6|XKBkNv2223mH{F5{yx*sonx z>%MkVrZLE^u($yVV*_A4AbnGg8`|EvyJI~}56B!4fa!<%6DS1M0}8`!LB~v;me{nw h^nk=b0Hzj3gM>hKfcU-d-P@4$fW$!nrWQtn!~j^wD<}W} literal 0 HcmV?d00001 diff --git a/dominion/as3/unittest5.gcno b/dominion/as3/unittest5.gcno new file mode 100644 index 0000000000000000000000000000000000000000..7982f5a17dae658092b5eab161beab6f8d033114 GIT binary patch literal 3096 zcmd6p$!Zi)6o&70p63AsB?^LW#Gt{TiP~w(80WM&8?osGX`}Jo-xL*6}Mb4 z`(=LSrGkE^9mjLMc;rya9Dp=6yFI!73s<*{i7}65Nvm#|ANR!I zY}z(PV~#J2!SQ@q41Pr*2EQ^8gI^Vh!LJU);MW9V@Z_Rwp784eG5Ga?82pAn41QxE z2EQo~gWnv8!EXt~;I|6c^TGU)JNRt^)=p00xJL(!i7e}+1~B4&T^duI4hVEoD-ZETo7CoToPOsToGiZOSQU&;{NU{(dzt*+MyC{=p66QX^rJvFwYmChsVEu z`|yVOw7Q*GKGD6ptHS=GXV`UE|Zp#H+EV>{YYZn_GyZ$NlER zLeBY~lXEwhIUdXf`$+$AK+jk8zm?OYRefZua^n6sM4no8PTYH2#nm}+@7uKF q Date: Wed, 27 Nov 2019 23:43:13 -0800 Subject: [PATCH 12/15] Create hw.c --- projects/alghanmz/a3/hw.c | 1 + 1 file changed, 1 insertion(+) create mode 100644 projects/alghanmz/a3/hw.c diff --git a/projects/alghanmz/a3/hw.c b/projects/alghanmz/a3/hw.c new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/projects/alghanmz/a3/hw.c @@ -0,0 +1 @@ + From 40b82e389210dd0f9b871af7576575587d24eaa7 Mon Sep 17 00:00:00 2001 From: zee100100 Date: Wed, 27 Nov 2019 23:43:44 -0800 Subject: [PATCH 13/15] Create hw.c --- projects/alghanmz/a4/hw.c | 1 + 1 file changed, 1 insertion(+) create mode 100644 projects/alghanmz/a4/hw.c diff --git a/projects/alghanmz/a4/hw.c b/projects/alghanmz/a4/hw.c new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/projects/alghanmz/a4/hw.c @@ -0,0 +1 @@ + From c50ca57f8f451f28e27d6be7253ecc780427987e Mon Sep 17 00:00:00 2001 From: zee100100 Date: Wed, 27 Nov 2019 23:44:33 -0800 Subject: [PATCH 14/15] Add files via upload --- projects/alghanmz/a4/Makefile old | 31 + projects/alghanmz/a4/READM.md | 2 + projects/alghanmz/a4/dominion.c | 1405 ++++++++++++++ projects/alghanmz/a4/dominion.c.gcov | 1936 ++++++++++++++++++++ projects/alghanmz/a4/dominion.gcda | Bin 0 -> 5688 bytes projects/alghanmz/a4/dominion.gcno | Bin 0 -> 40596 bytes projects/alghanmz/a4/dominion.h | 131 ++ projects/alghanmz/a4/dominion.o | Bin 0 -> 52256 bytes projects/alghanmz/a4/dominion_helpers.h | 15 + projects/alghanmz/a4/interface.c | 425 +++++ projects/alghanmz/a4/interface.h | 128 ++ projects/alghanmz/a4/playdom.c | 135 ++ projects/alghanmz/a4/player.c | 205 +++ projects/alghanmz/a4/randomtestcard1 | Bin 0 -> 62256 bytes projects/alghanmz/a4/randomtestcard1.gcda | Bin 0 -> 1264 bytes projects/alghanmz/a4/randomtestcard1.gcno | Bin 0 -> 5328 bytes projects/alghanmz/a4/randomtestcard2 | Bin 0 -> 62048 bytes projects/alghanmz/a4/randomtestcard2.gcda | Bin 0 -> 1152 bytes projects/alghanmz/a4/randomtestcard2.gcno | Bin 0 -> 4968 bytes projects/alghanmz/a4/randomtestcard3 | Bin 0 -> 62256 bytes projects/alghanmz/a4/randomtestcard3.gcda | Bin 0 -> 1328 bytes projects/alghanmz/a4/randomtestcard3.gcno | Bin 0 -> 6336 bytes projects/alghanmz/a4/randomtestresults.out | 541 ++++++ projects/alghanmz/a4/rngs.c | 183 ++ projects/alghanmz/a4/rngs.gcda | Bin 0 -> 2632 bytes projects/alghanmz/a4/rngs.gcno | Bin 0 -> 4032 bytes projects/alghanmz/a4/rngs.h | 19 + projects/alghanmz/a4/rngs.o | Bin 0 -> 11792 bytes projects/alghanmz/a4/rt.c | 27 + projects/alghanmz/a4/testdrawcard.c | 74 + projects/alghanmz/a4/unittest1 | Bin 0 -> 62248 bytes 31 files changed, 5257 insertions(+) create mode 100644 projects/alghanmz/a4/Makefile old create mode 100644 projects/alghanmz/a4/READM.md create mode 100644 projects/alghanmz/a4/dominion.c create mode 100644 projects/alghanmz/a4/dominion.c.gcov create mode 100644 projects/alghanmz/a4/dominion.gcda create mode 100644 projects/alghanmz/a4/dominion.gcno create mode 100644 projects/alghanmz/a4/dominion.h create mode 100644 projects/alghanmz/a4/dominion.o create mode 100644 projects/alghanmz/a4/dominion_helpers.h create mode 100644 projects/alghanmz/a4/interface.c create mode 100644 projects/alghanmz/a4/interface.h create mode 100644 projects/alghanmz/a4/playdom.c create mode 100644 projects/alghanmz/a4/player.c create mode 100644 projects/alghanmz/a4/randomtestcard1 create mode 100644 projects/alghanmz/a4/randomtestcard1.gcda create mode 100644 projects/alghanmz/a4/randomtestcard1.gcno create mode 100644 projects/alghanmz/a4/randomtestcard2 create mode 100644 projects/alghanmz/a4/randomtestcard2.gcda create mode 100644 projects/alghanmz/a4/randomtestcard2.gcno create mode 100644 projects/alghanmz/a4/randomtestcard3 create mode 100644 projects/alghanmz/a4/randomtestcard3.gcda create mode 100644 projects/alghanmz/a4/randomtestcard3.gcno create mode 100644 projects/alghanmz/a4/randomtestresults.out create mode 100644 projects/alghanmz/a4/rngs.c create mode 100644 projects/alghanmz/a4/rngs.gcda create mode 100644 projects/alghanmz/a4/rngs.gcno create mode 100644 projects/alghanmz/a4/rngs.h create mode 100644 projects/alghanmz/a4/rngs.o create mode 100644 projects/alghanmz/a4/rt.c create mode 100644 projects/alghanmz/a4/testdrawcard.c create mode 100644 projects/alghanmz/a4/unittest1 diff --git a/projects/alghanmz/a4/Makefile old b/projects/alghanmz/a4/Makefile old new file mode 100644 index 000000000..5541801f3 --- /dev/null +++ b/projects/alghanmz/a4/Makefile old @@ -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/alghanmz/a4/READM.md b/projects/alghanmz/a4/READM.md new file mode 100644 index 000000000..c3599f6ad --- /dev/null +++ b/projects/alghanmz/a4/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/alghanmz/a4/dominion.c b/projects/alghanmz/a4/dominion.c new file mode 100644 index 000000000..739e2605e --- /dev/null +++ b/projects/alghanmz/a4/dominion.c @@ -0,0 +1,1405 @@ +#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 doMine(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) +{ + int i; + int j; + + 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; +} + +void getEstateCard(struct gameState *state, int currentPlayer) +{ + 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); + } + } +} + +void doBaron(int choice1, struct gameState *state, int currentPlayer) +{ + state->numBuys++;//Increase buys by 1! + state->numBuys++;//Increase buys by 1! + if (choice1 > 0) { //Boolean true or going to discard an estate + int p = 1; //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"); + } + getEstateCard(state, currentPlayer); + card_not_discarded = 0;//Exit the loop + } + + else { + p++;//Next card + } + } + } + + else { + getEstateCard(state, currentPlayer); + } +} + +void doMinion(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) +{ + int i; + int j; + + //+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) > 1 /*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); + } + } + } + } + } +} + +void doTribute(struct gameState *state, int currentPlayer, int nextPlayer, int tributeRevealedCards[2]) +{ + int i; + + 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->numActions = state->numActions + 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->coins += 2; + } + } +} + +int doAmbassador(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) +{ + int i; + int j; + + j = 0; //used to check if player has enough cards to discard + + if (choice2 > 3 || 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; +} + +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: + return doMine(choice1, choice2, state, handPos, currentPlayer); + + 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: + doBaron(choice1, state, currentPlayer); + 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: + doMinion(choice1, choice2, state, handPos, currentPlayer); + 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: + doTribute(state, currentPlayer, nextPlayer, tributeRevealedCards); + return 0; + + case ambassador: + return doAmbassador(choice1, choice2, state, handPos, currentPlayer); + + 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/alghanmz/a4/dominion.c.gcov b/projects/alghanmz/a4/dominion.c.gcov new file mode 100644 index 000000000..2e0a8d298 --- /dev/null +++ b/projects/alghanmz/a4/dominion.c.gcov @@ -0,0 +1,1936 @@ + -: 0:Source:dominion.c + -: 0:Graph:dominion.gcno + -: 0:Data:dominion.gcda + -: 0:Runs:3 + -: 0:Programs:3 + -: 1:#include "dominion.h" + -: 2:#include "dominion_helpers.h" + -: 3:#include "rngs.h" + -: 4:#include + -: 5:#include + -: 6:#include + -: 7: +function compare called 93382020 returned 100% blocks executed 100% + 93382020: 8:int compare(const void* a, const void* b) { + 93382020: 9: if (*(int*)a > *(int*)b) +branch 0 taken 1% (fallthrough) +branch 1 taken 99% + 45588: 10: return 1; + 93336432: 11: if (*(int*)a < *(int*)b) +branch 0 taken 27% (fallthrough) +branch 1 taken 73% + 24916392: 12: return -1; + 68420040: 13: return 0; + -: 14:} + -: 15: +function newGame called 0 returned 0% blocks executed 0% + #####: 16:struct gameState* newGame() { + #####: 17: struct gameState* g = malloc(sizeof(struct gameState)); + #####: 18: return g; + -: 19:} + -: 20: +function kingdomCards called 0 returned 0% blocks executed 0% + #####: 21:int* kingdomCards(int k1, int k2, int k3, int k4, int k5, int k6, int k7, + -: 22: int k8, int k9, int k10) { + #####: 23: int* k = malloc(10 * sizeof(int)); + #####: 24: k[0] = k1; + #####: 25: k[1] = k2; + #####: 26: k[2] = k3; + #####: 27: k[3] = k4; + #####: 28: k[4] = k5; + #####: 29: k[5] = k6; + #####: 30: k[6] = k7; + #####: 31: k[7] = k8; + #####: 32: k[8] = k9; + #####: 33: k[9] = k10; + #####: 34: return k; + -: 35:} + -: 36: +function initializeGame called 2073550 returned 100% blocks executed 95% + 2073550: 37:int initializeGame(int numPlayers, int kingdomCards[10], int randomSeed, + -: 38: struct gameState *state) { + -: 39: int i; + -: 40: int j; + -: 41: int it; + -: 42: + -: 43: //set up random number generator + 2073550: 44: SelectStream(1); +call 0 returned 100% + 2073550: 45: PutSeed((long)randomSeed); +call 0 returned 100% + -: 46: + -: 47: //check number of players + 2073550: 48: if (numPlayers > MAX_PLAYERS || numPlayers < 2) +branch 0 taken 100% (fallthrough) +branch 1 taken 0% +branch 2 taken 0% (fallthrough) +branch 3 taken 100% + -: 49: { + #####: 50: return -1; + -: 51: } + -: 52: + -: 53: //set number of players + 2073550: 54: state->numPlayers = numPlayers; + -: 55: + -: 56: //check selected kingdom cards are different + 22809050: 57: for (i = 0; i < 10; i++) +branch 0 taken 91% +branch 1 taken 9% (fallthrough) + -: 58: { +228090500: 59: for (j = 0; j < 10; j++) +branch 0 taken 91% +branch 1 taken 9% (fallthrough) + -: 60: { +207355000: 61: if (j != i && kingdomCards[j] == kingdomCards[i]) +branch 0 taken 90% (fallthrough) +branch 1 taken 10% +branch 2 taken 0% (fallthrough) +branch 3 taken 100% + -: 62: { + #####: 63: return -1; + -: 64: } + -: 65: } + -: 66: } + -: 67: + -: 68: + -: 69: //initialize supply + -: 70: /////////////////////////////// + -: 71: + -: 72: //set number of Curse cards + 2073550: 73: if (numPlayers == 2) +branch 0 taken 33% (fallthrough) +branch 1 taken 67% + -: 74: { + 691948: 75: state->supplyCount[curse] = 10; + -: 76: } + 1381602: 77: else if (numPlayers == 3) +branch 0 taken 50% (fallthrough) +branch 1 taken 50% + -: 78: { + 690892: 79: state->supplyCount[curse] = 20; + -: 80: } + -: 81: else + -: 82: { + 690710: 83: state->supplyCount[curse] = 30; + -: 84: } + -: 85: + -: 86: //set number of Victory cards + 2073550: 87: if (numPlayers == 2) +branch 0 taken 33% (fallthrough) +branch 1 taken 67% + -: 88: { + 691948: 89: state->supplyCount[estate] = 8; + 691948: 90: state->supplyCount[duchy] = 8; + 691948: 91: state->supplyCount[province] = 8; + -: 92: } + -: 93: else + -: 94: { + 1381602: 95: state->supplyCount[estate] = 12; + 1381602: 96: state->supplyCount[duchy] = 12; + 1381602: 97: state->supplyCount[province] = 12; + -: 98: } + -: 99: + -: 100: //set number of Treasure cards + 2073550: 101: state->supplyCount[copper] = 60 - (7 * numPlayers); + 2073550: 102: state->supplyCount[silver] = 40; + 2073550: 103: state->supplyCount[gold] = 30; + -: 104: + -: 105: //set number of Kingdom cards + 43544550: 106: for (i = adventurer; i <= treasure_map; i++) //loop all cards +branch 0 taken 95% +branch 1 taken 5% (fallthrough) + -: 107: { +342135750: 108: for (j = 0; j < 10; j++) //loop chosen cards +branch 0 taken 94% +branch 1 taken 6% (fallthrough) + -: 109: { +321400250: 110: if (kingdomCards[j] == i) +branch 0 taken 6% (fallthrough) +branch 1 taken 94% + -: 111: { + -: 112: //check if card is a 'Victory' Kingdom card + 20735500: 113: if (kingdomCards[j] == great_hall || kingdomCards[j] == gardens) +branch 0 taken 90% (fallthrough) +branch 1 taken 10% +branch 2 taken 11% (fallthrough) +branch 3 taken 89% + -: 114: { + 8294200: 115: if (numPlayers == 2) { +branch 0 taken 33% (fallthrough) +branch 1 taken 67% + 1383896: 116: state->supplyCount[i] = 8; + -: 117: } + -: 118: else { + 2763204: 119: state->supplyCount[i] = 12; + -: 120: } + -: 121: } + -: 122: else + -: 123: { + 16588400: 124: state->supplyCount[i] = 10; + -: 125: } + 20735500: 126: break; + -: 127: } + -: 128: else //card is not in the set choosen for the game + -: 129: { +300664750: 130: state->supplyCount[i] = -1; + -: 131: } + -: 132: } + -: 133: + -: 134: } + -: 135: + -: 136: //////////////////////// + -: 137: //supply intilization complete + -: 138: + -: 139: //set player decks + 8292962: 140: for (i = 0; i < numPlayers; i++) +branch 0 taken 75% +branch 1 taken 25% (fallthrough) + -: 141: { + 6219412: 142: state->deckCount[i] = 0; + 24877648: 143: for (j = 0; j < 3; j++) +branch 0 taken 75% +branch 1 taken 25% (fallthrough) + -: 144: { + 18658236: 145: state->deck[i][j] = estate; + 18658236: 146: state->deckCount[i]++; + -: 147: } + 49755296: 148: for (j = 3; j < 10; j++) +branch 0 taken 88% +branch 1 taken 13% (fallthrough) + -: 149: { + 43535884: 150: state->deck[i][j] = copper; + 43535884: 151: state->deckCount[i]++; + -: 152: } + -: 153: } + -: 154: + -: 155: //shuffle player decks + 8292962: 156: for (i = 0; i < numPlayers; i++) +branch 0 taken 75% +branch 1 taken 25% (fallthrough) + -: 157: { + 6219412: 158: if ( shuffle(i, state) < 0 ) +call 0 returned 100% +branch 1 taken 0% (fallthrough) +branch 2 taken 100% + -: 159: { + #####: 160: return -1; + -: 161: } + -: 162: } + -: 163: + -: 164: //draw player hands + 8292962: 165: for (i = 0; i < numPlayers; i++) +branch 0 taken 75% +branch 1 taken 25% (fallthrough) + -: 166: { + -: 167: //initialize hand size to zero + 6219412: 168: state->handCount[i] = 0; + 6219412: 169: state->discardCount[i] = 0; + -: 170: //draw 5 cards + -: 171: // for (j = 0; j < 5; j++) + -: 172: // { + -: 173: // drawCard(i, state); + -: 174: // } + -: 175: } + -: 176: + -: 177: //set embargo tokens to 0 for all supply piles + 58059400: 178: for (i = 0; i <= treasure_map; i++) +branch 0 taken 96% +branch 1 taken 4% (fallthrough) + -: 179: { + 55985850: 180: state->embargoTokens[i] = 0; + -: 181: } + -: 182: + -: 183: //initialize first player's turn + 2073550: 184: state->outpostPlayed = 0; + 2073550: 185: state->phase = 0; + 2073550: 186: state->numActions = 1; + 2073550: 187: state->numBuys = 1; + 2073550: 188: state->playedCardCount = 0; + 2073550: 189: state->whoseTurn = 0; + 2073550: 190: state->handCount[state->whoseTurn] = 0; + -: 191: //int it; move to top + -: 192: + -: 193: //Moved draw cards to here, only drawing at the start of a turn + 12441300: 194: for (it = 0; it < 5; it++) { +branch 0 taken 83% +branch 1 taken 17% (fallthrough) + 10367750: 195: drawCard(state->whoseTurn, state); +call 0 returned 100% + -: 196: } + -: 197: + 2073550: 198: updateCoins(state->whoseTurn, state, 0); +call 0 returned 100% + -: 199: + 2073550: 200: return 0; + -: 201:} + -: 202: +function shuffle called 6297823 returned 100% blocks executed 94% + 6297823: 203:int shuffle(int player, struct gameState *state) { + -: 204: + -: 205: + -: 206: int newDeck[MAX_DECK]; + 6297823: 207: int newDeckPos = 0; + -: 208: int card; + -: 209: int i; + -: 210: + 6297823: 211: if (state->deckCount[player] < 1) +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + #####: 212: return -1; + 6297823: 213: qsort ((void*)(state->deck[player]), state->deckCount[player], sizeof(int), compare); +call 0 returned 100% + -: 214: /* SORT CARDS IN DECK TO ENSURE DETERMINISM! */ + -: 215: + 74946595: 216: while (state->deckCount[player] > 0) { +branch 0 taken 91% +branch 1 taken 9% (fallthrough) + 62350949: 217: card = floor(Random() * state->deckCount[player]); +call 0 returned 100% + 62350949: 218: newDeck[newDeckPos] = state->deck[player][card]; + 62350949: 219: newDeckPos++; +228253492: 220: for (i = card; i < state->deckCount[player]-1; i++) { +branch 0 taken 73% +branch 1 taken 27% (fallthrough) +165902543: 221: state->deck[player][i] = state->deck[player][i+1]; + -: 222: } + 62350949: 223: state->deckCount[player]--; + -: 224: } + 68648772: 225: for (i = 0; i < newDeckPos; i++) { +branch 0 taken 91% +branch 1 taken 9% (fallthrough) + 62350949: 226: state->deck[player][i] = newDeck[i]; + 62350949: 227: state->deckCount[player]++; + -: 228: } + -: 229: + 6297823: 230: return 0; + -: 231:} + -: 232: +function playCard called 0 returned 0% blocks executed 0% + #####: 233:int playCard(int handPos, int choice1, int choice2, int choice3, struct gameState *state) + -: 234:{ + -: 235: int card; + #####: 236: int coin_bonus = 0; //tracks coins gain from actions + -: 237: + -: 238: //check if it is the right phase + #####: 239: if (state->phase != 0) +branch 0 never executed +branch 1 never executed + -: 240: { + #####: 241: return -1; + -: 242: } + -: 243: + -: 244: //check if player has enough actions + #####: 245: if ( state->numActions < 1 ) +branch 0 never executed +branch 1 never executed + -: 246: { + #####: 247: return -1; + -: 248: } + -: 249: + -: 250: //get card played + #####: 251: card = handCard(handPos, state); +call 0 never executed + -: 252: + -: 253: //check if selected card is an action + #####: 254: if ( card < adventurer || card > treasure_map ) +branch 0 never executed +branch 1 never executed +branch 2 never executed +branch 3 never executed + -: 255: { + #####: 256: return -1; + -: 257: } + -: 258: + -: 259: //play card + #####: 260: if ( cardEffect(card, choice1, choice2, choice3, state, handPos, &coin_bonus) < 0 ) +call 0 never executed +branch 1 never executed +branch 2 never executed + -: 261: { + #####: 262: return -1; + -: 263: } + -: 264: + -: 265: //reduce number of actions + #####: 266: state->numActions--; + -: 267: + -: 268: //update coins (Treasure cards may be added with card draws) + #####: 269: updateCoins(state->whoseTurn, state, coin_bonus); +call 0 never executed + -: 270: + #####: 271: return 0; + -: 272:} + -: 273: +function buyCard called 0 returned 0% blocks executed 0% + #####: 274:int buyCard(int supplyPos, struct gameState *state) { + -: 275: int who; + -: 276: if (DEBUG) { + -: 277: printf("Entering buyCard...\n"); + -: 278: } + -: 279: + -: 280: // I don't know what to do about the phase thing. + -: 281: + #####: 282: who = state->whoseTurn; + -: 283: + #####: 284: if (state->numBuys < 1) { +branch 0 never executed +branch 1 never executed + -: 285: if (DEBUG) + -: 286: printf("You do not have any buys left\n"); + #####: 287: return -1; + #####: 288: } else if (supplyCount(supplyPos, state) <1) { +call 0 never executed +branch 1 never executed +branch 2 never executed + -: 289: if (DEBUG) + -: 290: printf("There are not any of that type of card left\n"); + #####: 291: return -1; + #####: 292: } else if (state->coins < getCost(supplyPos)) { +call 0 never executed +branch 1 never executed +branch 2 never executed + -: 293: if (DEBUG) + -: 294: printf("You do not have enough money to buy that. You have %d coins.\n", state->coins); + #####: 295: return -1; + -: 296: } else { + #####: 297: state->phase=1; + -: 298: //state->supplyCount[supplyPos]--; + #####: 299: gainCard(supplyPos, state, 0, who); //card goes in discard, this might be wrong.. (2 means goes into hand, 0 goes into discard) +call 0 never executed + -: 300: + #####: 301: state->coins = (state->coins) - (getCost(supplyPos)); +call 0 never executed + #####: 302: state->numBuys--; + -: 303: if (DEBUG) + -: 304: 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); + -: 305: } + -: 306: + -: 307: //state->discard[who][state->discardCount[who]] = supplyPos; + -: 308: //state->discardCount[who]++; + -: 309: + #####: 310: return 0; + -: 311:} + -: 312: +function numHandCards called 747834 returned 100% blocks executed 100% + 747834: 313:int numHandCards(struct gameState *state) { + 747834: 314: return state->handCount[ whoseTurn(state) ]; +call 0 returned 100% + -: 315:} + -: 316: +function handCard called 0 returned 0% blocks executed 0% + #####: 317:int handCard(int handPos, struct gameState *state) { + #####: 318: int currentPlayer = whoseTurn(state); +call 0 never executed + #####: 319: return state->hand[currentPlayer][handPos]; + -: 320:} + -: 321: +function supplyCount called 1669227 returned 100% blocks executed 100% + 1669227: 322:int supplyCount(int card, struct gameState *state) { + 1669227: 323: return state->supplyCount[card]; + -: 324:} + -: 325: +function fullDeckCount called 0 returned 0% blocks executed 0% + #####: 326:int fullDeckCount(int player, int card, struct gameState *state) { + -: 327: int i; + #####: 328: int count = 0; + -: 329: + #####: 330: for (i = 0; i < state->deckCount[player]; i++) +branch 0 never executed +branch 1 never executed + -: 331: { + #####: 332: if (state->deck[player][i] == card) count++; +branch 0 never executed +branch 1 never executed + -: 333: } + -: 334: + #####: 335: for (i = 0; i < state->handCount[player]; i++) +branch 0 never executed +branch 1 never executed + -: 336: { + #####: 337: if (state->hand[player][i] == card) count++; +branch 0 never executed +branch 1 never executed + -: 338: } + -: 339: + #####: 340: for (i = 0; i < state->discardCount[player]; i++) +branch 0 never executed +branch 1 never executed + -: 341: { + #####: 342: if (state->discard[player][i] == card) count++; +branch 0 never executed +branch 1 never executed + -: 343: } + -: 344: + #####: 345: return count; + -: 346:} + -: 347: +function whoseTurn called 747834 returned 100% blocks executed 100% + 747834: 348:int whoseTurn(struct gameState *state) { + 747834: 349: return state->whoseTurn; + -: 350:} + -: 351: +function endTurn called 0 returned 0% blocks executed 0% + #####: 352:int endTurn(struct gameState *state) { + -: 353: int k; + -: 354: int i; + #####: 355: int currentPlayer = whoseTurn(state); +call 0 never executed + -: 356: + -: 357: //Discard hand + #####: 358: for (i = 0; i < state->handCount[currentPlayer]; i++) { +branch 0 never executed +branch 1 never executed + #####: 359: state->discard[currentPlayer][state->discardCount[currentPlayer]++] = state->hand[currentPlayer][i];//Discard + #####: 360: state->hand[currentPlayer][i] = -1;//Set card to -1 + -: 361: } + #####: 362: state->handCount[currentPlayer] = 0;//Reset hand count + -: 363: + -: 364: //Code for determining the player + #####: 365: if (currentPlayer < (state->numPlayers - 1)) { +branch 0 never executed +branch 1 never executed + #####: 366: state->whoseTurn = currentPlayer + 1;//Still safe to increment + -: 367: } + -: 368: else { + #####: 369: state->whoseTurn = 0;//Max player has been reached, loop back around to player 1 + -: 370: } + -: 371: + #####: 372: state->outpostPlayed = 0; + #####: 373: state->phase = 0; + #####: 374: state->numActions = 1; + #####: 375: state->coins = 0; + #####: 376: state->numBuys = 1; + #####: 377: state->playedCardCount = 0; + #####: 378: state->handCount[state->whoseTurn] = 0; + -: 379: + -: 380: //int k; move to top + -: 381: //Next player draws hand + #####: 382: for (k = 0; k < 5; k++) { +branch 0 never executed +branch 1 never executed + #####: 383: drawCard(state->whoseTurn, state);//Draw a card +call 0 never executed + -: 384: } + -: 385: + -: 386: //Update money + #####: 387: updateCoins(state->whoseTurn, state, 0); +call 0 never executed + -: 388: + #####: 389: return 0; + -: 390:} + -: 391: +function isGameOver called 0 returned 0% blocks executed 0% + #####: 392:int isGameOver(struct gameState *state) { + -: 393: int i; + -: 394: int j; + -: 395: + -: 396: //if stack of Province cards is empty, the game ends + #####: 397: if (state->supplyCount[province] == 0) +branch 0 never executed +branch 1 never executed + -: 398: { + #####: 399: return 1; + -: 400: } + -: 401: + -: 402: //if three supply pile are at 0, the game ends + #####: 403: j = 0; + #####: 404: for (i = 0; i < 25; i++) +branch 0 never executed +branch 1 never executed + -: 405: { + #####: 406: if (state->supplyCount[i] == 0) +branch 0 never executed +branch 1 never executed + -: 407: { + #####: 408: j++; + -: 409: } + -: 410: } + #####: 411: if ( j >= 3) +branch 0 never executed +branch 1 never executed + -: 412: { + #####: 413: return 1; + -: 414: } + -: 415: + #####: 416: return 0; + -: 417:} + -: 418: +function scoreFor called 0 returned 0% blocks executed 0% + #####: 419:int scoreFor (int player, struct gameState *state) { + -: 420: + -: 421: int i; + #####: 422: int score = 0; + -: 423: //score from hand + #####: 424: for (i = 0; i < state->handCount[player]; i++) +branch 0 never executed +branch 1 never executed + -: 425: { + #####: 426: if (state->hand[player][i] == curse) { +branch 0 never executed +branch 1 never executed + #####: 427: score = score - 1; + -: 428: }; + #####: 429: if (state->hand[player][i] == estate) { +branch 0 never executed +branch 1 never executed + #####: 430: score = score + 1; + -: 431: }; + #####: 432: if (state->hand[player][i] == duchy) { +branch 0 never executed +branch 1 never executed + #####: 433: score = score + 3; + -: 434: }; + #####: 435: if (state->hand[player][i] == province) { +branch 0 never executed +branch 1 never executed + #####: 436: score = score + 6; + -: 437: }; + #####: 438: if (state->hand[player][i] == great_hall) { +branch 0 never executed +branch 1 never executed + #####: 439: score = score + 1; + -: 440: }; + #####: 441: if (state->hand[player][i] == gardens) { +branch 0 never executed +branch 1 never executed + #####: 442: score = score + ( fullDeckCount(player, 0, state) / 10 ); +call 0 never executed + -: 443: }; + -: 444: } + -: 445: + -: 446: //score from discard + #####: 447: for (i = 0; i < state->discardCount[player]; i++) +branch 0 never executed +branch 1 never executed + -: 448: { + #####: 449: if (state->discard[player][i] == curse) { +branch 0 never executed +branch 1 never executed + #####: 450: score = score - 1; + -: 451: }; + #####: 452: if (state->discard[player][i] == estate) { +branch 0 never executed +branch 1 never executed + #####: 453: score = score + 1; + -: 454: }; + #####: 455: if (state->discard[player][i] == duchy) { +branch 0 never executed +branch 1 never executed + #####: 456: score = score + 3; + -: 457: }; + #####: 458: if (state->discard[player][i] == province) { +branch 0 never executed +branch 1 never executed + #####: 459: score = score + 6; + -: 460: }; + #####: 461: if (state->discard[player][i] == great_hall) { +branch 0 never executed +branch 1 never executed + #####: 462: score = score + 1; + -: 463: }; + #####: 464: if (state->discard[player][i] == gardens) { +branch 0 never executed +branch 1 never executed + #####: 465: score = score + ( fullDeckCount(player, 0, state) / 10 ); +call 0 never executed + -: 466: }; + -: 467: } + -: 468: + -: 469: //score from deck + #####: 470: for (i = 0; i < state->discardCount[player]; i++) +branch 0 never executed +branch 1 never executed + -: 471: { + #####: 472: if (state->deck[player][i] == curse) { +branch 0 never executed +branch 1 never executed + #####: 473: score = score - 1; + -: 474: }; + #####: 475: if (state->deck[player][i] == estate) { +branch 0 never executed +branch 1 never executed + #####: 476: score = score + 1; + -: 477: }; + #####: 478: if (state->deck[player][i] == duchy) { +branch 0 never executed +branch 1 never executed + #####: 479: score = score + 3; + -: 480: }; + #####: 481: if (state->deck[player][i] == province) { +branch 0 never executed +branch 1 never executed + #####: 482: score = score + 6; + -: 483: }; + #####: 484: if (state->deck[player][i] == great_hall) { +branch 0 never executed +branch 1 never executed + #####: 485: score = score + 1; + -: 486: }; + #####: 487: if (state->deck[player][i] == gardens) { +branch 0 never executed +branch 1 never executed + #####: 488: score = score + ( fullDeckCount(player, 0, state) / 10 ); +call 0 never executed + -: 489: }; + -: 490: } + -: 491: + #####: 492: return score; + -: 493:} + -: 494: +function getWinners called 0 returned 0% blocks executed 0% + #####: 495:int getWinners(int players[MAX_PLAYERS], struct gameState *state) { + -: 496: int i; + -: 497: int j; + -: 498: int highScore; + -: 499: int currentPlayer; + -: 500: + -: 501: //get score for each player + #####: 502: for (i = 0; i < MAX_PLAYERS; i++) +branch 0 never executed +branch 1 never executed + -: 503: { + -: 504: //set unused player scores to -9999 + #####: 505: if (i >= state->numPlayers) +branch 0 never executed +branch 1 never executed + -: 506: { + #####: 507: players[i] = -9999; + -: 508: } + -: 509: else + -: 510: { + #####: 511: players[i] = scoreFor (i, state); +call 0 never executed + -: 512: } + -: 513: } + -: 514: + -: 515: //find highest score + #####: 516: j = 0; + #####: 517: for (i = 0; i < MAX_PLAYERS; i++) +branch 0 never executed +branch 1 never executed + -: 518: { + #####: 519: if (players[i] > players[j]) +branch 0 never executed +branch 1 never executed + -: 520: { + #####: 521: j = i; + -: 522: } + -: 523: } + #####: 524: highScore = players[j]; + -: 525: + -: 526: //add 1 to players who had less turns + #####: 527: currentPlayer = whoseTurn(state); +call 0 never executed + #####: 528: for (i = 0; i < MAX_PLAYERS; i++) +branch 0 never executed +branch 1 never executed + -: 529: { + #####: 530: if ( players[i] == highScore && i > currentPlayer ) +branch 0 never executed +branch 1 never executed +branch 2 never executed +branch 3 never executed + -: 531: { + #####: 532: players[i]++; + -: 533: } + -: 534: } + -: 535: + -: 536: //find new highest score + #####: 537: j = 0; + #####: 538: for (i = 0; i < MAX_PLAYERS; i++) +branch 0 never executed +branch 1 never executed + -: 539: { + #####: 540: if ( players[i] > players[j] ) +branch 0 never executed +branch 1 never executed + -: 541: { + #####: 542: j = i; + -: 543: } + -: 544: } + #####: 545: highScore = players[j]; + -: 546: + -: 547: //set winners in array to 1 and rest to 0 + #####: 548: for (i = 0; i < MAX_PLAYERS; i++) +branch 0 never executed +branch 1 never executed + -: 549: { + #####: 550: if ( players[i] == highScore ) +branch 0 never executed +branch 1 never executed + -: 551: { + #####: 552: players[i] = 1; + -: 553: } + -: 554: else + -: 555: { + #####: 556: players[i] = 0; + -: 557: } + -: 558: } + -: 559: + #####: 560: return 0; + -: 561:} + -: 562: +function drawCard called 15673140 returned 100% blocks executed 38% + 15673140: 563:int drawCard(int player, struct gameState *state) + -: 564:{ int count; + -: 565: int deckCounter; + 15673140: 566: if (state->deckCount[player] <= 0) { //Deck is empty +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + -: 567: + -: 568: //Step 1 Shuffle the discard pile back into a deck + -: 569: int i; + -: 570: //Move discard to deck + #####: 571: for (i = 0; i < state->discardCount[player]; i++) { +branch 0 never executed +branch 1 never executed + #####: 572: state->deck[player][i] = state->discard[player][i]; + #####: 573: state->discard[player][i] = -1; + -: 574: } + -: 575: + #####: 576: state->deckCount[player] = state->discardCount[player]; + #####: 577: state->discardCount[player] = 0;//Reset discard + -: 578: + -: 579: //Shufffle the deck + #####: 580: shuffle(player, state);//Shuffle the deck up and make it so that we can draw +call 0 never executed + -: 581: + -: 582: if (DEBUG) { //Debug statements + -: 583: printf("Deck count now: %d\n", state->deckCount[player]); + -: 584: } + -: 585: + #####: 586: state->discardCount[player] = 0; + -: 587: + -: 588: //Step 2 Draw Card + #####: 589: count = state->handCount[player];//Get current player's hand count + -: 590: + -: 591: if (DEBUG) { //Debug statements + -: 592: printf("Current hand count: %d\n", count); + -: 593: } + -: 594: + #####: 595: deckCounter = state->deckCount[player];//Create a holder for the deck count + -: 596: + #####: 597: if (deckCounter == 0) +branch 0 never executed +branch 1 never executed + #####: 598: return -1; + -: 599: + #####: 600: state->hand[player][count] = state->deck[player][deckCounter - 1];//Add card to hand + #####: 601: state->deckCount[player]--; + #####: 602: state->handCount[player]++;//Increment hand count + -: 603: } + -: 604: + -: 605: else { + 15673140: 606: int count = state->handCount[player];//Get current hand count for player + -: 607: int deckCounter; + -: 608: if (DEBUG) { //Debug statements + -: 609: printf("Current hand count: %d\n", count); + -: 610: } + -: 611: + 15673140: 612: deckCounter = state->deckCount[player];//Create holder for the deck count + 15673140: 613: state->hand[player][count] = state->deck[player][deckCounter - 1];//Add card to the hand + 15673140: 614: state->deckCount[player]--; + 15673140: 615: state->handCount[player]++;//Increment hand count + -: 616: } + -: 617: + 15673140: 618: return 0; + -: 619:} + -: 620: +function getCost called 0 returned 0% blocks executed 0% + #####: 621:int getCost(int cardNumber) + -: 622:{ + #####: 623: switch( cardNumber ) +branch 0 never executed +branch 1 never executed +branch 2 never executed +branch 3 never executed +branch 4 never executed +branch 5 never executed +branch 6 never executed +branch 7 never executed +branch 8 never executed +branch 9 never executed +branch 10 never executed +branch 11 never executed +branch 12 never executed +branch 13 never executed +branch 14 never executed +branch 15 never executed +branch 16 never executed +branch 17 never executed +branch 18 never executed +branch 19 never executed +branch 20 never executed +branch 21 never executed +branch 22 never executed +branch 23 never executed +branch 24 never executed +branch 25 never executed +branch 26 never executed +branch 27 never executed + -: 624: { + -: 625: case curse: + #####: 626: return 0; + -: 627: case estate: + #####: 628: return 2; + -: 629: case duchy: + #####: 630: return 5; + -: 631: case province: + #####: 632: return 8; + -: 633: case copper: + #####: 634: return 0; + -: 635: case silver: + #####: 636: return 3; + -: 637: case gold: + #####: 638: return 6; + -: 639: case adventurer: + #####: 640: return 6; + -: 641: case council_room: + #####: 642: return 5; + -: 643: case feast: + #####: 644: return 4; + -: 645: case gardens: + #####: 646: return 4; + -: 647: case mine: + #####: 648: return 5; + -: 649: case remodel: + #####: 650: return 4; + -: 651: case smithy: + #####: 652: return 4; + -: 653: case village: + #####: 654: return 3; + -: 655: case baron: + #####: 656: return 4; + -: 657: case great_hall: + #####: 658: return 3; + -: 659: case minion: + #####: 660: return 5; + -: 661: case steward: + #####: 662: return 3; + -: 663: case tribute: + #####: 664: return 5; + -: 665: case ambassador: + #####: 666: return 3; + -: 667: case cutpurse: + #####: 668: return 4; + -: 669: case embargo: + #####: 670: return 2; + -: 671: case outpost: + #####: 672: return 5; + -: 673: case salvager: + #####: 674: return 4; + -: 675: case sea_hag: + #####: 676: return 4; + -: 677: case treasure_map: + #####: 678: return 4; + -: 679: } + -: 680: + #####: 681: return -1; + -: 682:} + -: 683: +function doMine called 0 returned 0% blocks executed 0% + #####: 684:int doMine(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) + -: 685:{ + -: 686: int i; + -: 687: int j; + -: 688: + #####: 689: j = state->hand[currentPlayer][choice1]; //store card we will trash + -: 690: + #####: 691: if (/*state->hand[currentPlayer][choice1] < copper ||*/ state->hand[currentPlayer][choice1] > gold) +branch 0 never executed +branch 1 never executed + -: 692: { + #####: 693: return -1; + -: 694: } + -: 695: + #####: 696: if (choice2 > treasure_map || choice2 < curse) +branch 0 never executed +branch 1 never executed +branch 2 never executed +branch 3 never executed + -: 697: { + #####: 698: return -1; + -: 699: } + -: 700: + #####: 701: if ( (getCost(state->hand[currentPlayer][choice1]) + 3) > getCost(choice2) ) +call 0 never executed +call 1 never executed +branch 2 never executed +branch 3 never executed + -: 702: { + #####: 703: return -1; + -: 704: } + -: 705: + -: 706: //gainCard(choice2, state, 2, currentPlayer); + -: 707: + -: 708: //discard card from hand + #####: 709: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + -: 710: + -: 711: //discard trashed card + #####: 712: for (i = 0; i < state->handCount[currentPlayer]; i++) +branch 0 never executed +branch 1 never executed + -: 713: { + #####: 714: if (state->hand[currentPlayer][i] == j) +branch 0 never executed +branch 1 never executed + -: 715: { + #####: 716: discardCard(i, currentPlayer, state, 0); +call 0 never executed + #####: 717: break; + -: 718: } + -: 719: } + -: 720: + #####: 721: return 0; + -: 722:} + -: 723: +function getEstateCard called 556409 returned 100% blocks executed 86% + 556409: 724:void getEstateCard(struct gameState *state, int currentPlayer) + -: 725:{ + 556409: 726: if (supplyCount(estate, state) > 0) { +call 0 returned 100% +branch 1 taken 100% (fallthrough) +branch 2 taken 0% + 556409: 727: gainCard(estate, state, 0, currentPlayer);//Gain an estate +call 0 returned 100% + -: 728: + 556409: 729: state->supplyCount[estate]--;//Decrement Estates + 556409: 730: if (supplyCount(estate, state) == 0) { +call 0 returned 100% +branch 1 taken 0% (fallthrough) +branch 2 taken 100% + #####: 731: isGameOver(state); +call 0 never executed + -: 732: } + -: 733: } + 556409: 734:} + -: 735: +function doBaron called 647059 returned 100% blocks executed 100% + 647059: 736:void doBaron(int choice1, struct gameState *state, int currentPlayer) + -: 737:{ + 647059: 738: state->numBuys++;//Increase buys by 1! + 647059: 739: state->numBuys++;//Increase buys by 1! + 647059: 740: if (choice1 > 0) { //Boolean true or going to discard an estate +branch 0 taken 50% (fallthrough) +branch 1 taken 50% + 322771: 741: int p = 1; //0;//Iterator for hand! + 322771: 742: int card_not_discarded = 1;//Flag for discard set! + 1333592: 743: while(card_not_discarded) { +branch 0 taken 68% +branch 1 taken 32% (fallthrough) + 688050: 744: if (state->hand[currentPlayer][p] == estate) { //Found an estate card! +branch 0 taken 13% (fallthrough) +branch 1 taken 87% + 90650: 745: state->coins += 4;//Add 4 coins to the amount of coins + 90650: 746: state->discard[currentPlayer][state->discardCount[currentPlayer]] = state->hand[currentPlayer][p]; + 90650: 747: state->discardCount[currentPlayer]++; + 247791: 748: for (; p < state->handCount[currentPlayer]; p++) { +branch 0 taken 63% +branch 1 taken 37% (fallthrough) + 157141: 749: state->hand[currentPlayer][p] = state->hand[currentPlayer][p+1]; + -: 750: } + 90650: 751: state->hand[currentPlayer][state->handCount[currentPlayer]] = -1; + 90650: 752: state->handCount[currentPlayer]--; + 90650: 753: card_not_discarded = 0;//Exit the loop + -: 754: } + 597400: 755: else if (p > state->handCount[currentPlayer]) { +branch 0 taken 39% (fallthrough) +branch 1 taken 61% + -: 756: if(DEBUG) { + -: 757: printf("No estate cards in your hand, invalid choice\n"); + -: 758: printf("Must gain an estate if there are any\n"); + -: 759: } + 232121: 760: getEstateCard(state, currentPlayer); +call 0 returned 100% + 232121: 761: card_not_discarded = 0;//Exit the loop + -: 762: } + -: 763: + -: 764: else { + 365279: 765: p++;//Next card + -: 766: } + -: 767: } + -: 768: } + -: 769: + -: 770: else { + 324288: 771: getEstateCard(state, currentPlayer); +call 0 returned 100% + -: 772: } + 647059: 773:} + -: 774: +function doMinion called 720681 returned 100% blocks executed 100% + 720681: 775:void doMinion(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) + -: 776:{ + -: 777: int i; + -: 778: int j; + -: 779: + -: 780: //+1 action + 720681: 781: state->numActions++; + -: 782: + -: 783: //discard card from hand + 720681: 784: discardCard(handPos, currentPlayer, state, 0); +call 0 returned 100% + -: 785: + 720681: 786: if (choice1) +branch 0 taken 50% (fallthrough) +branch 1 taken 50% + -: 787: { + 361452: 788: state->coins = state->coins + 2; + -: 789: } + 359229: 790: else if (choice2) //discard hand, redraw 4, other players with 5+ cards discard hand and draw 4 +branch 0 taken 100% (fallthrough) +branch 1 taken 0% + -: 791: { + -: 792: //discard hand + 1107063: 793: while(numHandCards(state) > 1 /*0*/) +call 0 returned 100% +branch 1 taken 52% +branch 2 taken 48% (fallthrough) + -: 794: { + 388605: 795: discardCard(handPos, currentPlayer, state, 0); +call 0 returned 100% + -: 796: } + -: 797: + -: 798: //draw 4 + 1796145: 799: for (i = 0; i < 4; i++) +branch 0 taken 80% +branch 1 taken 20% (fallthrough) + -: 800: { + 1436916: 801: drawCard(currentPlayer, state); +call 0 returned 100% + -: 802: } + -: 803: + -: 804: //other players discard hand and redraw if hand size > 4 + 1436917: 805: for (i = 0; i < state->numPlayers; i++) +branch 0 taken 75% +branch 1 taken 25% (fallthrough) + -: 806: { + 1077688: 807: if (i != currentPlayer) +branch 0 taken 67% (fallthrough) +branch 1 taken 33% + -: 808: { + -: 809: //if ( state->handCount[i] > 4 ) + -: 810: { + -: 811: //discard hand + 4671315: 812: while( state->handCount[i] > 0 ) +branch 0 taken 82% +branch 1 taken 18% (fallthrough) + -: 813: { + 3234397: 814: discardCard(handPos, i, state, 0); +call 0 returned 100% + -: 815: } + -: 816: + -: 817: //draw 4 + 3592295: 818: for (j = 0; j < 4; j++) +branch 0 taken 80% +branch 1 taken 20% (fallthrough) + -: 819: { + 2873836: 820: drawCard(i, state); +call 0 returned 100% + -: 821: } + -: 822: } + -: 823: } + -: 824: } + -: 825: } + 720681: 826:} + -: 827: +function doTribute called 705810 returned 100% blocks executed 100% + 705810: 828:void doTribute(struct gameState *state, int currentPlayer, int nextPlayer, int tributeRevealedCards[2]) + -: 829:{ + -: 830: int i; + -: 831: + 705810: 832: if ((state->discardCount[nextPlayer] + state->deckCount[nextPlayer]) <= 1) { +branch 0 taken 8% (fallthrough) +branch 1 taken 92% + 58992: 833: if (state->deckCount[nextPlayer] > 0) { +branch 0 taken 33% (fallthrough) +branch 1 taken 67% + 19584: 834: tributeRevealedCards[0] = state->deck[nextPlayer][state->deckCount[nextPlayer]-1]; + 19584: 835: state->deckCount[nextPlayer]--; + -: 836: } + 39408: 837: else if (state->discardCount[nextPlayer] > 0) { +branch 0 taken 50% (fallthrough) +branch 1 taken 50% + 19581: 838: tributeRevealedCards[0] = state->discard[nextPlayer][state->discardCount[nextPlayer]-1]; + 19581: 839: state->discardCount[nextPlayer]--; + -: 840: } + -: 841: else { + -: 842: //No Card to Reveal + -: 843: if (DEBUG) { + -: 844: printf("No cards to reveal\n"); + -: 845: } + -: 846: } + -: 847: } + -: 848: + -: 849: else { + 646818: 850: if (state->deckCount[nextPlayer] == 0) { +branch 0 taken 12% (fallthrough) +branch 1 taken 88% + 235240: 851: for (i = 0; i < state->discardCount[nextPlayer]; i++) { +branch 0 taken 67% +branch 1 taken 33% (fallthrough) + 156829: 852: state->deck[nextPlayer][i] = state->discard[nextPlayer][i];//Move to deck + 156829: 853: state->deckCount[nextPlayer]++; + 156829: 854: state->discard[nextPlayer][i] = -1; + 156829: 855: state->discardCount[nextPlayer]--; + -: 856: } + -: 857: + 78411: 858: shuffle(nextPlayer,state);//Shuffle the deck +call 0 returned 100% + -: 859: } + 646818: 860: tributeRevealedCards[0] = state->deck[nextPlayer][state->deckCount[nextPlayer]-1]; + 646818: 861: state->deck[nextPlayer][state->deckCount[nextPlayer]--] = -1; + 646818: 862: state->deckCount[nextPlayer]--; + 646818: 863: tributeRevealedCards[1] = state->deck[nextPlayer][state->deckCount[nextPlayer]-1]; + 646818: 864: state->deck[nextPlayer][state->deckCount[nextPlayer]--] = -1; + 646818: 865: state->deckCount[nextPlayer]--; + -: 866: } + -: 867: + 705810: 868: if (tributeRevealedCards[0] == tributeRevealedCards[1]) { //If we have a duplicate card, just drop one +branch 0 taken 7% (fallthrough) +branch 1 taken 93% + 46711: 869: state->playedCards[state->playedCardCount] = tributeRevealedCards[1]; + 46711: 870: state->playedCardCount++; + 46711: 871: tributeRevealedCards[1] = -1; + -: 872: } + -: 873: + 2823240: 874: for (i = 0; i <= 2; i ++) { +branch 0 taken 75% +branch 1 taken 25% (fallthrough) + 2117430: 875: if (tributeRevealedCards[i] == copper || tributeRevealedCards[i] == silver || tributeRevealedCards[i] == gold) { //Treasure cards +branch 0 taken 97% (fallthrough) +branch 1 taken 3% +branch 2 taken 96% (fallthrough) +branch 3 taken 4% +branch 4 taken 4% (fallthrough) +branch 5 taken 96% + 216627: 876: state->numActions = state->numActions + 2; + -: 877: } + -: 878: + 1900803: 879: else if (tributeRevealedCards[i] == estate || tributeRevealedCards[i] == duchy || tributeRevealedCards[i] == province || tributeRevealedCards[i] == gardens || tributeRevealedCards[i] == great_hall) { //Victory Card Found +branch 0 taken 96% (fallthrough) +branch 1 taken 4% +branch 2 taken 96% (fallthrough) +branch 3 taken 4% +branch 4 taken 56% (fallthrough) +branch 5 taken 44% +branch 6 taken 93% (fallthrough) +branch 7 taken 7% +branch 8 taken 0% (fallthrough) +branch 9 taken 100% + 994638: 880: drawCard(currentPlayer, state); +call 0 returned 100% + -: 881: //drawCard(currentPlayer, state); + -: 882: } + -: 883: else { //Action Card + 906165: 884: state->coins += 2; + -: 885: } + -: 886: } + 705810: 887:} + -: 888: +function doAmbassador called 0 returned 0% blocks executed 0% + #####: 889:int doAmbassador(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) + -: 890:{ + -: 891: int i; + -: 892: int j; + -: 893: + #####: 894: j = 0; //used to check if player has enough cards to discard + -: 895: + #####: 896: if (choice2 > 3 || choice2 < 0) +branch 0 never executed +branch 1 never executed +branch 2 never executed +branch 3 never executed + -: 897: { + #####: 898: return -1; + -: 899: } + -: 900: + -: 901:/* + -: 902: if (choice1 == handPos) + -: 903: { + -: 904: return -1; + -: 905: } + -: 906: */ + -: 907: + #####: 908: for (i = 0; i < state->handCount[currentPlayer]; i++) +branch 0 never executed +branch 1 never executed + -: 909: { + #####: 910: if (i != handPos && i == state->hand[currentPlayer][choice1] && i != choice1) +branch 0 never executed +branch 1 never executed +branch 2 never executed +branch 3 never executed +branch 4 never executed +branch 5 never executed + -: 911: { + #####: 912: j++; + -: 913: } + -: 914: } + #####: 915: if (j < choice2) +branch 0 never executed +branch 1 never executed + -: 916: { + #####: 917: return -1; + -: 918: } + -: 919: + -: 920: if (DEBUG) + -: 921: printf("Player %d reveals card number: %d\n", currentPlayer, state->hand[currentPlayer][choice1]); + -: 922: + -: 923: //increase supply count for choosen card by amount being discarded + #####: 924: state->supplyCount[state->hand[currentPlayer][choice1]] += choice2; + -: 925: + -: 926: //each other player gains a copy of revealed card + #####: 927: for (i = 0; i < state->numPlayers; i++) +branch 0 never executed +branch 1 never executed + -: 928: { + #####: 929: if (i != currentPlayer) +branch 0 never executed +branch 1 never executed + -: 930: { + #####: 931: gainCard(state->hand[currentPlayer][choice1], state, 0, i); +call 0 never executed + -: 932: } + -: 933: } + -: 934: + -: 935: //discard played card from hand + #####: 936: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + -: 937: + -: 938: //trash copies of cards returned to supply + #####: 939: for (j = 0; j < choice2; j++) +branch 0 never executed +branch 1 never executed + -: 940: { + #####: 941: for (i = 0; i < state->handCount[currentPlayer]; i++) +branch 0 never executed +branch 1 never executed + -: 942: { + #####: 943: if (state->hand[currentPlayer][i] == state->hand[currentPlayer][choice1]) +branch 0 never executed +branch 1 never executed + -: 944: { + #####: 945: discardCard(i, currentPlayer, state, 1); +call 0 never executed + #####: 946: break; + -: 947: } + -: 948: } + -: 949: } + -: 950: + #####: 951: return 0; + -: 952:} + -: 953: +function cardEffect called 0 returned 0% blocks executed 0% + #####: 954:int cardEffect(int card, int choice1, int choice2, int choice3, struct gameState *state, int handPos, int *bonus) + -: 955:{ + -: 956: int i; + -: 957: int j; + -: 958: int k; + -: 959: int x; + -: 960: int index; + #####: 961: int currentPlayer = whoseTurn(state); +call 0 never executed + #####: 962: int nextPlayer = currentPlayer + 1; + -: 963: + #####: 964: int tributeRevealedCards[2] = {-1, -1}; + -: 965: int temphand[MAX_HAND];// moved above the if statement + #####: 966: int drawntreasure=0; + -: 967: int cardDrawn; + #####: 968: int z = 0;// this is the counter for the temp hand + #####: 969: if (nextPlayer > (state->numPlayers - 1)) { +branch 0 never executed +branch 1 never executed + #####: 970: nextPlayer = 0; + -: 971: } + -: 972: + -: 973: + -: 974: //uses switch to select card and perform actions + #####: 975: switch( card ) +branch 0 never executed +branch 1 never executed +branch 2 never executed +branch 3 never executed +branch 4 never executed +branch 5 never executed +branch 6 never executed +branch 7 never executed +branch 8 never executed +branch 9 never executed +branch 10 never executed +branch 11 never executed +branch 12 never executed +branch 13 never executed +branch 14 never executed +branch 15 never executed +branch 16 never executed +branch 17 never executed +branch 18 never executed +branch 19 never executed +branch 20 never executed + -: 976: { + -: 977: case adventurer: + #####: 978: while(drawntreasure<2) { +branch 0 never executed +branch 1 never executed + #####: 979: if (state->deckCount[currentPlayer] <1) { //if the deck is empty we need to shuffle discard and add to deck +branch 0 never executed +branch 1 never executed + #####: 980: shuffle(currentPlayer, state); +call 0 never executed + -: 981: } + #####: 982: drawCard(currentPlayer, state); +call 0 never executed + #####: 983: cardDrawn = state->hand[currentPlayer][state->handCount[currentPlayer]-1];//top card of hand is most recently drawn card. + #####: 984: if (cardDrawn == copper || cardDrawn == silver || cardDrawn == gold) +branch 0 never executed +branch 1 never executed +branch 2 never executed +branch 3 never executed +branch 4 never executed +branch 5 never executed + #####: 985: drawntreasure++; + -: 986: else { + #####: 987: temphand[z]=cardDrawn; + #####: 988: state->handCount[currentPlayer]--; //this should just remove the top card (the most recently drawn one). + #####: 989: z++; + -: 990: } + -: 991: } + #####: 992: while(z-1>=0) { +branch 0 never executed +branch 1 never executed + #####: 993: state->discard[currentPlayer][state->discardCount[currentPlayer]++]=temphand[z-1]; // discard all cards in play that have been drawn + #####: 994: z=z-1; + -: 995: } + #####: 996: return 0; + -: 997: + -: 998: case council_room: + -: 999: //+4 Cards + #####: 1000: for (i = 0; i < 4; i++) +branch 0 never executed +branch 1 never executed + -: 1001: { + #####: 1002: drawCard(currentPlayer, state); +call 0 never executed + -: 1003: } + -: 1004: + -: 1005: //+1 Buy + #####: 1006: state->numBuys++; + -: 1007: + -: 1008: //Each other player draws a card + #####: 1009: for (i = 0; i < state->numPlayers; i++) +branch 0 never executed +branch 1 never executed + -: 1010: { + #####: 1011: if ( i != currentPlayer ) +branch 0 never executed +branch 1 never executed + -: 1012: { + #####: 1013: drawCard(i, state); +call 0 never executed + -: 1014: } + -: 1015: } + -: 1016: + -: 1017: //put played card in played card pile + #####: 1018: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + -: 1019: + #####: 1020: return 0; + -: 1021: + -: 1022: case feast: + -: 1023: //gain card with cost up to 5 + -: 1024: //Backup hand + #####: 1025: for (i = 0; i <= state->handCount[currentPlayer]; i++) { +branch 0 never executed +branch 1 never executed + #####: 1026: temphand[i] = state->hand[currentPlayer][i];//Backup card + #####: 1027: state->hand[currentPlayer][i] = -1;//Set to nothing + -: 1028: } + -: 1029: //Backup hand + -: 1030: + -: 1031: //Update Coins for Buy + #####: 1032: updateCoins(currentPlayer, state, 5); +call 0 never executed + #####: 1033: x = 1;//Condition to loop on + #####: 1034: while( x == 1) {//Buy one card +branch 0 never executed +branch 1 never executed + #####: 1035: if (supplyCount(choice1, state) <= 0) { +call 0 never executed +branch 1 never executed +branch 2 never executed + -: 1036: if (DEBUG) + -: 1037: printf("None of that card left, sorry!\n"); + -: 1038: + -: 1039: if (DEBUG) { + -: 1040: printf("Cards Left: %d\n", supplyCount(choice1, state)); + -: 1041: } + -: 1042: } + #####: 1043: else if (state->coins < getCost(choice1)) { +call 0 never executed +branch 1 never executed +branch 2 never executed + #####: 1044: printf("That card is too expensive!\n"); +call 0 never executed + -: 1045: + -: 1046: if (DEBUG) { + -: 1047: printf("Coins: %d < %d\n", state->coins, getCost(choice1)); + -: 1048: } + -: 1049: } + -: 1050: else { + -: 1051: + -: 1052: if (DEBUG) { + -: 1053: printf("Deck Count: %d\n", state->handCount[currentPlayer] + state->deckCount[currentPlayer] + state->discardCount[currentPlayer]); + -: 1054: } + -: 1055: + #####: 1056: gainCard(choice1, state, 0, currentPlayer);//Gain the card +call 0 never executed + #####: 1057: x = 0;//No more buying cards + -: 1058: + -: 1059: if (DEBUG) { + -: 1060: printf("Deck Count: %d\n", state->handCount[currentPlayer] + state->deckCount[currentPlayer] + state->discardCount[currentPlayer]); + -: 1061: } + -: 1062: + -: 1063: } + -: 1064: } + -: 1065: + -: 1066: //Reset Hand + #####: 1067: for (i = 0; i <= state->handCount[currentPlayer]; i++) { +branch 0 never executed +branch 1 never executed + #####: 1068: state->hand[currentPlayer][i] = temphand[i]; + #####: 1069: temphand[i] = -1; + -: 1070: } + -: 1071: //Reset Hand + -: 1072: + #####: 1073: return 0; + -: 1074: + -: 1075: case gardens: + #####: 1076: return -1; + -: 1077: + -: 1078: case mine: + #####: 1079: return doMine(choice1, choice2, state, handPos, currentPlayer); +call 0 never executed + -: 1080: + -: 1081: case remodel: + #####: 1082: j = state->hand[currentPlayer][choice1]; //store card we will trash + -: 1083: + #####: 1084: if ( (getCost(state->hand[currentPlayer][choice1]) + 2) > getCost(choice2) ) +call 0 never executed +call 1 never executed +branch 2 never executed +branch 3 never executed + -: 1085: { + #####: 1086: return -1; + -: 1087: } + -: 1088: + #####: 1089: gainCard(choice2, state, 0, currentPlayer); +call 0 never executed + -: 1090: + -: 1091: //discard card from hand + #####: 1092: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + -: 1093: + -: 1094: //discard trashed card + #####: 1095: for (i = 0; i < state->handCount[currentPlayer]; i++) +branch 0 never executed +branch 1 never executed + -: 1096: { + #####: 1097: if (state->hand[currentPlayer][i] == j) +branch 0 never executed +branch 1 never executed + -: 1098: { + #####: 1099: discardCard(i, currentPlayer, state, 0); +call 0 never executed + #####: 1100: break; + -: 1101: } + -: 1102: } + -: 1103: + -: 1104: + #####: 1105: return 0; + -: 1106: + -: 1107: case smithy: + -: 1108: //+3 Cards + #####: 1109: for (i = 0; i < 3; i++) +branch 0 never executed +branch 1 never executed + -: 1110: { + #####: 1111: drawCard(currentPlayer, state); +call 0 never executed + -: 1112: } + -: 1113: + -: 1114: //discard card from hand + #####: 1115: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + #####: 1116: return 0; + -: 1117: + -: 1118: case village: + -: 1119: //+1 Card + #####: 1120: drawCard(currentPlayer, state); +call 0 never executed + -: 1121: + -: 1122: //+2 Actions + #####: 1123: state->numActions = state->numActions + 2; + -: 1124: + -: 1125: //discard played card from hand + #####: 1126: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + #####: 1127: return 0; + -: 1128: + -: 1129: case baron: + #####: 1130: doBaron(choice1, state, currentPlayer); +call 0 never executed + #####: 1131: return 0; + -: 1132: + -: 1133: case great_hall: + -: 1134: //+1 Card + #####: 1135: drawCard(currentPlayer, state); +call 0 never executed + -: 1136: + -: 1137: //+1 Actions + #####: 1138: state->numActions++; + -: 1139: + -: 1140: //discard card from hand + #####: 1141: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + #####: 1142: return 0; + -: 1143: + -: 1144: case minion: + #####: 1145: doMinion(choice1, choice2, state, handPos, currentPlayer); +call 0 never executed + #####: 1146: return 0; + -: 1147: + -: 1148: case steward: + #####: 1149: if (choice1 == 1) +branch 0 never executed +branch 1 never executed + -: 1150: { + -: 1151: //+2 cards + #####: 1152: drawCard(currentPlayer, state); +call 0 never executed + #####: 1153: drawCard(currentPlayer, state); +call 0 never executed + -: 1154: } + #####: 1155: else if (choice1 == 2) +branch 0 never executed +branch 1 never executed + -: 1156: { + -: 1157: //+2 coins + #####: 1158: state->coins = state->coins + 2; + -: 1159: } + -: 1160: else + -: 1161: { + -: 1162: //trash 2 cards in hand + #####: 1163: discardCard(choice2, currentPlayer, state, 1); +call 0 never executed + #####: 1164: discardCard(choice3, currentPlayer, state, 1); +call 0 never executed + -: 1165: } + -: 1166: + -: 1167: //discard card from hand + #####: 1168: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + #####: 1169: return 0; + -: 1170: + -: 1171: case tribute: + #####: 1172: doTribute(state, currentPlayer, nextPlayer, tributeRevealedCards); +call 0 never executed + #####: 1173: return 0; + -: 1174: + -: 1175: case ambassador: + #####: 1176: return doAmbassador(choice1, choice2, state, handPos, currentPlayer); +call 0 never executed + -: 1177: + -: 1178: case cutpurse: + -: 1179: + #####: 1180: updateCoins(currentPlayer, state, 2); +call 0 never executed + #####: 1181: for (i = 0; i < state->numPlayers; i++) +branch 0 never executed +branch 1 never executed + -: 1182: { + #####: 1183: if (i != currentPlayer) +branch 0 never executed +branch 1 never executed + -: 1184: { + #####: 1185: for (j = 0; j < state->handCount[i]; j++) +branch 0 never executed +branch 1 never executed + -: 1186: { + #####: 1187: if (state->hand[i][j] == copper) +branch 0 never executed +branch 1 never executed + -: 1188: { + #####: 1189: discardCard(j, i, state, 0); +call 0 never executed + #####: 1190: break; + -: 1191: } + #####: 1192: if (j == state->handCount[i]) +branch 0 never executed +branch 1 never executed + -: 1193: { + #####: 1194: for (k = 0; k < state->handCount[i]; k++) +branch 0 never executed +branch 1 never executed + -: 1195: { + -: 1196: if (DEBUG) + -: 1197: printf("Player %d reveals card number %d\n", i, state->hand[i][k]); + -: 1198: } + #####: 1199: break; + -: 1200: } + -: 1201: } + -: 1202: + -: 1203: } + -: 1204: + -: 1205: } + -: 1206: + -: 1207: //discard played card from hand + #####: 1208: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + -: 1209: + #####: 1210: return 0; + -: 1211: + -: 1212: + -: 1213: case embargo: + -: 1214: //+2 Coins + #####: 1215: state->coins = state->coins + 2; + -: 1216: + -: 1217: //see if selected pile is in play + #####: 1218: if ( state->supplyCount[choice1] == -1 ) +branch 0 never executed +branch 1 never executed + -: 1219: { + #####: 1220: return -1; + -: 1221: } + -: 1222: + -: 1223: //add embargo token to selected supply pile + #####: 1224: state->embargoTokens[choice1]++; + -: 1225: + -: 1226: //trash card + #####: 1227: discardCard(handPos, currentPlayer, state, 1); +call 0 never executed + #####: 1228: return 0; + -: 1229: + -: 1230: case outpost: + -: 1231: //set outpost flag + #####: 1232: state->outpostPlayed++; + -: 1233: + -: 1234: //discard card + #####: 1235: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + #####: 1236: return 0; + -: 1237: + -: 1238: case salvager: + -: 1239: //+1 buy + #####: 1240: state->numBuys++; + -: 1241: + #####: 1242: if (choice1) +branch 0 never executed +branch 1 never executed + -: 1243: { + -: 1244: //gain coins equal to trashed card + #####: 1245: state->coins = state->coins + getCost( handCard(choice1, state) ); +call 0 never executed +call 1 never executed + -: 1246: //trash card + #####: 1247: discardCard(choice1, currentPlayer, state, 1); +call 0 never executed + -: 1248: } + -: 1249: + -: 1250: //discard card + #####: 1251: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + #####: 1252: return 0; + -: 1253: + -: 1254: case sea_hag: + #####: 1255: for (i = 0; i < state->numPlayers; i++) { +branch 0 never executed +branch 1 never executed + #####: 1256: if (i != currentPlayer) { +branch 0 never executed +branch 1 never executed + #####: 1257: state->discard[i][state->discardCount[i]] = state->deck[i][state->deckCount[i]--]; + #####: 1258: state->deckCount[i]--; + #####: 1259: state->discardCount[i]++; + #####: 1260: state->deck[i][state->deckCount[i]--] = curse;//Top card now a curse + -: 1261: } + -: 1262: } + #####: 1263: return 0; + -: 1264: + -: 1265: case treasure_map: + -: 1266: //search hand for another treasure_map + #####: 1267: index = -1; + #####: 1268: for (i = 0; i < state->handCount[currentPlayer]; i++) +branch 0 never executed +branch 1 never executed + -: 1269: { + #####: 1270: if (state->hand[currentPlayer][i] == treasure_map && i != handPos) +branch 0 never executed +branch 1 never executed +branch 2 never executed +branch 3 never executed + -: 1271: { + #####: 1272: index = i; + #####: 1273: break; + -: 1274: } + -: 1275: } + #####: 1276: if (index > -1) +branch 0 never executed +branch 1 never executed + -: 1277: { + -: 1278: //trash both treasure cards + #####: 1279: discardCard(handPos, currentPlayer, state, 1); +call 0 never executed + #####: 1280: discardCard(index, currentPlayer, state, 1); +call 0 never executed + -: 1281: + -: 1282: //gain 4 Gold cards + #####: 1283: for (i = 0; i < 4; i++) +branch 0 never executed +branch 1 never executed + -: 1284: { + #####: 1285: gainCard(gold, state, 1, currentPlayer); +call 0 never executed + -: 1286: } + -: 1287: + -: 1288: //return success + #####: 1289: return 1; + -: 1290: } + -: 1291: + -: 1292: //no second treasure_map found in hand + #####: 1293: return -1; + -: 1294: } + -: 1295: + #####: 1296: return -1; + -: 1297:} + -: 1298: +function discardCard called 4343683 returned 100% blocks executed 100% + 4343683: 1299:int discardCard(int handPos, int currentPlayer, struct gameState *state, int trashFlag) + -: 1300:{ + -: 1301: + -: 1302: //if card is not trashed, added to Played pile + 4343683: 1303: if (trashFlag < 1) +branch 0 taken 100% (fallthrough) +branch 1 taken 0% + -: 1304: { + -: 1305: //add card to played pile + 4343683: 1306: state->playedCards[state->playedCardCount] = state->hand[currentPlayer][handPos]; + 4343683: 1307: state->playedCardCount++; + -: 1308: } + -: 1309: + -: 1310: //set played card to -1 + 4343683: 1311: state->hand[currentPlayer][handPos] = -1; + -: 1312: + -: 1313: //remove card from player's hand + 4343683: 1314: if ( handPos == (state->handCount[currentPlayer] - 1) ) //last card in hand array is played +branch 0 taken 17% (fallthrough) +branch 1 taken 83% + -: 1315: { + -: 1316: //reduce number of cards in hand + 739365: 1317: state->handCount[currentPlayer]--; + -: 1318: } + 3604318: 1319: else if ( state->handCount[currentPlayer] == 1 ) //only one card in hand +branch 0 taken 16% (fallthrough) +branch 1 taken 84% + -: 1320: { + -: 1321: //reduce number of cards in hand + 575003: 1322: state->handCount[currentPlayer]--; + -: 1323: } + -: 1324: else + -: 1325: { + -: 1326: //replace discarded card with last card in hand + 3029315: 1327: state->hand[currentPlayer][handPos] = state->hand[currentPlayer][ (state->handCount[currentPlayer] - 1)]; + -: 1328: //set last card to -1 + 3029315: 1329: state->hand[currentPlayer][state->handCount[currentPlayer] - 1] = -1; + -: 1330: //reduce number of cards in hand + 3029315: 1331: state->handCount[currentPlayer]--; + -: 1332: } + -: 1333: + 4343683: 1334: return 0; + -: 1335:} + -: 1336: +function gainCard called 556409 returned 100% blocks executed 70% + 556409: 1337:int gainCard(int supplyPos, struct gameState *state, int toFlag, int player) + -: 1338:{ + -: 1339: //Note: supplyPos is enum of choosen card + -: 1340: + -: 1341: //check if supply pile is empty (0) or card is not used in game (-1) + 556409: 1342: if ( supplyCount(supplyPos, state) < 1 ) +call 0 returned 100% +branch 1 taken 0% (fallthrough) +branch 2 taken 100% + -: 1343: { + #####: 1344: return -1; + -: 1345: } + -: 1346: + -: 1347: //added card for [whoseTurn] current player: + -: 1348: // toFlag = 0 : add to discard + -: 1349: // toFlag = 1 : add to deck + -: 1350: // toFlag = 2 : add to hand + -: 1351: + 556409: 1352: if (toFlag == 1) +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + -: 1353: { + #####: 1354: state->deck[ player ][ state->deckCount[player] ] = supplyPos; + #####: 1355: state->deckCount[player]++; + -: 1356: } + 556409: 1357: else if (toFlag == 2) +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + -: 1358: { + #####: 1359: state->hand[ player ][ state->handCount[player] ] = supplyPos; + #####: 1360: state->handCount[player]++; + -: 1361: } + -: 1362: else + -: 1363: { + 556409: 1364: state->discard[player][ state->discardCount[player] ] = supplyPos; + 556409: 1365: state->discardCount[player]++; + -: 1366: } + -: 1367: + -: 1368: //decrease number in supply pile + 556409: 1369: state->supplyCount[supplyPos]--; + -: 1370: + 556409: 1371: return 0; + -: 1372:} + -: 1373: +function updateCoins called 4147100 returned 100% blocks executed 100% + 4147100: 1374:int updateCoins(int player, struct gameState *state, int bonus) + -: 1375:{ + -: 1376: int i; + -: 1377: + -: 1378: //reset coin count + 4147100: 1379: state->coins = 0; + -: 1380: + -: 1381: //add coins for each Treasure card in player's hand + 18253150: 1382: for (i = 0; i < state->handCount[player]; i++) +branch 0 taken 77% +branch 1 taken 23% (fallthrough) + -: 1383: { + 14106050: 1384: if (state->hand[player][i] == copper) +branch 0 taken 45% (fallthrough) +branch 1 taken 55% + -: 1385: { + 6412512: 1386: state->coins += 1; + -: 1387: } + 7693538: 1388: else if (state->hand[player][i] == silver) +branch 0 taken 2% (fallthrough) +branch 1 taken 98% + -: 1389: { + 191917: 1390: state->coins += 2; + -: 1391: } + 7501621: 1392: else if (state->hand[player][i] == gold) +branch 0 taken 3% (fallthrough) +branch 1 taken 97% + -: 1393: { + 192262: 1394: state->coins += 3; + -: 1395: } + -: 1396: } + -: 1397: + -: 1398: //add bonus + 4147100: 1399: state->coins += bonus; + -: 1400: + 4147100: 1401: return 0; + -: 1402:} + -: 1403: + -: 1404: + -: 1405://end of dominion.c diff --git a/projects/alghanmz/a4/dominion.gcda b/projects/alghanmz/a4/dominion.gcda new file mode 100644 index 0000000000000000000000000000000000000000..515b2ab339e379017450699dad5a9e4797f0fae4 GIT binary patch literal 5688 zcmeHL4OGro7{9L)CA^3t9~}#o<})E`l#g18i6U}TiWH-bqMA9ajdH8gB&bBdGL`CB4eMd))u#l$kqrU|3v5mvpy1pX3o8qP0>IjTFbseT;**Cdkp9m zCn)QcPO{H5+9>E7Q>zid)i-dAEo9%IT#*qwl@-)yN2@j?df9=BV>FUnc?c{B5q_v0 zA$qTS7*PA&6i5gG?og8AB0IMtu8pkAstu`q+s}~@)+>`K96AKYb{Km}&Y>T|Bt)7= zA94y+_9_$N7%}hUUrmXd-?bYdxYCo#*WTND5C`49hgIYl!G%Y6rEx}hemqs_B>I)o z7~~HB@B+0NvFgfz!NfTYwSfr5AkWT?xT*b;3E@ls3p1$wb}lkR$$ga{MD5t9B0?Cj ziCIo^RiT4Np8>S@x(Dg*WhwzdLa8^-=l{Ffr#l9#4$q7 zE&T(sGfpJqk)dRy%WBC2$K<_I33?ZEhxf-oSzIRBVrdg5c$^Uy{2f)EExWHJ zIb=l49hGMl=4Lb*D(!ZaQ;Y~i?oy>QWoHoS!i(DK&eV1~Hg9Q=1W-!_5lf7{LWrRT0Ms&gYuSbw>CcTH%2qF@1cpF3+xRdzBstBLo)i z|DHHTaE7})X@g*d&m$9^$d0MuW%Xjqe9V{psWtZo9FR)TGd`GVD?wDfl0dSIDj&7o z*48g;HXlbpS+6|l-Wunn4AyN@hy|HttM-a=tVsF1M1@l@A{f!e%Av3c6dGFF)_F>Y z5%v~atMR}B6%t6SPEp(`dzJIB#BD|dXKt9v@4g*I$es`u^1ow|%I};NEyw}bJ5bgZ z!(!ofOG0p4W~!W@?V;fSg-&2VZ<#6IZFuLOr!DCF7+uRgz$PBUurW#cjl$J#03xgknEwd zE?P|-BRICr2(FLz63H=wt2)*jphM)mrJvewi*uqW{~+*VZ2&zGMsU;Ii-}_d*ZL0! zxT!W2> zfXpz@y4X*>yfU_GR~?YSP177Fspr-62t1F#V?==7VeHwvi%U0qow(8k?~v7FDERjS8i_vki73nkbIVVZ-RR&K)7@HUxN7^rfuQ-it>#?f};T(gV zUEa&$6>`7shUzo&{f?34`0mDcN50=N@?DWpPDMW9ws>KXQ|UVA8K>bBPS=9p=!npL zd-1mwBY#8jcMyMPu^!vTsk}RM!I8qBPCkHbM2+|Mzd|XhU&vqFm#VYYT;H)OZ!v5l zrq8g@oE_x^C1>iL632uWU`}Ds(sP8PKRggIRP8ESNscwe8IQbcLNIC%-vj5;fuW3{GSS~5%1Zpl>Q}q1B2zy zFpqv_%`Bd5;5P12ke_Q|KhOm>VDkwI*~I12Y-yqK)oTG2u!)T(;R?~U;Hy1fX^Wwy)E)3G#eK{u<^Qs+Ck`EV>#f{T4FSD$vEU$x6 zijXY6jusVo4-SiWJqNq$>*Zmif1^jXacNJ|o{PHfqB#oN*r%Rip*e8+B(E12uZ-Ie z$))km60RuLO} zQKCfOpGDs&rlINwM8=XNwKH{Tz)NO0*@SQ@>`sUM5nDUzFX>rFxaXVe*xE$ii#9k? zghfd-eaL)~qvTD!H&H*OY7T~Vh5P!LH^G-;U^G;2E3z;)vmS~8gnN9}eM-}uBt=z` q3>=8*>oeg|GFY58FTCcKdzSnFOVc1H`1?O|a4fC;n8r+(&VK@-U=5@I literal 0 HcmV?d00001 diff --git a/projects/alghanmz/a4/dominion.gcno b/projects/alghanmz/a4/dominion.gcno new file mode 100644 index 0000000000000000000000000000000000000000..d2c549165199836c29bd476271e3a270240c5c26 GIT binary patch literal 40596 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 mOn9tQmPF-0XQ_H~9>By|j^`iK+47W literal 0 HcmV?d00001 diff --git a/projects/alghanmz/a4/dominion_helpers.h b/projects/alghanmz/a4/dominion_helpers.h new file mode 100644 index 000000000..0887fda15 --- /dev/null +++ b/projects/alghanmz/a4/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/alghanmz/a4/interface.c b/projects/alghanmz/a4/interface.c new file mode 100644 index 000000000..58cc5ba58 --- /dev/null +++ b/projects/alghanmz/a4/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/alghanmz/a4/interface.h b/projects/alghanmz/a4/interface.h new file mode 100644 index 000000000..6f7bacac2 --- /dev/null +++ b/projects/alghanmz/a4/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/alghanmz/a4/playdom.c b/projects/alghanmz/a4/playdom.c new file mode 100644 index 000000000..336d9a661 --- /dev/null +++ b/projects/alghanmz/a4/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/alghanmz/a4/player.c b/projects/alghanmz/a4/player.c new file mode 100644 index 000000000..0a169d126 --- /dev/null +++ b/projects/alghanmz/a4/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/alghanmz/a4/randomtestcard1 b/projects/alghanmz/a4/randomtestcard1 new file mode 100644 index 0000000000000000000000000000000000000000..658665dc1856def5b144a6b86088e37b4aea127d GIT binary patch literal 62256 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 literal 0 HcmV?d00001 diff --git a/projects/alghanmz/a4/randomtestcard1.gcda b/projects/alghanmz/a4/randomtestcard1.gcda new file mode 100644 index 0000000000000000000000000000000000000000..189119319eeeec91a8c92aff6fbbc29d58fdfad8 GIT binary patch literal 1264 zcmah|Ur5tY6h6N#Q)dJt_pqRXWNlbrvLPnEg!y0(1xC4-gw<4HBO*kN6tRb(D1$ZV zL5Vba$Y^7OKn+?TJt&O9WcbizL=U~lkYEWy)BBz4squT+WxL-w-}!UT@7!|(!P`T< z?dN^(-<4;G=xsu6&sS^1NrOoJXt3PqQb0!kZcQax4XRVRZ=z80orA%&IuLAH$CNHK zWGv|QEd57tdk37LMd{X@Cc_Il3-*mpEek?R1~eylSaG=lWFQJH9c6?z++$_=Sri^b z;Fg|h?!KdzxdyebZyjQ})Yry{?1c!o;~#>PJc6eb=X0Y?L~}hZE(%+6(#D)1&b_*Q zgt;N-aYk^Nw668^n-k0-_Do85P7qvZ%*l2^RKE6F$2{)Kunm5xA5AO^;;RccTbb+d zdf>u6SZ?lOuGbx5L@j6YewLpsVnVdvm(RCY9v}V2hy&vo3RXaui=gR1MAXUw`X!%qV`< zzPFkkEkjRniZksmeoWr+qNlhRd22H7od-RT7{uMZc%db~xfquiMe&k)rA|fiIp{*- ikNwe3?6LzfI9J|;ych9B?R$TJ1uA{7W%c{1$V>Z@=c0B1 literal 0 HcmV?d00001 diff --git a/projects/alghanmz/a4/randomtestcard1.gcno b/projects/alghanmz/a4/randomtestcard1.gcno new file mode 100644 index 0000000000000000000000000000000000000000..975deb27e9fde5efdeb610e0204c07b7544ad0cc GIT binary patch literal 5328 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 literal 0 HcmV?d00001 diff --git a/projects/alghanmz/a4/randomtestcard2.gcno b/projects/alghanmz/a4/randomtestcard2.gcno new file mode 100644 index 0000000000000000000000000000000000000000..c6b256665b6d7e8abb4cbfd1dfdde19349c7535d GIT binary patch literal 4968 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

D=0~K@tRkzldql$kO} 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 GiNSw%Pd_&R literal 0 HcmV?d00001 diff --git a/projects/alghanmz/a4/randomtestcard3.gcda b/projects/alghanmz/a4/randomtestcard3.gcda new file mode 100644 index 0000000000000000000000000000000000000000..b8dbfa83b5588431ac354db72f36c297112ca346 GIT binary patch literal 1328 zcma)*O-Phc6o&7NH91mYWiUCEQ6?1;QDX>E(87>@Ab&873MaLif(Rl~q8}H5o1le6 zVJS^uwde=M4BE7rQV3gEM350u1GR}D2nw_NzQ=cvp#d+$_nh;7=bU@Kd+x-Wn~v60 zY>35r|8_a&?mY94k&fT%2LjIdp9>Fmukmo{>dT?&%nP`D=L(CjOrF_#057uE79?k_ zMc$VT8;g6G>B3WlHaTUBLGPd6ZQ{gr<1CM&KC|22BEssON}DF;dABueJ12I)v$$K$ zmLsCx$x?eCe?FISh-mLLZDidXYN#Yz#Njk1{E_%owxEKH_~*h@0qy>_AR9ovfzf%? zj^B-v&~7%&r+uhuDT&~gfx5SnF zX#W_!zmzmzclc8ok0f(1vwhtqQFU^0rst6>&Nt1o#!$NU4#pq!B{t!#IS~7#|2>(5 zFL|@F$9))k`barvpIEr4zP-vE%sbU_VeHq#or{r!eQTp7OwxZ!vFN$;`^9V1V^vQ? F;y-Rfmq-8r literal 0 HcmV?d00001 diff --git a/projects/alghanmz/a4/randomtestcard3.gcno b/projects/alghanmz/a4/randomtestcard3.gcno new file mode 100644 index 0000000000000000000000000000000000000000..ec10ff0443a711cc71c0fb7a8bfca0d790089029 GIT binary patch literal 6336 zcmd^@TWeia5XaAs+Inlfw%U42O={F$tR~iag%AQ#>!lSGRMcY{YNbguNky%;ML`8Y zQERF6!8hO3;!FJk>KE|Qeg+?X6X$pSGs)^^4JY7(f&(*at(p0+nYH#hd(A#`vr`B5 z?b7R&1HYU(((GOJ>wxuVx(8>i>FMXYv-{^}7N-{$r@Hg|N4HOz z{!WaY@#djk`+pM?%>}+>_Ugi3f1>H_q4lw$YrNm-$QJsV4ITKJ4gD&&mvb^7`n!$6 zMV!^vyV$rk7y3&Q8~RI)iPw&UKF&$Rxy*EzC;sU1FY{sy23l)e+8AHqx-vGopuaM) zp}#7zp}*R=wjT8B+!pJ(#>Uqs{^;>9b7l+%T5n7o=Hj_9-e4R$+Utz3cU`$g{L$lI z&d(SOw9&YzC zjqfm~&$}(=XN-QEG5vC`@ZDm1VsAATX-@Ruu(fgc)@0Edk8y2X=y{JoqsC=C#$&E)&x!ut#D;!nVncslVne?xv7x^|v7vv!xV=91 z82y9Bu`YCsSr6RlOg8+!dA~!{9u0??4%5ugoqd zn>E(sK7umLKC?Y-{0vS@q;EAH7W)~gi^cQ%w^+Hp9y8+(Wx^P1TY8PB+%8s*5n4rTG?WOgYG z_dS$hUYFUWFw_H3hMAYyr7+Y9P=;BM*`+Yl5m1JCQ)ZVse}g{CFmIXtZTC^5SeyFb z-l<@yS)eS|5t&^o&XA8X%)1rLa39Qj70l*7n4=X8H4&8Mc1&iMTF;1&GR*M`ChC+7 z^L_)zz9K^t3StKJ7Ue zGY_=d7@zQGOubpo!I(ITrCO2PAh5L>o_!cJj`zKFjr1%cc7`32vrA!=Pabc$g3-Ei zOf5Io4`sQH$Q-hvwq!lO4Sm!3{oGGKkmuCg?4teEw=iMn1;=bI)m8uAS>d^Ak928jlC$awGn6rZcrod5nPpB?dt!}`#d?+Wzj z!av64?|dcCj{M@A$GS! 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/alghanmz/a4/rngs.gcda b/projects/alghanmz/a4/rngs.gcda new file mode 100644 index 0000000000000000000000000000000000000000..d4c1edc67aabd56a12aec9dc821e2ebf9f2394c0 GIT binary patch literal 2632 zcmd5-eN5F=7(N&91N^!g6v!enQT$j@UD2>F6%w?TLP8QaK|VxS*@uNGYecAJTHevB zl_cO4>1(3SYi?0(Y~fT^jLcy{+E^6LXi(DvJJ0j-Ug*{zZS_ZIaGv)(=Y8Mbd*1W> zem5&;O@8vc7+2rkfj5jXH3#jqqiIx8y~7y$XYvMuqbwN5s>>sWqrbz9wrf{Od!K7I zHhe}Lf_=tScC9pQ46Flb4I#KIgPfwDUHi8RSyU%kFrT?yY(=cUXF1n&w8@yN zq$n1Jss5QDa*BBF{XdN*mmfBn2(I~*)H-F)wd4>xtwB1c2(GX=jQfhH{6wY1Y)Nb8 z9{d`a1c;kT&z zRpyB|Zd@5gO|_lYuZ?xTZ-Wr`wP)@uY_ycrGMD0@mYucpf4w6E4nAWptNJq;Y?n&I z#=!cYYWd`NiJlRG>ZPA!4)9oJTZ(9Jg5|$>n#VE)cc;(~QM#{)4C%3=vkkvH=?6t@ z`bBisc1A++PZTtLLRPW498KD_-V=7V4NS+>-K z|5(mFRGXPDn%b2#&g)mUcp>*+dT2vIDdH^~(I++3ovUIj&i3vn#q>)r?;&C% zqo<6vA~@H@HgbyKvN}7-DS}Js60Iwu=DfBfY?&1aZm-V1+w%x7L=g__4u3^X5nRAK zOZkCNM9sHtiDRCz0T<-Owt75n`P17j-+06ZAujM}YVf?f>=;>y1)Lqy1Tl%``*EUzW(lYZEL@e{JfuK zSw36LG|`)%pLTzJpYNP3{i08dfC|c!_i-_mFR47{IkyD80y;3Mz<&j^A=e<@a zTIE?@dfuA^kGw-X@2x^+b7Dd+Jh=Go)3P56SCKzG#gU?~+0z^-G7Yh&o4R7_-MV&FuwHB^PuAxccSyf+;55A7A-|%ieJR9^^QW(Dvz-c&%3LT z*>Jw`_igL)E$=S1jlk_Jnmt8vxYF-J=+PK^E6jo2Pt@tFbJMj_XPpzR72j7yuZcPd zb0c<>F7NBV-Zr`te_hAN&#efZ8oA}9^YMqpiF1P(+df+?d~Vn~2FJMEKN^$j+ekaO z&lhqRzQq*|b?zq0oLBQjKXBd(&*$#3x6u2izrBg|v8nqvk^95Op^dZ1-9y>8F$Zva z_bev86~Y}9JtkU;o*RvS_1p}V zBq_B%hrldY6tHC47~adY4Wlcori+?#To%^?sd7@KW#B=>(5` zMf|vD6pB{Y!5$-?cUGZjmB)S~o>yNlYh~{d&pRje^8p<*;Ws#(jaRxxcYNHuh5hb2 z(mN1t7TG}GzcX}egg#>)eycF?-9g^gbDOz<*Yn;Fs`z`C`-C;h+7sjzO#(5`ZNIiDj1nU;vA-Yp^muM-vzswc!eRnGqt^R(}Iahgm zgt0flO`W-Y!rNctvUdA@;Kx6Z;HA#z!2~aLKI?OYlR9^YD*m$Y1`_8Fqdz;B-dXX5 zIi~(At_l4bxy`Za#@DKO>2nF+>;;(RrtP`m#;0z1>T`*9;^{H!K3{k{7z^QRcOq+8 jFZ!?O2GNb8rL@kKO(jW6%G2?y{x>Ihx}GYp-SK__K>YFy literal 0 HcmV?d00001 diff --git a/projects/alghanmz/a4/rngs.h b/projects/alghanmz/a4/rngs.h new file mode 100644 index 000000000..c9f3f451a --- /dev/null +++ b/projects/alghanmz/a4/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/alghanmz/a4/rngs.o b/projects/alghanmz/a4/rngs.o new file mode 100644 index 0000000000000000000000000000000000000000..6a9e8488b8e9a2c75bdaac18b2282902f224eee0 GIT binary patch literal 11792 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 literal 0 HcmV?d00001 diff --git a/projects/alghanmz/a4/rt.c b/projects/alghanmz/a4/rt.c new file mode 100644 index 000000000..5805bb9b4 --- /dev/null +++ b/projects/alghanmz/a4/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/alghanmz/a4/testdrawcard.c b/projects/alghanmz/a4/testdrawcard.c new file mode 100644 index 000000000..da5379646 --- /dev/null +++ b/projects/alghanmz/a4/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); + +} diff --git a/projects/alghanmz/a4/unittest1 b/projects/alghanmz/a4/unittest1 new file mode 100644 index 0000000000000000000000000000000000000000..9c15748a230146c02fa0f7c390cab954f3e5cbc0 GIT binary patch literal 62248 zcmeFad3=+__CNllZJ=yTQNW6zQ9+B!Qbh#;ZJ~iwiy~0PmDbWi1q!wai&r+&D31?; zs-WQKs$4~{S4Gh)UPO=wi91cT$5{yd?%B8w8872NTj4Ab;mAFAhJ0sIL%{bL)1B?^jOr}sO zAeA;s)hbPve2GYt@Ew#O5Q7pj8Bl2tfi_gCETojm)1OQUinQVhkyWW-xEVomWb2-_ zoJE??fJ)QS1b*hlB2{u^9?2y?C-BM7LWE?BYi|3bgS)NK|b&dYhN^ZGm zVE<{8`c5k;_0Q=$XV67`FB;gdd`7?Xx!$Coct>5C$0aF0x{)KByWmTGfaqh(2X4-r zf79EqSihZf$=VewQ~oo@L$c}%@VGy_!FfU}+!;{T8h!-u?pF9`#L;ta9Q-+P@Fj8Z zxpDB$ICeI~;qMTK-yes6dmMZq4n8f8{v&bt?}>wdJr4e~IQlc<@E?wYr(xS#`*r}{ zjc@bM9YD0kzc~*6>NxnPfIkD@=AXBKXia}z9Q76o-FU z9R5fg{58P0=7;m+@P7<^XM9_HFt1FfY2+ef;>5|*XOvDX_Z5`+CQdYpr_GpAW`JBM z$mPDW!kKf8^0I=`Nk*}+XxcPLl$6gX96Wepd0|0mu`$!{D>r;4(~FFmzA0rz1(POD z_xpZFn~qu`bqWjPMc9)WK1uZ1}rHrDxC$blb{Idiszt4KBIVc zS&6U6C?>m%;+bV7rM_aLc+!lSDEhW?vZ}bS)Hls2C@d^0FE?PyE&gJNlLMqrrWcgJ zoU)=KpbO^|Oe{d)`$NvDJVLp%Z4jjz9ZNjq8rCZONZ#{n&Fq-s4nsidS6t?-jTC*1OT zAHcGfXq3vlkWaAX!_Vh~ORUkfo~Tbl4E`jAMA{gGPmjT;t;^?JTl_0cxc> zG5C%OiF9TR9t~lC=EUGrY^-4{jKRBN@QY*cs%?o}8H0}<|0`qgvGdyM82pJb`k#uy zQ!JrA>tgU-6%y%&7<{)Fd{qoyhJZ}n8G}DLhQBrjPjjmJ?1{mjqL4`IV(==KC2}|h z-!q24AqIbH48Ac2e_9OQcp;y2)OXwriGPw~@TbS%Q)BS4^L1Jb{>&JDcMQH)3_d*u z-#Z3BAO?R{41Q1y{_GgMH*hf7YdMP^cN^YdmCqTTic#hbY){@Mn4%Zn0#da1B>d|- zEfWysrw}nx7saRd^^~U}8>!{|Sjs0*zKZjgQ=X=V$U4psr#ubW$ZF1CLU|ghkxI^= zPk9=mk%gQ;hw|j!$V|?kL3tXIk$lc~r#ubC$QaI_KzSO1kxb6Fr#ub4$NBN=QmQGhDxN8^Dk1KhDc-~=bxrLO`(yQoPUh+G*lw_oPUV& zG(;j}IDa4IX=p?;Ie!o3X-Gr{aQ;rp(@==GIe$ClX$VA8IbTM3>iQ9b^S4r-x_qSJ zH>&?Fly_6Uj`P=3p1OFXmh)pNe+K2NIDa|i&!qf1&JU+Nb>+xv&L3FqHi|2e=TFAB zIp%ved(AJrf&C3*#^=;j)!vtBcx$TjIjLFRInxN=4Z{uw*iSa z(3s*iznYzJ)3yzyj5_q8o3;=sTIV`#A>lSqPVrYaCW7Bo7XU)1ccnMfB}fb~Ee!8j#t=`PzwHK^3+gWnc#gtm=N($^HX%2} zv;U6ggmbK})0w;#b?$l#z&IAvcp9mk`cY7LqE?v93LE1X(oI_M$$H!JcL4@GjSkDx zNLIW+wXnLr!3=D}YXF4}$*0w`48MUtkcwh{~vX@+G0BYQD-13g50WdOi{=b$5e+RK^Ucuk1k5&S0j&FYQj;>C-} zhEP&_jC*sdZA*1sQXe*ky75YD^iFT#8{U#P4xt}=9XrwKhnmZS8(?3+6Q(ZxHz<`u z;Q@ewdEun_i-BLI@k^=P&Ri}Ci#1^$z>SlOi;KyU_kOW$Fg@F?yzORfbzK5GW+x#$ z+hI-~%-QWN*)7beC39*j*c|Ez;b*xOyY}TGxbe>bxT^ZVX^z@Jouf~!>8T3Lt1|p2 z!4Q`=Bne>TZqjfoG{8Nr8nwyF+tkFUO_pcV5YKks;7S0;w2o#06#486wzK{Qu%67Q z)VLtP$Xv9z>H?mfV)ixPK?k^JEbEx5`HKh)1sgJKiH)0z!DPPU1^<@DXf*uLf2m)0 z9l=8EkwE~Pcw_^4H54K(mS+QmA^YDxTviudRy%-Ja1DA_$m_6z`_HE`^Il@^#bWS$ zw+`lrDf>%+=#H3-oE5`E-qt#>4Wp}ckGr>OZRc9`=LCi67WAD|U{ z3SA!d3t!(8zS%G~QkN69?iOC|q;)0;ozHsBkD&B)q4ekHZ3i6yC@b>PN$j9wRHX8< z)*N(`DD){-$_{#%z);>(qR?m2{?xy8p+PD%xOx?}VUiWB6K%ML+i<(!zEyKi1SlrJ z;9+Pw*Hh~q;@RU`(uo_!IYx7ONU!H0d=VNp?Jo!`;20yk-&VPeaM~P0uj~j? zDBAHfS_oz+wi{>dCOpzHVBNHt}3X9BFxY|1$Ao_y)&P*b)se=N&ZtVKZ;PIl3;}^z6$vNAKB^ zPHk+(Xt44QQb-0>p)pBVJ(?9X+U^C|#D4g>&ddvYVL8Uc2RhVy1K<{#b;4`L88k;%Y1(># zybRKG+V^S$tJ}e(1!-VfX*>mw+A3O8v#UO zpV}jPLSu%Km^r44kWQn%E5IIP8QO#b(a4492e6VhFw*ho0+ekMX(y(6h>NAnBy5%6}_ylntduW>E?7F$p1Ip`SYC@o(MGT4G6 zBP2c|7Zw?rJBXZW=$eIxn&dWMJ)@71+b=SrE|rucJZ&8oZH=u`jfb@G%Id7t+kqf~ zh8g+1#)_SF@Y-We40a2o?#v( zFuo}EFSf#x-5i>S?#XnMmK9VSN9eaFdqZ6_kB~+0ZRDPB?g$sxN28Hj(K1wjUEU~w z;c24?9oOC;UFYol(RE#Q__2f0=#Q@Rs!Y!z#h!PF#(YRrvgNS1##biu8i)O;8}^A_ zcnIN4{R|lLiVi2A<8ZQ(kB!)pKh&#C7>#M?4QstH;jp*lu-JG0fK3a{Jm&btJdr4N z+kawmqXr3t9XM`sExVN?wYYu=c@f98N~OsP)%lS_OK!(+2yC5MbOG10a-K{Ysc%Q_ z!aq<@trffske3=ucupxhj@l~LR%*&KZQLr@2Tey^OG@F34P+bo{`qVc_x-cEUR~2Q zrYFEAQJfux=9-u+#5tH4s5DdHfKzt0H!$ugTkIFhp&b6L`;1#z(^<2ZO>#h zyElzMo^20`QD2RbWO|NbmTEJfV!yVU_vo`U^f7zc`hNjN>i-^KWGz?IxtGzbzZPJ& zHTqyKO)#VDaLi-*!_<*O^ROEj+6$rPkJx=*jMq{o3C|Y0~HUjD9ynP6yYoW4M z%#Eh!pvcfX8tdnWp0WL~3}EC;;pe|Fn*A`7Kr62nTL9r_io#=6Ox7xHBo%ci0u}da z6~kBsY*|T12(*`|3IB3}VGQ0j&u)+mt>rAz@{rJSg4WVjYN=UBod`xy?C7=pWEo~T zX=(m6a`0eWuqAY!>WT;YXGzdksDh%+6qBw z?LX|AyiOqYWu){MH~_t!vgC$VqOQQ!p|X?}tb&cd2cRg$KElU#mcvpoC&8o%nt3!p zu@@CPOD`X<^K_-+hihQr;iqg1>j`9&DA2{|X)O>WtA=>Oew=l4$oia?e;lBQh*Y&? z04ijTE~r!mk3+#BEqLd#3zoi!E!C@qhqYEJpNFxfM;F|$N~P+atp$4=yVONn_q)(b zn^pI-zuWHm0AP#i@;Q?%xRN@J)pZk#a09*oP@WHPr^AtijDEV_thvT%uE0SzU5>!; zHcaO+@#~Y^PS|JHgx6u3$8xT=PtTy&gZXpf5CiBV$!zgTj|Nc|@=}r)w)}_y4tp2v zAiSCTB04sZVwDmky&wmwhg!M!Fb4verql+nll*1o-U+%VOmiajAt;ZHD$tY^(86fB zu=AU4B4vEXEu*p$qy_@JY>{z&i{PFP zkm)f|Fu23SijSbtv`&+h$k7x-ACaS(Mblzp;;^Nn;IOWdvRQS)Oqg@MHs>m7j_L<= zdP0Ypne7ePxtzT;_sIaU6pARghsJkqre$L?%KQ~TIc0GV^MtL; z)L@mrhdLP>uX%F-M(#nqWj|AuxfGQd#%$a%&nJ)@pC=GZNzkVzicXp@0U(VWR3&Zx zChT$(^m*Lj$88Ji0qSG6uQcHkfc7z)nr)k!7I_U#1na)R)vp{0`v{Cby~$aIEuPL( zTe+5}cpefOrrAxU8pqNFS7iercf%fXy zWO6v_TGmT%<0G}AoiEd}18vzj%b1$iW14#BYTIX<35?%O^s*4!+Lc;9c>MCZ!6#_> z(Z?^Z+uW_?yB@#1Zuan_cK!cD;PKVJWy^=KYdvPm->nO}1E6gAxf)w)7f*3f%z8zq zealX0+44axd%Gy|Ip@;4m6yl(k^TK>%Amv7nf_v51Hm@WVI!?vTg0+cPkMPpwgFm}wVNX2e>5l{V< zML3?i7hufJ38519UjAD7fJDSJ3}|!?`Kw*>00L>VfWza13vlIeu*tdd9vte|7(eWZ zM(ZzWNelJBWee@49iEKc%WOQ$2QkxvdtE9-9t z?^BxhVSp{m7MBfpSil>yFB@PjUpCCgJzhD<-BBt`4Veuq?Go1#NJB>KGe<)~Y(y{DL!1*b6W<v((MJXxEWVw)MuZ=1zdFRG?$(}7|O%_>Y616&@Kd>r9TNK+d$XN+-b zzbWo{wSaOnwrDuLHV|CHaBOV4PJWOa%q?~!z{r#62E37>T~96A$ZF|mUOwy^@u_KZ zM`MT9qI${(KK_icnSH?rpD{>P5pkuXD?)fWC5?Q|U9uGk)6>wztEyO>UZHc#bD86* zSOYp(iyriUy#dqLk!ahA<`lGRH0=taJw-G$3ds%E zw2O(hglHfUt)HfyNwk?ngUv+iu4yi!(VL4K+6Y=3P5bqJ(CDpAMf(v5*?GSqS`VU0 zJ3rO5_lbsALyQecLg$;BwuNZ>(diZKWlejAXgi4}bv~wP4-)O!7`dgI79d(>4DEJJ zn?W=m(PZ6=HSGqXO^A^jt7)T%HZ(@=Qcb&nXl|lOJI~Ry(}c$x^eC~a#r zVHFW_6ybhNSWJWgig2eU%qGG~YIeI#6N&+fy*eFk55ihx`Vpk%)taMs;W3w;dd_I} z804F%HJ^cUWTPgWcuaxDHu`>GW2No0=K)5Rqa6bC_H^f`N}gaMpI1Bt5O_mh@~+g9 zA(Ffvl9(ChYMD|3?R6=hIS8LV5|7qhsWpxO7@Cks_XaiLe}O!Bo3{BP&37(9br63N zquJVy1XBFz--(A+UqLg|UiF0~7Njz9|h@mM?>!wCNt<^}W-W?@zL0}NKVmi`@N2rtpXivZI3BIM;I zgRSPNvzU3ZX19zX^4_WrBc-bgSxFTOVgI?n6b_7~*p)-9*0M|$$F`K?+EJL-v?QvXJj1Ln zZ9x^o>F7Kp!Mib# z>8ojHkj#a^Meean{1jl55-&xGVEJ9M`~=YM;PSaf%=mTYXgt)2Cqyjg$(lKZK=K9O zBHKNmCNxY+b(SAbOCbCj{*=O?wbv{UtE*5skZ_z!tWg16#mXs`(0;Pu%c5`Xz2S8XXJPtE2M4;Jse+ zUZr%xAAI0{)sN!o3b384+1vmTXC}_CmU=+$p~;;AM&4srIWN@ca{yvc(1XMk4})5t z4zX_++kW|iK(5fy80TJh8dZpTC5`8pGgsUfZ_#~ft=97xzAPD`XWggrD$RM(@n&?nKvN;$0!}n5id>iU@moQWB#QH&`_5 zV3rZvkj2S(Hvtpevf*Na(?V*SLJLR*doo6&B8v5Z2EWv+-qlc#$I){#@ZBCW75}zW zF1B7x@$#9IS$EmZG8JItKE!=Zbf|qV8R(BkJf?v((Z(@QDQ|8d;iZB93EBqk1{nE4 ztS>KX^fLsuR&AIZ8~}%_!-X$JPrYA@F1AH^4H1nN>)aUI(WYR+)(|bL7n<0|gjzL1 ztR$`Zo*L>H#m3CwTKbP1CKr*G0(^)W#ql+U%R?2mOP3Ld`4r<$%mYOq6APIpd-ea( zK8S*Z`xfmWz3RRfx4BJSztiia(}tStJNd4*b%W?}s%D0YK7%<;gbpo-q3me!+tJEi zoXiiKx8eaR@c&H>oY6b&COSkQJ>NrPdk!$*WR zVQV3=h=mO|)QX?<)bQ)R=n$)PX-fgB@$#uyp5D^bDu8s_5c@E+IJgZoCi!5J^BT>3 z#W9$j{AhHBW3w7~tx5J+Sv%+<`L$6#*HP8hG5bB@8B>OWBo)cs4xR$1gX`x=z>Hz9BPd~sTLnyf#BZx`l zJ?%dh*jgU}NWqQX(=KNsZ&yr!kt1Ty04v4oc(CeTEq@n4jve;-Np?+HMOr`RmPdyBfrm39(>d+fXV?z&~HE%!wfNdBys``nuZ{|~t zxl;Q8M$X_>iGr87#`$=OJ{CtzL_fZg-mVFC+1Dk`gg^C`ZrXEe{;>?9wgaj=mR8hSo^uQlcRIU$xNs1R>miEN45*+ zG1zMJi>IuA;yhRW(AesU^*8 zwB}V@>IV+j(g!eA*WUr^1Da|P*vtnyPJ}AqSU(&P`=A|;+yVz2w5M3ILRiXt^kf}# zs^{)vo~#Q@uf@A8wRrLkp|v?HrlY&q9Pa2z03$OyQ@^7n+Nd82bEC6tHyt8S+N2u$ zJ=(5{YwNc)=T?Axef*lLo<5#puZj~YRSrF0`Mj211CTF$clq#UlryL)w-cx=keBIK zX$uN9=LF^yEr@yV-~zhH9;fNv7)}0NR*(klD^zKWO*0jz;RNF}Je@_@Jv{+Nt_Dq+ zJrgQZwMr+el%3`vZ~0p3xtRC(%C>ngizlEq6T-=@cS+RG6`FxYg+X`w?e@BZKr18% z=SC;hh#xTj6ca;@r;esmNZh0)#sZA&6X;nQJ(U%S&KRUgPYm>D-=`A0_GU(QQFnl} z-CQM9oTybKvkGCpcp{q>!Q0>Lr}ON2Zdg+9vu&>_<$~FLCjyLo-wC~sG{Cj(H7!~W+WVlv)@^0BpEdxr z=IyfNiX+-+JuOKV`y|V3gpXhT8t(u-AcU7{;Q)bh{#n88daUUdhlQg3{*bjMd;$g~ z>>mrGWw130U}!=DewzTc!K8*SnqFgEtXa>as)jpqRnr*F;Zi4nu}#j3>?ZGwT`64C zsB8Bv*G_n(`4E2++GXoU7K&c-k(PWb#xF7~Y-J?lIF_zJu*0#-@YuH?9u!asduD2_ zMF8tBmXl?^#^=SBhH{#QvA77Ch|ZvT%OIBH-qIIfq`HG$5uUEowcehrSJoY!8 zJ=1ykHfkI8Y&}3s*9r46T|2+i_%8|6wQDj-PC~)TsBJ95Mr{BXIS({wI&Y?3!s!I6 ziCe}A5B!Jvh;ykfFTmxAPNuhvoL9R>+tp2s`FDG5%t&p_5HjXb&``|ZXV}L46(Dyc zF*V8=jeb~THO7gmR2!}5S6CmpR_K|m_1s8cvr1L(<4V1!tGlYVO(1xG8Q|+?9fx+f|H=tDAAhh6%TTTlq4B3*h!S3t;3N zq3QDJcKcjLU}$s|y}O1mO;nL~0ypAWA*JR=ZckS84Zz5kZQ1+|T8#nlkDK}E_dNYR zqt&e@b<2gi?bB?lULjD22-pkD5aCrluSCWmP=FIxur}@w_W%?TnyaD*sPY**FlB0{ z3#rKeh$hU@=t~KdD+yniwRm61zE@20pK3QOo&^f404h_V2=^E#z{m@rDU;%iC*d-C z5y#6GfyStQ!0a9F9jtL1z{o__=zLyxnl;>MnySGn-@{6(}I^lpg1|(fN3k3p6W5;M%Mh>H-*L>!C{d?C4a|$2I%` zU}T;sW^;*M%!>r7Vh%w=Y%!Dn_lL3ah;9+4|NiiqtO459-=C9gBHfAVGvoRS2HupSCrm`Lbw{l5m zU0@r4ky}Ai@zLF4`2Vh3;U|D<_!lu%G`Sjvyocpev!-};j=*R6q6&E7u`udgR3k1G zHsUUf@pP{Mir)6idj)Gey(Pw4y@l^se(*HC(V=S}ae#h|qFa*0^+Qv9lbv`=Qfnfu zR8W{0duwvc3ev?1wGaAKQ1{2%0mg19#H=wHvxaKGDa_1$`X+#pfAFk~U_|e7W<%$7 zTIZDn%6`fX7w@1Y(AeGI8?v3WYyv>)033w*XhVzN9kOHFgHxbcjMvWzRE6wnK10ff zd;;_K8Lq`OqSjlq@JlSLyE-qva@zPxaIezbOPg}z?q9NQ1gqNVjYK{CTIN=O90_vs z;vkho=t&y-s=0(m|J^I zh)yOCb)}yvm2=Y1gjuwm4jSb%PIzfo{$i#%`XD{VuwXJyhZ`()ht!~+q-l&D4zW+t z(4(=q(~h}bYKXmFYEaip&OwvN4xT&u5=h0!yG|(AZjkV zfr@5Cahul^PXj7Ke|w=-33_!VyH!d&U1;jELc2DT0Y={EUelUA{8~P|gyY7R^^|wu z4eA~l9I>;Ge#E$Gh3L^6alal<@i85EjCwtGi(Rh=0jf#henxXgTnsSwO~<2ny`{m- zYeWZvUrx~SZ3(pU8t5X8pC|dKIvS0A(f_*wDvOnV2{7^~S_ltdIQ-K@YhVhdX6LC- z9O{eOHkrQh^MUv9Q|Ng|<@F|96)R~!xz!ZUec}jOjo$V2&uLO3pB5jh#LI`G>$WJ) zK4j+K9@53BLtMBg5%rXVpfMlg7WX#PXQaKnE*z`ed-&OdR*G)2qBPSemJ??s%9BM0 z3Dn~cahlyD=-~qhB&mkKg{8QSt_3JA0GmD_Si{jEJc+sRC?)F0H9nnam-s$`_Jcgl zR$%+NPh1%LdoY^}FcC_t$EYGNLG$sbaMGirxFFIos!{>}578zK09bzuaHnZpm*X_E zjh}8=?J^KU#gy^c&33gv0H`k#Wh<+0!WW4ja(oU|d`F9&h-0f(rW)a4*2s-;A3!CS%VL6j1vZ9Om*Qs6b?Eg4Oc?M zlAX&o5$nga2FJ3dH)VA_kC!R>RC~>xUV8eO?sMm#ZaE*5VjWcpKU_^EVEbiuanujO z?>Q3#q&ELNTB-r@1{VS#eUrk6za~RX@5?J6+b-Fn)C1 zTn*{vTG|BoqpLGL(?`#-dG>(Sv&WvW2Jj1cmh&7faTrBSz6ICu*aU0a9OHH1B8>HF7OY=TO9HXqKN*Yx@xaxBQied?2N( z@&NAeL{UkY8?2gtm6sk<-3XVGs~1w=I^pC8QgFvBo?o_z@zZC0;7WxjLXuX&IhUf{u&CE9z;z$BTenI6x^LzCB z-QMc3D7txpcmWYs)_+=~A0;p}Y)~J$NeVArO);Hw zqGlP-EGUkDk~G`qTu$~&=Uohufm);wfkYaH8D+r&`^Q92W)_}1QUK~7FG$ve--_MF zVo!A8yr@CvBF>+Ym%ckdU})G|>FE2#k4BltRdKFp`u}LY-2gETi^vEJ_Sk;+*=Qiq z=VZ?iKW%f47CntcuOrde`R6GTv$|k%pvT=)?Gc>lo+Gk<$#($PYx>gw#Y+NT(L>4dDVaz>be3l|8-tnEO z>1hOp#G}I_c$IQ?($oY3vFdq;y>k7olU&QI7JH6}dgckox8wAu)g?rV5E%P0a!*J4I;NrtxUJi`}#k^WS6eTAgy>pmCvr zo6!P>`727E00i#>!=FA(4btfFwXbnr1T3|Zqo*5CpPr}U-y61B&a;q?!*7A*TFwpt z&0mK_F-^|yhM(d49wj@rnLU4E`?BwJ->_{9{+5vuz6+z$a_$2f{re-@)}&ZnKgZpc z*>x|F_1nUe{)hhTLZ*>NFFqw(UDp9^Imy3Pry&)`Nfx^Do;^68GQ zltSrjdSE%Y26WJ9-&5l(!N2sWaTWris#xP!xXrGFhZ}}d61pSk-e{y62K@qx5xx{w zV46)xbPfb{@HW$V9@5#DSY6#n9q)TX+0fAQL=wf{V8K?k#+iT&eQKOXZxIkI_zGbC zL-;!qeZa9_;vGG|0F+UM>iQp|>Sh~8)-~SX;jFx@@j2$9ym7v9!QHvmMZQ6y;aClR z&DfnAnpTr6{%*xz+=lO@(5(*aOA@@*UnJ#NcXUY&_kbevfH$x$Id^cq|KnWqn{Ydz za?OStZpykb>!z%mx1qqF@W(hR*h+6O>hEASqBF?6YxBQ1Tn3Ui@Z)8D=&|ovp9dN* zo1ON`Fd#QvY8aV)-opy?{`Y}z5<^LMZyOVSWmPn4>s$2u*g*pZ`lgr-^lNO@;k3-f zzFvttvU{ZtT%6R)Yyi}GKy^43=?R1I&xvCfXZLcL4b|af`~?rd2|jw_A~cj5Bez$o zH*{gUUWSol)_JW#8CBsMQJIV?I6GbRU!FL&75B64w@#|xQmONK8N0{9b9iWpLeye& ze6Iv=O?IzjsyqQ`YP9n#Q~`eph;=iFlSWN zIJ*-gJ~hs?0yhDG+84M90F+#SzrceJ`T`*Oggr1jSY>XTvjBfW1ooQ;UTX`y`B}Jr zB~g6s!*>D*3`+8Sjw+|1%AiHbtRT3ZPvoPu$9Y5Jd%4X|#SFC-#9-B&E4|jRyFtx3 zT;qHYse_992)cyzi?&m}(J|%UL&2d6Au_5Ml}V+13}*C+59E9>Y%sKheL#9^oP7Y( z2lSW1wGRSk4Lcb)bQ|9!9+}Q=$WjHYu006aJ!fF}VhCH#cEnfX{2DtI`qVfN+R%3r z;y+x(tLye1XZ|YOQ4VP{?S>X~H2#(Z6dxYT z4BqNr-R6WO;#){o<(WT|3gV#ZgwJCxb4rpN&so=IU6W=0ZjVUn)fj}m+&ShqUbC*U zhLk|GDk*nx*#ARL=*C{@8Q*5SktI9N9$Ai+ioZ{jYQC9m?g+f@s6OC)|Lb-Gmj|jb ze5=wH{g-y5{=LG`fBb@9zaPK0bGA8vt7eW#%CgSu6}}gEfk@A?ru9k=FKmkF7@k20 zs*0JO1CG@2%^KmY{>_bQ5k4(EvQ@l0+z)s&U9x6b{kgcDKuuD(3n-%p|7NE9!<)(2 zdYAZnKA36J0^d4(W3sI?J;D9H?^%Sf;m`j|j{&-Kt-=OTv05M)0yd}ms5{%tPXe_u z{4c>tIOrm@e;o~RHDzT@M03gc35~=>guj3g28XYc1^46cUkQ77Zs1G|KezvjlD{i{ z)*_Re7je4V+pZS6Gtt3WNhP;8reCZ(vS(3?hy6m>Rq>+(%Z6blvJJVR^5pRKibM~b zgET_gH(cT0k$AKZCIzoKA~jqrfVA*U1cd&Q4y^mN)hA(gJzRrz>oJG`N^k|&3Mk1H zq!roxA)~4~l9+jTN77H;XI#M?rtSdWIe-FRL-b?-Uh~V`(4<~&PsX?PrwYGV>1dNA z^ZW3Slc8qn(JaU7xr4v-ogsYrKqLFo|1r8Q905kf;s4YV{MJ>m4owc)UQfn;p)dHY z|MDzzUsm;gXW-XlSH*{5$O>g+ditck8`e1>Lu1^oip_*K@t0D}PptEn2evta-}=7f z&Li3Yd?tvIC#~hU&J`q3`dJi%KTtW70(;k$uyMEJ-wnpSLFj6IJ5{k`Hzmv}@b^%rY zWev^9=u0(8@GqX7UrX2z!=Kzo{E>DnRvDoJk?o5F4cBMKh;$?KnPM z2kqDX4s?>MVkFQ)dEh&AyqcuQKwxCMIKRGL#7{%bU#($pAcLvZ8JGPcB<4rXZ7RJv+30aZGa4L+@t1>o|Ep(pQdUL{p49Yz?Xjlh zGh?>-ou0ps!B72;e*8Aa%AArF%7Z%wc|#MDb3?t}$MWN<*o#6da|gF|ReT00Bbsse zxa?rrCm~_Y?#KdS{ei{V8Dx8NyJ@MrAtx{g3-I`CYjzsTj0$zh$TklbSDJCjH3V1KwH2La>Y_q?uL93xgavIg&%9r2j&VHkSNJw6=M4Z_Gn6clv@&%(5j zaX50GNUlL*%}$Nv(=EHP1RNqaMpF3nTWpm9& zUpW>UTx{~6fx~w4VJ>b+ntz`)AuYJqd^i()zISu2e0RoP2#fh+v~}LTTuf^N>GzhZ zXllp_CG7|pj$Fr-)Z8IclIJDmnp04@ZH~dLVfNd)NPkFG04^2Xo(gpZd%@G$mZ*1V z*q7ZAKKyejY7MVfOvCLex>|dxETWeBWoW9sAb7VSzzgn&b6hKeiBN-`)T<;pS4euz zZLW&fI}54akXm?0VzfWpn#{ao(4(U%phDI1stT-Y3pbM%yj$FWvM}bD&vM>#jT@nH zw!`fW)Zv_SJK$a}s7WO?fhQ4}Kd_jhjUC(qObCn(UGndTeqdbyj| zY*_e9e^UG zLm|7E465>7mTR&1>QiXEqQig;bo$W#{vR?9??^OgGqnVbiAP0T6<=Ys*pb-Z=EK_? z)@ClqZ~%4wjB{QCLSREacopvqtE`*SaB*^>F1h$Z~6!P)VZc?Eypu zx`JQ+Ml~+lbA#A(W=*_F#%FL6wNZGD1qT$+!Wc|~1T4Z|)N@NH+v-$1&TY_CwRCnn zDtg!&(nM>;Q0lm1s@mKE&$A47 z1b3T3!umUkHO^cyhu_9CC=1^|%3NLc=+Imd}KplfT9WzwawV_fr(`dnR zdkBN-)n8#)))xBLlW`css~1!tUdlCp;)OOyqX!~9mpa$+++2ewFgSpU5;JZ_RhEgr zIT0dMw$&%sx;oWkemC0u5GxDbzE47=bQ*jFZ~rS1#RT`y8JSb~0h*qt>rj`mI2B0r zhK6>tTr?f*h5$B@-NN-MiuE~_rq(7GmvKAzJ2mdm^i`V=`^t;f| z9Iv_jH|8QOR)}2?%6%`beu9n%ate=Fa~o04EGoybiHq@Cn?x~*bCbQMgjJE&VEWUa zPAaV<%bA-#r@J-vl{!Egg9&P{x&>q>GpeBcfI683*LjM~a| zcQSPt9PTD%Vt0^eZE{jIDcblRZJg_P$w}4aCWdc#LbTRXyZ_{U!dg!~*$UE38a#}q zME7u2+y`%1A?n%WXdnA#Jym@R%6mNgR~m!X!xPAs;9h@+`hIdcOjT&gDKZK zlg8}O#n^`h_ve~VkO)mWJpSZ*+YKE77#hx)fd?T$AsAR*3CZaJyLmj^D&__&L~LGb z#FSj?Jj4~>`r79Vz6n$7tLVmJ-$O3`>}5DKtfhxIV2_XfDUzI%s^NcJzu4NXn0;VzEZS}4y6yq< zjK4WBc+BJxp^lfC-lVM1sAz7;w=LP%o8stPYY59yNESYcWe4R{N8P!Df66xJB>6vs z;i);;jpPK5Ci_i`Yeh3o9S3FWxd|*@Zh5{9p9v>Q_ah;4WIb4O3b(_XV#K1)g@)pi zkagu+-sIfGtCBr~e|O#eH5@`f;C9T0*=B9CMGS&yj3% zJ+)@88O}AgVd6ow=yf#an(yYCAzlznZnAJ27$Z9TvXiJs7B*Te2vfK%LtPf+T0(+G z;Y(r^I+ipa>^^7i;5T{LEyy*O@UX*h!;ssD`RK4Kcr#8@0&8h9!8ylTn#j@uJhx!d zIs-IJEX0q=CGdVUG6DAv*biizsK;iiM~>_H*FAlH$1a0zf#JT-GWO>5c|DSj>0h=t zPmvQ-BRk+rJ{PsFO^z&sYSGW&HzRUCEkUY&Sa1`c#;W1#>M0iM-V3nm>mB z4oO<}L0FFiM}!T);xKa=@R5zsrsqEn)^9-RnU2U5XcqPz#-zjXK`Dlnh0}kz=*q}q zPFlDEFH}=>a}tbIGk}N%BHu%ewV7t1@KQ`9kvrfWF|aR#+8Tp`3=C{Kx8>5Lc56av z_*5{MX_29j09LG7yx$NrAT|M*q_Aw&VET(3#SsxEMdFg1PO;R{R3Vq$r!k3Iyx`aH zx(j0slUHj#E{n_}Ux@Vrf4B7tH$2v}4P1%IEE!se9g*Pa$BKNd6~qZUxFxV{z8(z~ zIfTeYxbm5AK&63t64^p?6xr8W6f$^3sw;RKIj`q%m=fIUT6%yC2=Q#Kds5aW+F)l} z>&eCSXNU!0Fo)2tir<;k(*Xq@((n{Cup!x2-+h_v{l1o}%hTWS$sgzv;U zm~Hi(4Gu4Uco*9-gbJi6*ZdsK2kX3I2zaeiT+1dvF8tXd-iC%SelW98^{~&RMGogD zp@(S>Lysr-(Fiqp!{!+>KOdu)W)UPb;xQ${m>lbxDO4%Pl~%7`T*0g17SSH3P>rZP z=#X86zVr))_)T_K@LX_VvGcVbJ$PU*S49HW1q4N#+Con@{l)RENjZU`A2|YhaPlLA zmv8XbfkQLX%_Am9z~Lo#vU+U3L`dwaxF1SoO~p*hcHr19T=|tWWgPhuCwXbY#5oFo zJ46ZJL*Vlj{sxJs1Gk!BIw}ndF=uSf1b9W@j_=U;=0WUMfEA*>l_>37vdsh4Uvyry zm6oKz=yUWdjDqcVyca0;1>~IM_adRBw@I~GW9~55Z%5;qA(~yoPoSm1Xfe)J@f5MI zAVVys=a@C2+i+m?MUvO?N$?G?IedWGU|ya+Iy9*!*>^(tBg`JO`^Mo}vcDIaY8Aga!vGCc|Eq z?v}+Qp}QZ#TADyUAX;!Y0_6+uxdHn)-b^Eiq1_@?KJqxQ6lhvFBg5g87t9{q zI}E`roOcF>l*NmjH`M97_GoIcZIRP&2pCMf-4}O-*fN z4aS|8EBFhz1%11sQ)d$Nj;`P*HhqnvALiB~dGx%Epd+YB%h)^Gn)az%oVid;I7MhJ zRZ^#Oe`KV|9te*UB;gNN#eZ3?7<1KMcV4uEJNG-T;I$|s%Np1#)bXOh)vlnIO0@3i zm5gFjv!Wl;e%ebX%E8;I#|4Hx?Qt81?_|rl5dh5-OW_0DiG@0yj#y|;TM3{!u5)8% zvp3swL6r@WJ|CK7R4muTy=Zgz(}^;g&TNr0vDSgIAE)f?XzZywAd~z+OnYp(Sz$$_{^nsb@muUXUuY#)n2?cb13yk(y+x zi?64w_qiPE@1lv>@j6Uu#KEjTOjl4b*UOdI&w4lH$&dHF1K!iOdi(s_yYT|~@tTd^ z>hBZ0r`LK<2ihe+UPld6!kB;?iMY`rKZxVE;t_*E@_YpMPbLoNb4)x0kYj$BH9j}g zJO327k%xx}<{%xH+vlr{y||%E@zn}x}uK$^ug?x{zHZVAh1pKQ%?S~gl zE-7`7FDmzylumX}nlZefY({B%pG(>sSNf;lg7}N3(!L|lACNJ)@9jlJ83P93|Grt}R&$>=w^a8d!c%hEN`=+pS_!1oJ$ zf5*4`6Vd2J_>RT56yJOBeG=cT_P}a;1f+yQttN6nBgv(Gqb3)yku6<=|;_~(dgVw(df#}(7y%xtD@0y z_@-}-MmOVo`L<~EK73Ex9*vgcyXEz0w9SraG!NfFJEKwO8`0=Ad>6bKjb`qOM*pw+ zQ8`q*(P-}}^`Y|@xM$8NFY%#D=+VBS$v~ACp;M<1c26pqT!K+Cqs%?6sJy(7`_fC@ zM(=5pxD^beeNO32zt25`zQyjcg3`%F?tcCHxqW4G-38R)40rEhx4XUSC+*$ir=X1K zGp7|%yBGM-zARZfxx8PY8xAgDf4N_l zkHPbh`s0__(*QOYKg4w}ccJ3`kKci3> zRxoYaj6#@Z6wdH-_fjH8u`J0b_fMZ*P&U_4RW&?iWi!f}n$IZhgHa={x@O{-v7V7R z6DE!uKQ?EK5rb(eIc{pn%w|57KAVA&+l+!LOh?6ppB<+p4jG80!vkODm*WNraIHTY z9fNf9tZ0;enLlxMG`bV%l}N)xN1BYlVEi16d!#EDfFJ48NM|BF9npLx(yNfJL+Zk2 zs1|9>-M9)v`XQd@PsNt*+9lEG0Hix{Uort{ciiR7LAns>N~CL%Za|t<8IA5iIvHsr z(zkK9o`#+HVqCfpLVE8i$Rqv7UtvE|$LeTwHPV5PN266puf{wWMmiF6T{2D?&i)7N zMmp;mEY?VGeK8uHf^_rxXml~s3o$pXLt2LUsTS$fcVIWthIe5%HoFP6up8-_@1fpE zL%UILq<{Ya^+x&?(sf8DeF%A^bN>x_q?JhNg`--e1CS2b19_zGk6|~`N~Bdt>yYk2 zI`b3M7iraA@FRR4vk&}8XCj@6v=V70(sf8TAkF*~^+VsBi8LMQYNTGIsR;g7BF#s- zf$~RS57H{6=^Y@~7>(v5U5Ioc(ki6ukh=eic1K!?G_@o2Ax%e0pDrRX9Jh}(9CK0~ zr*v$aTd2I|%UvC2CoeQE>ptY1 z3woUaEc0X|?c|F_M-n0{CH1a^5uMs3WT9k1p9J&;pkL91KGLRF0Dm*+cQ&EVv*~Mq zuL7O;wEhK5?*-I$e0yPRWTP!@x;K!RcyU|i0haANh&1z#X!Ha^C_6_B7OHDU#Lwr0 zK0B74P-fe49_S|M{bK1QT0R%_2SKljr6;^<%TELSVnpEl7cNx!iT`Xv3{?IS(BH-B zQwqkSZC_%$L`8oV^v!p{Pe?U=o`dM*hh4y*wm2HSEtc+qA0{&kID{V#fj-4Vd_o9i zM}lw!+0g~<{SfHIP3Q%7J!oF4108ScX!$8j=6Z|={aeuKFCy6b6PK|Oq~8a6ffbFO z6)P{)v;1<%~2>i5%qtTwR^`LT2 zCnZtGqHy)e-QMy z-ax$FgkEIRJ7O*B`WE8%CiZu=?LQB6*W1zPrBH9{pDSFz^#{E#=yWP!(-UsD+i@D` zOF-}1M1QKSe+lS|u$INE-?O040X>uSds9*a3A0l$#qx*B-v#WN?IT>JH?&w_x34iz+@?QV<=d9pueodnmU>Iho_`2P4J|o zg%XFSxR)elr=;KI%t{#$Xp=CyeM)*(ihFoU8hD0F4b)X`g#1p(k0SX55Rs6bKI(^9 zqk~9{D^ms}+?bMlP09eu83XZM4*E=5!*x56otLN7IuaUfL%khF0Up6ddpdCaA-5Q7 z{vuK|CM7jtII2Ig!vt~?(GP;&2s)lE;`#>?u4>}Hj#xj4ezHx!)~5FY?mS6%OFGs$ zvg?Wz_m#?fMlNXM!Pfvii^+aedl~AUwlvX`;tnMZPf1_m%uX3_SDUPqL4mf}Dfx*d zj+8<0WL8Q#JZpQA%D{*0UITptK8QxoCPa2hY96XJs>4XOjp*A!&jh`{q)z}nSJKIz z{h*Hl{Z{IC+8&f9?Lq0%o?O`TilcpN28n(|CXMTjUUMi3K*#f(tQTvSteKqLM zc17lDiU%(5)aKe{iA$40&LwREZ4+;9(|+6VUBllV{?71svvy#7jOsvgOCU#g=xYFz zogwnul0@{ayOQ9Y0QoK9e(r4OxL`nMBf0I6tAyO`B&YlJs1*0rc5lhb@`mA*ldm@ zP<%!ogy8(a6Gr?=ZkNfa!dE4Wyt3QNRKq}M#~)Qb?q<0@`H~-p{hU|jHpqN?NtfdP z&y(cm@>?zQW!cU=%JdqU7Rz*&Oz)EE12TP5rZ3BMhfF_`>DMwn zEYnt<7lW*OF`skPpa1^J>nC+s@LMh+XrD?S_l|r{;JJ} zV=2jZpnvdLeVp>-uU#KSFS#poY8A<;_1AbOpR#d3%Kpyac&Mn?@N?2e-%iYS|2s~3 zYH!!;*(Yw9@Z4J@pF;oO<9;`v(|G@=@~OSv>sK}6q!Gg(Azl@4tUgY8D(|P|=k9vG zpfF1E%KnA5`IL?OQRR06M^4qN8`93}&&SHD{i=>rz9Zzj+_tq{IC9foDon*$jmIfZ z?fqfxHHQvA`{F$$ugW*x%cpGIkFvi#I7(7Ks%T#RpyQOM_~zi&TO9wr{GWGFVQT)* zJWhEUFQ;sL>iy>OV~$gv>N~ya%8Zi0@I6$%8h`o6DNpg^J*j(U*I(+`LGmhITYa4J z)L-taG(P<%dqo+^+y393PuaL1<$s!QPYORfX#6wRtRUu|QX=y>V9ZQt?CPAIRtbGoRRv)iSM}}nGIhT!=`vj{(>j^D|0U@%T`ki(nYuSfx=dHgv`(h(S0r7g zt7TdzQ};$eZysNKv{l3xRVy+L`uy+47iyl)m*uh2n1ASp(_*rJf`5A8PY?X*fj>R) zrw9J@!2b_Cu<-SKt|i5{_a6AiSo~huwS-7zEcVy$=S!&dM9EWp``DcuB5D6UA)PqY z`GE03K4s&6lsxhOc=@T>8v+B?5VP9fxQ|nw;>m=H8z)->>Uxtr?U(42d7SbT-(Gh2 zn7V7;9G*>bYJa!-IOWOS>bl=Ybz5st@rif_u{HiA`<@_H zSt43}L#zC440Vstl)tUf+WC7Tc9-hhzA1k@L!JLO#kV)qJwa1^2SeSLG{tu`R(H&d zMKPRc;FQ7D8a~BHZ58h_)cs4WvP6vj*G_;Fget~LD0M&=8x;k)BU2wKCRVl@BII8QQu z;4`3D8qGHjqow_H&Xj=Ds?28oC(VSP*$m%L;+x;E(WK-sw4G{x9LM;U{=8l4scokJ zF6M99E+;}^YxR0UmaER$)w=MK#H;grh2JUh>RtdX!Jq#~d}d8P=N0~YiC6a+ZdtLT zz>|N}{o@HNh3B3@ci{9+o$K>r1KN2Kug>`u{!)oo=l%*mPU6))fWl8!`d`fF5*0p# z1*SFs%wqoThC0Vk^}0*q)%i%WwEqE#SLZGY|BTWj&vU|(f2+hB5sY z@fS(FIzLU9cFvJ_buPP8;!TNH=e;u}{;v{W_f9@zl%BN`ug<6IB>!fm|82oPLE?8w zygE-;c77r8>YP4P^8cvx$n*a>5}$~E!sArpD`#H)J{dY^|r!z5na zueceD$1EjY-P@@8-Xig<<@i$gS-{gcQup_29Ia%2jH7?%vu4Hrti-GHHih3T@#_3d z;op;Z_e)Ln(6i_~PMhKXtMoU+cSsWa>ikaW?;-K(JWt`zllXjjo~Q7`C0?EPDg4z+ ze>469rC*-=DgH90zZpKL^f$vlp!7Gx|3m4Q=Y~rED@uPe{98(YGyLaDe>42gO20gJ zRQlT>fMx$T!=EDY>bz3%pDXd|{8HhEO1wJHRQOz_U!G?we4*0c3_nNdZ-!s2^vm-} zr6&V{XKVBAO37dKs_1X(Apc>;cQ^9i7kIdZKWij@QZxKIiC6J?s^s4y@ha|D_Ux8; zwV%kB{9j1CTgLgx691#b8xrr9__nAQ%@1l{wNT=_15e{rJzt~7=^*Am*{Ir<&z#Dh zD3_XxxsL(gTD#CM8Ik?9Gc(yv@h|S2 zB|h~wfw_^XxJ#7ynG(;NCeZdte14hWpDg(!O25R9lK5XF-d!&EgA$+8R`@yX!+gdh zOMIHdr#8c5d2F>_=P>^X#=<8ur3R4w+I*I>Mmp2Ay&9)5QRdY;2Yn;Y?7^SJ$2G#K$GpDp;u zf|ows(9o^vr$4^j8h#kz6H@GZmJ5X%BURSxda1uy;;)ROCtvC@{F%(TNb*mQ!~dqV zzwPOQpWg+9%)&VQ_e=eCvK_li{SQg}m`b5%jl@3@N6&^h_+7xK!p{w_=SvMD`3ed7 zIkj^pBPs;i_@}i0s_p{M?>d6^ejNSZ5FUQ6mHu%{JyD6Tn=SP4yDOl15GPQ%{z8H0 zcg=wRMfQ{4r2^0IU;)2|`&G;R?1|_fP0eJ^J0*X;>~9bD7I=R56|`4Wxw2lg-=@z7>F41knVjc$ z1p%$am-PQ8_r)WbY8datsn?fr@P~nSOWD|D6EdWKgtY$(Np#`?iq`t!$-s9`NHtRL z&x}=LoE3+EF!9Hn&!{+u-i4)d@4Zy$`B`eC_s?4^_d3~cUn~;*{H`Wsu4j9?8_9Bg zRQjh&{hiJe{I5#=(kew8mdMY3MnpEWp>5&Z5iAo>Y4 zDtDorug(_i#*5rfTAs5dc4*!IkI4SK>|~+8O6utb{>};Ajk*u=8IvyYXOSM1TPgc_ zXNjlZm8Eu%T$srieuo)Q2id+aXA3;P6Ab)Nsb`(EzduXiy|p-YP6D3%(|lbx0y!#o zxm*`Se1rGXq<-UGQSR+h{}s~CMSTSREQ!BE@-LM9{Ei-IV+k*LViPkC{$8p7z4J4f zJq`7zPfzKGr?1H5Jiq%4=;1he=yw-dEBDPfc>1I0l_q2>C!P}Xaw9C!S#JM?@a^>^)+Noo!LtpKD;CB8uRtA0$y`pEsi<#}>a z$JWQ=(m3B~ zfPMw#_$?_PxMQ=P+x!L7Y+T_C{D=^Kx@rV|NJ}G;89_fiV`HY%FA+@~m3!6jtlWtc z%l)@Z%$a!6g%@7%|8;itK62Dh+&Ux_p$I4_5Fl|9w6QKxq9onkXYQn265XBnDsX0J zJhz*homqBfb9+=s(9lE(D1s1DBq|yR9UU|v@dqHKLeLG)>M$9F>PI1*9=XpLJSL=8I%K2YZwURDyT&Fp> zWUMB{=DS18u-C+aHCw|F!$h5P-BogteI1N#XM{RqgyL`zjX*fiN=DA0lMWASFqHYk; zYb4tG+9hod^Ryay54=$%WwQ@VJ8N!C4a19E(ILIB3;6K9ZGt_X;vsU?i&sYzjSvsF+t@2V) ztTS6Uz=l>~f64UBGO!d;L^e3uB#|qYS3t<#jglGmtwNV}P2SpD-Q851*EX;{+P#wR zX@vZag+bbQ^V;g}&N`$zC5VP-HZOcRuQs=pt!;Z_&#wm8x3=~-57fcx+SN^Jp&0g4 zmDW?UcM8lpUEc2Xu3X(&TUY1gIe7tlsMaAzsc|zfHaOBJiegb>Jxlu4q>1J9WKvej z1ZIN;!csV1Iz9<`qay^C3t84{6h%wZD#46?3SqOo~v!NS- zw9v^!PU|u5S9ila@B53jVCC2rU)@`!ZPlYom3R24$4yh6#G$ULZmjXp2)`&glmlS z%o|-q)`N1RsniI+DO3@05X9{#M@Q1VKh1$6ed^Ri<0(@qoK{V8`Ge$i; z-i;MMAF{P?V@TOcN7!#?c;uoP9pXFwPm@TDOccRbW?YR;=dpmXnhS=2RMIfDu3sKauK{d8DlXNH-OL=BR9AY^t@qCT59 z6IPq~KnoG|Opa-1KboPHC|G@mb{?;R-JG*=-=9g<=F z9b3?Q7_uqj`5f90PH@`^a{G+u{(s=`Yfg^OtDVAo0!lMyKf)6x#@_*t?CQ+r&$YdW z_Xd<+u$jNc!f>B9Zz^OAr6Xa%-kc7iTj4oUF@^dl8lB0l5aiul}}ZXUU)LEQMs0_k7+P@>;O r-oYQ+jn^-lUtV|Ib6Wn@-d%F*2=lpJrs>`0BK#W Date: Wed, 27 Nov 2019 23:46:17 -0800 Subject: [PATCH 15/15] Add files via upload --- projects/alghanmz/a3/dominion.c | 1420 ++++++++++++++++ projects/alghanmz/a3/dominion.c.gcov | 1961 ++++++++++++++++++++++ projects/alghanmz/a3/dominion.gcda | Bin 0 -> 5848 bytes projects/alghanmz/a3/dominion.gcno | Bin 0 -> 41668 bytes projects/alghanmz/a3/dominion.h | 131 ++ projects/alghanmz/a3/dominion.o | Bin 0 -> 53784 bytes projects/alghanmz/a3/dominion_helpers.h | 15 + projects/alghanmz/a3/rngs.c | 183 ++ projects/alghanmz/a3/rngs.gcda | Bin 0 -> 2664 bytes projects/alghanmz/a3/rngs.gcno | Bin 0 -> 4032 bytes projects/alghanmz/a3/rngs.h | 19 + projects/alghanmz/a3/rngs.o | Bin 0 -> 11728 bytes projects/alghanmz/a3/unittest1 | Bin 0 -> 62552 bytes projects/alghanmz/a3/unittest1.gcda | Bin 0 -> 936 bytes projects/alghanmz/a3/unittest1.gcno | Bin 0 -> 3924 bytes projects/alghanmz/a3/unittest2 | Bin 0 -> 62352 bytes projects/alghanmz/a3/unittest2.gcda | Bin 0 -> 792 bytes projects/alghanmz/a3/unittest2.gcno | Bin 0 -> 2512 bytes projects/alghanmz/a3/unittest3 | Bin 0 -> 62552 bytes projects/alghanmz/a3/unittest3.gcda | Bin 0 -> 836 bytes projects/alghanmz/a3/unittest3.gcno | Bin 0 -> 3216 bytes projects/alghanmz/a3/unittest4 | Bin 0 -> 62552 bytes projects/alghanmz/a3/unittest4.gcda | Bin 0 -> 904 bytes projects/alghanmz/a3/unittest4.gcno | Bin 0 -> 3900 bytes projects/alghanmz/a3/unittest5 | Bin 0 -> 62552 bytes projects/alghanmz/a3/unittest5.gcda | Bin 0 -> 812 bytes projects/alghanmz/a3/unittest5.gcno | Bin 0 -> 3096 bytes projects/alghanmz/a3/unittestresults.out | 963 +++++++++++ 28 files changed, 4692 insertions(+) create mode 100644 projects/alghanmz/a3/dominion.c create mode 100644 projects/alghanmz/a3/dominion.c.gcov create mode 100644 projects/alghanmz/a3/dominion.gcda create mode 100644 projects/alghanmz/a3/dominion.gcno create mode 100644 projects/alghanmz/a3/dominion.h create mode 100644 projects/alghanmz/a3/dominion.o create mode 100644 projects/alghanmz/a3/dominion_helpers.h create mode 100644 projects/alghanmz/a3/rngs.c create mode 100644 projects/alghanmz/a3/rngs.gcda create mode 100644 projects/alghanmz/a3/rngs.gcno create mode 100644 projects/alghanmz/a3/rngs.h create mode 100644 projects/alghanmz/a3/rngs.o create mode 100644 projects/alghanmz/a3/unittest1 create mode 100644 projects/alghanmz/a3/unittest1.gcda create mode 100644 projects/alghanmz/a3/unittest1.gcno create mode 100644 projects/alghanmz/a3/unittest2 create mode 100644 projects/alghanmz/a3/unittest2.gcda create mode 100644 projects/alghanmz/a3/unittest2.gcno create mode 100644 projects/alghanmz/a3/unittest3 create mode 100644 projects/alghanmz/a3/unittest3.gcda create mode 100644 projects/alghanmz/a3/unittest3.gcno create mode 100644 projects/alghanmz/a3/unittest4 create mode 100644 projects/alghanmz/a3/unittest4.gcda create mode 100644 projects/alghanmz/a3/unittest4.gcno create mode 100644 projects/alghanmz/a3/unittest5 create mode 100644 projects/alghanmz/a3/unittest5.gcda create mode 100644 projects/alghanmz/a3/unittest5.gcno create mode 100644 projects/alghanmz/a3/unittestresults.out diff --git a/projects/alghanmz/a3/dominion.c b/projects/alghanmz/a3/dominion.c new file mode 100644 index 000000000..0c865f97e --- /dev/null +++ b/projects/alghanmz/a3/dominion.c @@ -0,0 +1,1420 @@ +#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 doMine(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) +{ + int i; + int j; + + 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; +} + +void getEstateCard(struct gameState *state, int currentPlayer) +{ + 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); + } + } +} + +void doBaron(int choice1, struct gameState *state, int currentPlayer) +{ + state->numBuys++;//Increase buys by 1! + state->numBuys++;//Increase buys by 1! + if (choice1 > 0) { //Boolean true or going to discard an estate + int p = 1; //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"); + } + getEstateCard(state, currentPlayer); + card_not_discarded = 0;//Exit the loop + } + + else { + p++;//Next card + } + } + } + + else { + getEstateCard(state, currentPlayer); + } +} + +void doMinion(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) +{ + int i; + int j; + + //+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) > 1 /*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); + } + } + } + } + } +} + +void printDeck(struct gameState *state, int p) { + printf("Deck:"); + for (int i=0; i < state->deckCount[p]; i++) + printf(" %d", state->deck[p][i]); + printf("\n"); +} + +void printHand(struct gameState *state, int p) { + printf("Hand:"); + for (int i=0; i < state->handCount[p]; i++) + printf(" %d", state->hand[p][i]); + printf("\n"); +} + +void doTribute(struct gameState *state, int currentPlayer, int nextPlayer, int tributeRevealedCards[2]) +{ + int i; + + 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]; + tributeRevealedCards[1] = state->deck[nextPlayer][state->deckCount[nextPlayer]-2]; + //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->numActions = state->numActions + 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->coins += 2; + } + } +} + +int doAmbassador(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) +{ + int i; + int j; + + j = 0; //used to check if player has enough cards to discard + + if (choice2 > 3 || choice2 < 0) + { + return -1; + } + +/* + if (choice1 == handPos) + { + return -1; + } + */ + + for (i = 0; i < state->handCount[currentPlayer]; i++) + { + if (i != handPos && state->hand[currentPlayer][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; +} + +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: + return doMine(choice1, choice2, state, handPos, currentPlayer); + + 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: + doBaron(choice1, state, currentPlayer); + 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: + doMinion(choice1, choice2, state, handPos, currentPlayer); + 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: + doTribute(state, currentPlayer, nextPlayer, tributeRevealedCards); + return 0; + + case ambassador: + return doAmbassador(choice1, choice2, state, handPos, currentPlayer); + + 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/alghanmz/a3/dominion.c.gcov b/projects/alghanmz/a3/dominion.c.gcov new file mode 100644 index 000000000..3292286c4 --- /dev/null +++ b/projects/alghanmz/a3/dominion.c.gcov @@ -0,0 +1,1961 @@ + -: 0:Source:dominion.c + -: 0:Graph:dominion.gcno + -: 0:Data:dominion.gcda + -: 0:Runs:5 + -: 0:Programs:5 + -: 1:#include "dominion.h" + -: 2:#include "dominion_helpers.h" + -: 3:#include "rngs.h" + -: 4:#include + -: 5:#include + -: 6:#include + -: 7: +function compare called 180 returned 100% blocks executed 83% + 180: 8:int compare(const void* a, const void* b) { + 180: 9: if (*(int*)a > *(int*)b) +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + #####: 10: return 1; + 180: 11: if (*(int*)a < *(int*)b) +branch 0 taken 27% (fallthrough) +branch 1 taken 73% + 48: 12: return -1; + 132: 13: return 0; + -: 14:} + -: 15: +function newGame called 0 returned 0% blocks executed 0% + #####: 16:struct gameState* newGame() { + #####: 17: struct gameState* g = malloc(sizeof(struct gameState)); + #####: 18: return g; + -: 19:} + -: 20: +function kingdomCards called 0 returned 0% blocks executed 0% + #####: 21:int* kingdomCards(int k1, int k2, int k3, int k4, int k5, int k6, int k7, + -: 22: int k8, int k9, int k10) { + #####: 23: int* k = malloc(10 * sizeof(int)); + #####: 24: k[0] = k1; + #####: 25: k[1] = k2; + #####: 26: k[2] = k3; + #####: 27: k[3] = k4; + #####: 28: k[4] = k5; + #####: 29: k[5] = k6; + #####: 30: k[6] = k7; + #####: 31: k[7] = k8; + #####: 32: k[8] = k9; + #####: 33: k[9] = k10; + #####: 34: return k; + -: 35:} + -: 36: +function initializeGame called 5 returned 100% blocks executed 94% + 5: 37:int initializeGame(int numPlayers, int kingdomCards[10], int randomSeed, + -: 38: struct gameState *state) { + -: 39: int i; + -: 40: int j; + -: 41: int it; + -: 42: + -: 43: //set up random number generator + 5: 44: SelectStream(1); +call 0 returned 100% + 5: 45: PutSeed((long)randomSeed); +call 0 returned 100% + -: 46: + -: 47: //check number of players + 5: 48: if (numPlayers > MAX_PLAYERS || numPlayers < 2) +branch 0 taken 100% (fallthrough) +branch 1 taken 0% +branch 2 taken 0% (fallthrough) +branch 3 taken 100% + -: 49: { + #####: 50: return -1; + -: 51: } + -: 52: + -: 53: //set number of players + 5: 54: state->numPlayers = numPlayers; + -: 55: + -: 56: //check selected kingdom cards are different + 55: 57: for (i = 0; i < 10; i++) +branch 0 taken 91% +branch 1 taken 9% (fallthrough) + -: 58: { + 550: 59: for (j = 0; j < 10; j++) +branch 0 taken 91% +branch 1 taken 9% (fallthrough) + -: 60: { + 500: 61: if (j != i && kingdomCards[j] == kingdomCards[i]) +branch 0 taken 90% (fallthrough) +branch 1 taken 10% +branch 2 taken 0% (fallthrough) +branch 3 taken 100% + -: 62: { + #####: 63: return -1; + -: 64: } + -: 65: } + -: 66: } + -: 67: + -: 68: + -: 69: //initialize supply + -: 70: /////////////////////////////// + -: 71: + -: 72: //set number of Curse cards + 5: 73: if (numPlayers == 2) +branch 0 taken 80% (fallthrough) +branch 1 taken 20% + -: 74: { + 4: 75: state->supplyCount[curse] = 10; + -: 76: } + 1: 77: else if (numPlayers == 3) +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + -: 78: { + #####: 79: state->supplyCount[curse] = 20; + -: 80: } + -: 81: else + -: 82: { + 1: 83: state->supplyCount[curse] = 30; + -: 84: } + -: 85: + -: 86: //set number of Victory cards + 5: 87: if (numPlayers == 2) +branch 0 taken 80% (fallthrough) +branch 1 taken 20% + -: 88: { + 4: 89: state->supplyCount[estate] = 8; + 4: 90: state->supplyCount[duchy] = 8; + 4: 91: state->supplyCount[province] = 8; + -: 92: } + -: 93: else + -: 94: { + 1: 95: state->supplyCount[estate] = 12; + 1: 96: state->supplyCount[duchy] = 12; + 1: 97: state->supplyCount[province] = 12; + -: 98: } + -: 99: + -: 100: //set number of Treasure cards + 5: 101: state->supplyCount[copper] = 60 - (7 * numPlayers); + 5: 102: state->supplyCount[silver] = 40; + 5: 103: state->supplyCount[gold] = 30; + -: 104: + -: 105: //set number of Kingdom cards + 105: 106: for (i = adventurer; i <= treasure_map; i++) //loop all cards +branch 0 taken 95% +branch 1 taken 5% (fallthrough) + -: 107: { + 825: 108: for (j = 0; j < 10; j++) //loop chosen cards +branch 0 taken 94% +branch 1 taken 6% (fallthrough) + -: 109: { + 775: 110: if (kingdomCards[j] == i) +branch 0 taken 6% (fallthrough) +branch 1 taken 94% + -: 111: { + -: 112: //check if card is a 'Victory' Kingdom card + 50: 113: if (kingdomCards[j] == great_hall || kingdomCards[j] == gardens) +branch 0 taken 90% (fallthrough) +branch 1 taken 10% +branch 2 taken 11% (fallthrough) +branch 3 taken 89% + -: 114: { + 20: 115: if (numPlayers == 2) { +branch 0 taken 80% (fallthrough) +branch 1 taken 20% + 8: 116: state->supplyCount[i] = 8; + -: 117: } + -: 118: else { + 2: 119: state->supplyCount[i] = 12; + -: 120: } + -: 121: } + -: 122: else + -: 123: { + 40: 124: state->supplyCount[i] = 10; + -: 125: } + 50: 126: break; + -: 127: } + -: 128: else //card is not in the set choosen for the game + -: 129: { + 725: 130: state->supplyCount[i] = -1; + -: 131: } + -: 132: } + -: 133: + -: 134: } + -: 135: + -: 136: //////////////////////// + -: 137: //supply intilization complete + -: 138: + -: 139: //set player decks + 17: 140: for (i = 0; i < numPlayers; i++) +branch 0 taken 71% +branch 1 taken 29% (fallthrough) + -: 141: { + 12: 142: state->deckCount[i] = 0; + 48: 143: for (j = 0; j < 3; j++) +branch 0 taken 75% +branch 1 taken 25% (fallthrough) + -: 144: { + 36: 145: state->deck[i][j] = estate; + 36: 146: state->deckCount[i]++; + -: 147: } + 96: 148: for (j = 3; j < 10; j++) +branch 0 taken 88% +branch 1 taken 13% (fallthrough) + -: 149: { + 84: 150: state->deck[i][j] = copper; + 84: 151: state->deckCount[i]++; + -: 152: } + -: 153: } + -: 154: + -: 155: //shuffle player decks + 17: 156: for (i = 0; i < numPlayers; i++) +branch 0 taken 71% +branch 1 taken 29% (fallthrough) + -: 157: { + 12: 158: if ( shuffle(i, state) < 0 ) +call 0 returned 100% +branch 1 taken 0% (fallthrough) +branch 2 taken 100% + -: 159: { + #####: 160: return -1; + -: 161: } + -: 162: } + -: 163: + -: 164: //draw player hands + 17: 165: for (i = 0; i < numPlayers; i++) +branch 0 taken 71% +branch 1 taken 29% (fallthrough) + -: 166: { + -: 167: //initialize hand size to zero + 12: 168: state->handCount[i] = 0; + 12: 169: state->discardCount[i] = 0; + -: 170: //draw 5 cards + -: 171: // for (j = 0; j < 5; j++) + -: 172: // { + -: 173: // drawCard(i, state); + -: 174: // } + -: 175: } + -: 176: + -: 177: //set embargo tokens to 0 for all supply piles + 140: 178: for (i = 0; i <= treasure_map; i++) +branch 0 taken 96% +branch 1 taken 4% (fallthrough) + -: 179: { + 135: 180: state->embargoTokens[i] = 0; + -: 181: } + -: 182: + -: 183: //initialize first player's turn + 5: 184: state->outpostPlayed = 0; + 5: 185: state->phase = 0; + 5: 186: state->numActions = 1; + 5: 187: state->numBuys = 1; + 5: 188: state->playedCardCount = 0; + 5: 189: state->whoseTurn = 0; + 5: 190: state->handCount[state->whoseTurn] = 0; + -: 191: //int it; move to top + -: 192: + -: 193: //Moved draw cards to here, only drawing at the start of a turn + 30: 194: for (it = 0; it < 5; it++) { +branch 0 taken 83% +branch 1 taken 17% (fallthrough) + 25: 195: drawCard(state->whoseTurn, state); +call 0 returned 100% + -: 196: } + -: 197: + 5: 198: updateCoins(state->whoseTurn, state, 0); +call 0 returned 100% + -: 199: + 5: 200: return 0; + -: 201:} + -: 202: +function shuffle called 13 returned 100% blocks executed 94% + 13: 203:int shuffle(int player, struct gameState *state) { + -: 204: + -: 205: + -: 206: int newDeck[MAX_DECK]; + 13: 207: int newDeckPos = 0; + -: 208: int card; + -: 209: int i; + -: 210: + 13: 211: if (state->deckCount[player] < 1) +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + #####: 212: return -1; + 13: 213: qsort ((void*)(state->deck[player]), state->deckCount[player], sizeof(int), compare); +call 0 returned 100% + -: 214: /* SORT CARDS IN DECK TO ENSURE DETERMINISM! */ + -: 215: + 147: 216: while (state->deckCount[player] > 0) { +branch 0 taken 90% +branch 1 taken 10% (fallthrough) + 121: 217: card = floor(Random() * state->deckCount[player]); +call 0 returned 100% + 121: 218: newDeck[newDeckPos] = state->deck[player][card]; + 121: 219: newDeckPos++; + 442: 220: for (i = card; i < state->deckCount[player]-1; i++) { +branch 0 taken 73% +branch 1 taken 27% (fallthrough) + 321: 221: state->deck[player][i] = state->deck[player][i+1]; + -: 222: } + 121: 223: state->deckCount[player]--; + -: 224: } + 134: 225: for (i = 0; i < newDeckPos; i++) { +branch 0 taken 90% +branch 1 taken 10% (fallthrough) + 121: 226: state->deck[player][i] = newDeck[i]; + 121: 227: state->deckCount[player]++; + -: 228: } + -: 229: + 13: 230: return 0; + -: 231:} + -: 232: +function playCard called 0 returned 0% blocks executed 0% + #####: 233:int playCard(int handPos, int choice1, int choice2, int choice3, struct gameState *state) + -: 234:{ + -: 235: int card; + #####: 236: int coin_bonus = 0; //tracks coins gain from actions + -: 237: + -: 238: //check if it is the right phase + #####: 239: if (state->phase != 0) +branch 0 never executed +branch 1 never executed + -: 240: { + #####: 241: return -1; + -: 242: } + -: 243: + -: 244: //check if player has enough actions + #####: 245: if ( state->numActions < 1 ) +branch 0 never executed +branch 1 never executed + -: 246: { + #####: 247: return -1; + -: 248: } + -: 249: + -: 250: //get card played + #####: 251: card = handCard(handPos, state); +call 0 never executed + -: 252: + -: 253: //check if selected card is an action + #####: 254: if ( card < adventurer || card > treasure_map ) +branch 0 never executed +branch 1 never executed +branch 2 never executed +branch 3 never executed + -: 255: { + #####: 256: return -1; + -: 257: } + -: 258: + -: 259: //play card + #####: 260: if ( cardEffect(card, choice1, choice2, choice3, state, handPos, &coin_bonus) < 0 ) +call 0 never executed +branch 1 never executed +branch 2 never executed + -: 261: { + #####: 262: return -1; + -: 263: } + -: 264: + -: 265: //reduce number of actions + #####: 266: state->numActions--; + -: 267: + -: 268: //update coins (Treasure cards may be added with card draws) + #####: 269: updateCoins(state->whoseTurn, state, coin_bonus); +call 0 never executed + -: 270: + #####: 271: return 0; + -: 272:} + -: 273: +function buyCard called 0 returned 0% blocks executed 0% + #####: 274:int buyCard(int supplyPos, struct gameState *state) { + -: 275: int who; + -: 276: if (DEBUG) { + -: 277: printf("Entering buyCard...\n"); + -: 278: } + -: 279: + -: 280: // I don't know what to do about the phase thing. + -: 281: + #####: 282: who = state->whoseTurn; + -: 283: + #####: 284: if (state->numBuys < 1) { +branch 0 never executed +branch 1 never executed + -: 285: if (DEBUG) + -: 286: printf("You do not have any buys left\n"); + #####: 287: return -1; + #####: 288: } else if (supplyCount(supplyPos, state) <1) { +call 0 never executed +branch 1 never executed +branch 2 never executed + -: 289: if (DEBUG) + -: 290: printf("There are not any of that type of card left\n"); + #####: 291: return -1; + #####: 292: } else if (state->coins < getCost(supplyPos)) { +call 0 never executed +branch 1 never executed +branch 2 never executed + -: 293: if (DEBUG) + -: 294: printf("You do not have enough money to buy that. You have %d coins.\n", state->coins); + #####: 295: return -1; + -: 296: } else { + #####: 297: state->phase=1; + -: 298: //state->supplyCount[supplyPos]--; + #####: 299: gainCard(supplyPos, state, 0, who); //card goes in discard, this might be wrong.. (2 means goes into hand, 0 goes into discard) +call 0 never executed + -: 300: + #####: 301: state->coins = (state->coins) - (getCost(supplyPos)); +call 0 never executed + #####: 302: state->numBuys--; + -: 303: if (DEBUG) + -: 304: 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); + -: 305: } + -: 306: + -: 307: //state->discard[who][state->discardCount[who]] = supplyPos; + -: 308: //state->discardCount[who]++; + -: 309: + #####: 310: return 0; + -: 311:} + -: 312: +function numHandCards called 4 returned 100% blocks executed 100% + 4: 313:int numHandCards(struct gameState *state) { + 4: 314: return state->handCount[ whoseTurn(state) ]; +call 0 returned 100% + -: 315:} + -: 316: +function handCard called 0 returned 0% blocks executed 0% + #####: 317:int handCard(int handPos, struct gameState *state) { + #####: 318: int currentPlayer = whoseTurn(state); +call 0 never executed + #####: 319: return state->hand[currentPlayer][handPos]; + -: 320:} + -: 321: +function supplyCount called 8 returned 100% blocks executed 100% + 8: 322:int supplyCount(int card, struct gameState *state) { + 8: 323: return state->supplyCount[card]; + -: 324:} + -: 325: +function fullDeckCount called 0 returned 0% blocks executed 0% + #####: 326:int fullDeckCount(int player, int card, struct gameState *state) { + -: 327: int i; + #####: 328: int count = 0; + -: 329: + #####: 330: for (i = 0; i < state->deckCount[player]; i++) +branch 0 never executed +branch 1 never executed + -: 331: { + #####: 332: if (state->deck[player][i] == card) count++; +branch 0 never executed +branch 1 never executed + -: 333: } + -: 334: + #####: 335: for (i = 0; i < state->handCount[player]; i++) +branch 0 never executed +branch 1 never executed + -: 336: { + #####: 337: if (state->hand[player][i] == card) count++; +branch 0 never executed +branch 1 never executed + -: 338: } + -: 339: + #####: 340: for (i = 0; i < state->discardCount[player]; i++) +branch 0 never executed +branch 1 never executed + -: 341: { + #####: 342: if (state->discard[player][i] == card) count++; +branch 0 never executed +branch 1 never executed + -: 343: } + -: 344: + #####: 345: return count; + -: 346:} + -: 347: +function whoseTurn called 4 returned 100% blocks executed 100% + 4: 348:int whoseTurn(struct gameState *state) { + 4: 349: return state->whoseTurn; + -: 350:} + -: 351: +function endTurn called 0 returned 0% blocks executed 0% + #####: 352:int endTurn(struct gameState *state) { + -: 353: int k; + -: 354: int i; + #####: 355: int currentPlayer = whoseTurn(state); +call 0 never executed + -: 356: + -: 357: //Discard hand + #####: 358: for (i = 0; i < state->handCount[currentPlayer]; i++) { +branch 0 never executed +branch 1 never executed + #####: 359: state->discard[currentPlayer][state->discardCount[currentPlayer]++] = state->hand[currentPlayer][i];//Discard + #####: 360: state->hand[currentPlayer][i] = -1;//Set card to -1 + -: 361: } + #####: 362: state->handCount[currentPlayer] = 0;//Reset hand count + -: 363: + -: 364: //Code for determining the player + #####: 365: if (currentPlayer < (state->numPlayers - 1)) { +branch 0 never executed +branch 1 never executed + #####: 366: state->whoseTurn = currentPlayer + 1;//Still safe to increment + -: 367: } + -: 368: else { + #####: 369: state->whoseTurn = 0;//Max player has been reached, loop back around to player 1 + -: 370: } + -: 371: + #####: 372: state->outpostPlayed = 0; + #####: 373: state->phase = 0; + #####: 374: state->numActions = 1; + #####: 375: state->coins = 0; + #####: 376: state->numBuys = 1; + #####: 377: state->playedCardCount = 0; + #####: 378: state->handCount[state->whoseTurn] = 0; + -: 379: + -: 380: //int k; move to top + -: 381: //Next player draws hand + #####: 382: for (k = 0; k < 5; k++) { +branch 0 never executed +branch 1 never executed + #####: 383: drawCard(state->whoseTurn, state);//Draw a card +call 0 never executed + -: 384: } + -: 385: + -: 386: //Update money + #####: 387: updateCoins(state->whoseTurn, state, 0); +call 0 never executed + -: 388: + #####: 389: return 0; + -: 390:} + -: 391: +function isGameOver called 0 returned 0% blocks executed 0% + #####: 392:int isGameOver(struct gameState *state) { + -: 393: int i; + -: 394: int j; + -: 395: + -: 396: //if stack of Province cards is empty, the game ends + #####: 397: if (state->supplyCount[province] == 0) +branch 0 never executed +branch 1 never executed + -: 398: { + #####: 399: return 1; + -: 400: } + -: 401: + -: 402: //if three supply pile are at 0, the game ends + #####: 403: j = 0; + #####: 404: for (i = 0; i < 25; i++) +branch 0 never executed +branch 1 never executed + -: 405: { + #####: 406: if (state->supplyCount[i] == 0) +branch 0 never executed +branch 1 never executed + -: 407: { + #####: 408: j++; + -: 409: } + -: 410: } + #####: 411: if ( j >= 3) +branch 0 never executed +branch 1 never executed + -: 412: { + #####: 413: return 1; + -: 414: } + -: 415: + #####: 416: return 0; + -: 417:} + -: 418: +function scoreFor called 0 returned 0% blocks executed 0% + #####: 419:int scoreFor (int player, struct gameState *state) { + -: 420: + -: 421: int i; + #####: 422: int score = 0; + -: 423: //score from hand + #####: 424: for (i = 0; i < state->handCount[player]; i++) +branch 0 never executed +branch 1 never executed + -: 425: { + #####: 426: if (state->hand[player][i] == curse) { +branch 0 never executed +branch 1 never executed + #####: 427: score = score - 1; + -: 428: }; + #####: 429: if (state->hand[player][i] == estate) { +branch 0 never executed +branch 1 never executed + #####: 430: score = score + 1; + -: 431: }; + #####: 432: if (state->hand[player][i] == duchy) { +branch 0 never executed +branch 1 never executed + #####: 433: score = score + 3; + -: 434: }; + #####: 435: if (state->hand[player][i] == province) { +branch 0 never executed +branch 1 never executed + #####: 436: score = score + 6; + -: 437: }; + #####: 438: if (state->hand[player][i] == great_hall) { +branch 0 never executed +branch 1 never executed + #####: 439: score = score + 1; + -: 440: }; + #####: 441: if (state->hand[player][i] == gardens) { +branch 0 never executed +branch 1 never executed + #####: 442: score = score + ( fullDeckCount(player, 0, state) / 10 ); +call 0 never executed + -: 443: }; + -: 444: } + -: 445: + -: 446: //score from discard + #####: 447: for (i = 0; i < state->discardCount[player]; i++) +branch 0 never executed +branch 1 never executed + -: 448: { + #####: 449: if (state->discard[player][i] == curse) { +branch 0 never executed +branch 1 never executed + #####: 450: score = score - 1; + -: 451: }; + #####: 452: if (state->discard[player][i] == estate) { +branch 0 never executed +branch 1 never executed + #####: 453: score = score + 1; + -: 454: }; + #####: 455: if (state->discard[player][i] == duchy) { +branch 0 never executed +branch 1 never executed + #####: 456: score = score + 3; + -: 457: }; + #####: 458: if (state->discard[player][i] == province) { +branch 0 never executed +branch 1 never executed + #####: 459: score = score + 6; + -: 460: }; + #####: 461: if (state->discard[player][i] == great_hall) { +branch 0 never executed +branch 1 never executed + #####: 462: score = score + 1; + -: 463: }; + #####: 464: if (state->discard[player][i] == gardens) { +branch 0 never executed +branch 1 never executed + #####: 465: score = score + ( fullDeckCount(player, 0, state) / 10 ); +call 0 never executed + -: 466: }; + -: 467: } + -: 468: + -: 469: //score from deck + #####: 470: for (i = 0; i < state->discardCount[player]; i++) +branch 0 never executed +branch 1 never executed + -: 471: { + #####: 472: if (state->deck[player][i] == curse) { +branch 0 never executed +branch 1 never executed + #####: 473: score = score - 1; + -: 474: }; + #####: 475: if (state->deck[player][i] == estate) { +branch 0 never executed +branch 1 never executed + #####: 476: score = score + 1; + -: 477: }; + #####: 478: if (state->deck[player][i] == duchy) { +branch 0 never executed +branch 1 never executed + #####: 479: score = score + 3; + -: 480: }; + #####: 481: if (state->deck[player][i] == province) { +branch 0 never executed +branch 1 never executed + #####: 482: score = score + 6; + -: 483: }; + #####: 484: if (state->deck[player][i] == great_hall) { +branch 0 never executed +branch 1 never executed + #####: 485: score = score + 1; + -: 486: }; + #####: 487: if (state->deck[player][i] == gardens) { +branch 0 never executed +branch 1 never executed + #####: 488: score = score + ( fullDeckCount(player, 0, state) / 10 ); +call 0 never executed + -: 489: }; + -: 490: } + -: 491: + #####: 492: return score; + -: 493:} + -: 494: +function getWinners called 0 returned 0% blocks executed 0% + #####: 495:int getWinners(int players[MAX_PLAYERS], struct gameState *state) { + -: 496: int i; + -: 497: int j; + -: 498: int highScore; + -: 499: int currentPlayer; + -: 500: + -: 501: //get score for each player + #####: 502: for (i = 0; i < MAX_PLAYERS; i++) +branch 0 never executed +branch 1 never executed + -: 503: { + -: 504: //set unused player scores to -9999 + #####: 505: if (i >= state->numPlayers) +branch 0 never executed +branch 1 never executed + -: 506: { + #####: 507: players[i] = -9999; + -: 508: } + -: 509: else + -: 510: { + #####: 511: players[i] = scoreFor (i, state); +call 0 never executed + -: 512: } + -: 513: } + -: 514: + -: 515: //find highest score + #####: 516: j = 0; + #####: 517: for (i = 0; i < MAX_PLAYERS; i++) +branch 0 never executed +branch 1 never executed + -: 518: { + #####: 519: if (players[i] > players[j]) +branch 0 never executed +branch 1 never executed + -: 520: { + #####: 521: j = i; + -: 522: } + -: 523: } + #####: 524: highScore = players[j]; + -: 525: + -: 526: //add 1 to players who had less turns + #####: 527: currentPlayer = whoseTurn(state); +call 0 never executed + #####: 528: for (i = 0; i < MAX_PLAYERS; i++) +branch 0 never executed +branch 1 never executed + -: 529: { + #####: 530: if ( players[i] == highScore && i > currentPlayer ) +branch 0 never executed +branch 1 never executed +branch 2 never executed +branch 3 never executed + -: 531: { + #####: 532: players[i]++; + -: 533: } + -: 534: } + -: 535: + -: 536: //find new highest score + #####: 537: j = 0; + #####: 538: for (i = 0; i < MAX_PLAYERS; i++) +branch 0 never executed +branch 1 never executed + -: 539: { + #####: 540: if ( players[i] > players[j] ) +branch 0 never executed +branch 1 never executed + -: 541: { + #####: 542: j = i; + -: 543: } + -: 544: } + #####: 545: highScore = players[j]; + -: 546: + -: 547: //set winners in array to 1 and rest to 0 + #####: 548: for (i = 0; i < MAX_PLAYERS; i++) +branch 0 never executed +branch 1 never executed + -: 549: { + #####: 550: if ( players[i] == highScore ) +branch 0 never executed +branch 1 never executed + -: 551: { + #####: 552: players[i] = 1; + -: 553: } + -: 554: else + -: 555: { + #####: 556: players[i] = 0; + -: 557: } + -: 558: } + -: 559: + #####: 560: return 0; + -: 561:} + -: 562: +function drawCard called 43 returned 100% blocks executed 38% + 43: 563:int drawCard(int player, struct gameState *state) + -: 564:{ int count; + -: 565: int deckCounter; + 43: 566: if (state->deckCount[player] <= 0) { //Deck is empty +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + -: 567: + -: 568: //Step 1 Shuffle the discard pile back into a deck + -: 569: int i; + -: 570: //Move discard to deck + #####: 571: for (i = 0; i < state->discardCount[player]; i++) { +branch 0 never executed +branch 1 never executed + #####: 572: state->deck[player][i] = state->discard[player][i]; + #####: 573: state->discard[player][i] = -1; + -: 574: } + -: 575: + #####: 576: state->deckCount[player] = state->discardCount[player]; + #####: 577: state->discardCount[player] = 0;//Reset discard + -: 578: + -: 579: //Shufffle the deck + #####: 580: shuffle(player, state);//Shuffle the deck up and make it so that we can draw +call 0 never executed + -: 581: + -: 582: if (DEBUG) { //Debug statements + -: 583: printf("Deck count now: %d\n", state->deckCount[player]); + -: 584: } + -: 585: + #####: 586: state->discardCount[player] = 0; + -: 587: + -: 588: //Step 2 Draw Card + #####: 589: count = state->handCount[player];//Get current player's hand count + -: 590: + -: 591: if (DEBUG) { //Debug statements + -: 592: printf("Current hand count: %d\n", count); + -: 593: } + -: 594: + #####: 595: deckCounter = state->deckCount[player];//Create a holder for the deck count + -: 596: + #####: 597: if (deckCounter == 0) +branch 0 never executed +branch 1 never executed + #####: 598: return -1; + -: 599: + #####: 600: state->hand[player][count] = state->deck[player][deckCounter - 1];//Add card to hand + #####: 601: state->deckCount[player]--; + #####: 602: state->handCount[player]++;//Increment hand count + -: 603: } + -: 604: + -: 605: else { + 43: 606: int count = state->handCount[player];//Get current hand count for player + -: 607: int deckCounter; + -: 608: if (DEBUG) { //Debug statements + -: 609: printf("Current hand count: %d\n", count); + -: 610: } + -: 611: + 43: 612: deckCounter = state->deckCount[player];//Create holder for the deck count + 43: 613: state->hand[player][count] = state->deck[player][deckCounter - 1];//Add card to the hand + 43: 614: state->deckCount[player]--; + 43: 615: state->handCount[player]++;//Increment hand count + -: 616: } + -: 617: + 43: 618: return 0; + -: 619:} + -: 620: +function getCost called 4 returned 100% blocks executed 17% + 4: 621:int getCost(int cardNumber) + -: 622:{ + 4: 623: switch( cardNumber ) +branch 0 taken 25% +branch 1 taken 0% +branch 2 taken 0% +branch 3 taken 0% +branch 4 taken 25% +branch 5 taken 50% +branch 6 taken 0% +branch 7 taken 0% +branch 8 taken 0% +branch 9 taken 0% +branch 10 taken 0% +branch 11 taken 0% +branch 12 taken 0% +branch 13 taken 0% +branch 14 taken 0% +branch 15 taken 0% +branch 16 taken 0% +branch 17 taken 0% +branch 18 taken 0% +branch 19 taken 0% +branch 20 taken 0% +branch 21 taken 0% +branch 22 taken 0% +branch 23 taken 0% +branch 24 taken 0% +branch 25 taken 0% +branch 26 taken 0% +branch 27 taken 0% + -: 624: { + -: 625: case curse: + 1: 626: return 0; + -: 627: case estate: + #####: 628: return 2; + -: 629: case duchy: + #####: 630: return 5; + -: 631: case province: + #####: 632: return 8; + -: 633: case copper: + 1: 634: return 0; + -: 635: case silver: + 2: 636: return 3; + -: 637: case gold: + #####: 638: return 6; + -: 639: case adventurer: + #####: 640: return 6; + -: 641: case council_room: + #####: 642: return 5; + -: 643: case feast: + #####: 644: return 4; + -: 645: case gardens: + #####: 646: return 4; + -: 647: case mine: + #####: 648: return 5; + -: 649: case remodel: + #####: 650: return 4; + -: 651: case smithy: + #####: 652: return 4; + -: 653: case village: + #####: 654: return 3; + -: 655: case baron: + #####: 656: return 4; + -: 657: case great_hall: + #####: 658: return 3; + -: 659: case minion: + #####: 660: return 5; + -: 661: case steward: + #####: 662: return 3; + -: 663: case tribute: + #####: 664: return 5; + -: 665: case ambassador: + #####: 666: return 3; + -: 667: case cutpurse: + #####: 668: return 4; + -: 669: case embargo: + #####: 670: return 2; + -: 671: case outpost: + #####: 672: return 5; + -: 673: case salvager: + #####: 674: return 4; + -: 675: case sea_hag: + #####: 676: return 4; + -: 677: case treasure_map: + #####: 678: return 4; + -: 679: } + -: 680: + #####: 681: return -1; + -: 682:} + -: 683: +function doMine called 3 returned 100% blocks executed 83% + 3: 684:int doMine(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) + -: 685:{ + -: 686: int i; + -: 687: int j; + -: 688: + 3: 689: j = state->hand[currentPlayer][choice1]; //store card we will trash + -: 690: + 3: 691: if (/*state->hand[currentPlayer][choice1] < copper ||*/ state->hand[currentPlayer][choice1] > gold) +branch 0 taken 33% (fallthrough) +branch 1 taken 67% + -: 692: { + 1: 693: return -1; + -: 694: } + -: 695: + 2: 696: if (choice2 > treasure_map || choice2 < curse) +branch 0 taken 100% (fallthrough) +branch 1 taken 0% +branch 2 taken 0% (fallthrough) +branch 3 taken 100% + -: 697: { + #####: 698: return -1; + -: 699: } + -: 700: + 2: 701: if ( (getCost(state->hand[currentPlayer][choice1]) + 3) > getCost(choice2) ) +call 0 returned 100% +call 1 returned 100% +branch 2 taken 0% (fallthrough) +branch 3 taken 100% + -: 702: { + #####: 703: return -1; + -: 704: } + -: 705: + -: 706: //gainCard(choice2, state, 2, currentPlayer); + -: 707: + -: 708: //discard card from hand + 2: 709: discardCard(handPos, currentPlayer, state, 0); +call 0 returned 100% + -: 710: + -: 711: //discard trashed card + 2: 712: for (i = 0; i < state->handCount[currentPlayer]; i++) +branch 0 taken 100% +branch 1 taken 0% (fallthrough) + -: 713: { + 2: 714: if (state->hand[currentPlayer][i] == j) +branch 0 taken 100% (fallthrough) +branch 1 taken 0% + -: 715: { + 2: 716: discardCard(i, currentPlayer, state, 0); +call 0 returned 100% + 2: 717: break; + -: 718: } + -: 719: } + -: 720: + 2: 721: return 0; + -: 722:} + -: 723: +function getEstateCard called 2 returned 100% blocks executed 86% + 2: 724:void getEstateCard(struct gameState *state, int currentPlayer) + -: 725:{ + 2: 726: if (supplyCount(estate, state) > 0) { +call 0 returned 100% +branch 1 taken 100% (fallthrough) +branch 2 taken 0% + 2: 727: gainCard(estate, state, 0, currentPlayer);//Gain an estate +call 0 returned 100% + -: 728: + 2: 729: state->supplyCount[estate]--;//Decrement Estates + 2: 730: if (supplyCount(estate, state) == 0) { +call 0 returned 100% +branch 1 taken 0% (fallthrough) +branch 2 taken 100% + #####: 731: isGameOver(state); +call 0 never executed + -: 732: } + -: 733: } + 2: 734:} + -: 735: +function doBaron called 3 returned 100% blocks executed 100% + 3: 736:void doBaron(int choice1, struct gameState *state, int currentPlayer) + -: 737:{ + 3: 738: state->numBuys++;//Increase buys by 1! + 3: 739: state->numBuys++;//Increase buys by 1! + 3: 740: if (choice1 > 0) { //Boolean true or going to discard an estate +branch 0 taken 67% (fallthrough) +branch 1 taken 33% + 2: 741: int p = 1; //0;//Iterator for hand! + 2: 742: int card_not_discarded = 1;//Flag for discard set! + 11: 743: while(card_not_discarded) { +branch 0 taken 78% +branch 1 taken 22% (fallthrough) + 7: 744: if (state->hand[currentPlayer][p] == estate) { //Found an estate card! +branch 0 taken 14% (fallthrough) +branch 1 taken 86% + 1: 745: state->coins += 4;//Add 4 coins to the amount of coins + 1: 746: state->discard[currentPlayer][state->discardCount[currentPlayer]] = state->hand[currentPlayer][p]; + 1: 747: state->discardCount[currentPlayer]++; + 5: 748: for (; p < state->handCount[currentPlayer]; p++) { +branch 0 taken 80% +branch 1 taken 20% (fallthrough) + 4: 749: state->hand[currentPlayer][p] = state->hand[currentPlayer][p+1]; + -: 750: } + 1: 751: state->hand[currentPlayer][state->handCount[currentPlayer]] = -1; + 1: 752: state->handCount[currentPlayer]--; + 1: 753: card_not_discarded = 0;//Exit the loop + -: 754: } + 6: 755: else if (p > state->handCount[currentPlayer]) { +branch 0 taken 17% (fallthrough) +branch 1 taken 83% + -: 756: if(DEBUG) { + -: 757: printf("No estate cards in your hand, invalid choice\n"); + -: 758: printf("Must gain an estate if there are any\n"); + -: 759: } + 1: 760: getEstateCard(state, currentPlayer); +call 0 returned 100% + 1: 761: card_not_discarded = 0;//Exit the loop + -: 762: } + -: 763: + -: 764: else { + 5: 765: p++;//Next card + -: 766: } + -: 767: } + -: 768: } + -: 769: + -: 770: else { + 1: 771: getEstateCard(state, currentPlayer); +call 0 returned 100% + -: 772: } + 3: 773:} + -: 774: +function doMinion called 2 returned 100% blocks executed 100% + 2: 775:void doMinion(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) + -: 776:{ + -: 777: int i; + -: 778: int j; + -: 779: + -: 780: //+1 action + 2: 781: state->numActions++; + -: 782: + -: 783: //discard card from hand + 2: 784: discardCard(handPos, currentPlayer, state, 0); +call 0 returned 100% + -: 785: + 2: 786: if (choice1) +branch 0 taken 50% (fallthrough) +branch 1 taken 50% + -: 787: { + 1: 788: state->coins = state->coins + 2; + -: 789: } + 1: 790: else if (choice2) //discard hand, redraw 4, other players with 5+ cards discard hand and draw 4 +branch 0 taken 100% (fallthrough) +branch 1 taken 0% + -: 791: { + -: 792: //discard hand + 5: 793: while(numHandCards(state) > 1 /*0*/) +call 0 returned 100% +branch 1 taken 75% +branch 2 taken 25% (fallthrough) + -: 794: { + 3: 795: discardCard(handPos, currentPlayer, state, 0); +call 0 returned 100% + -: 796: } + -: 797: + -: 798: //draw 4 + 5: 799: for (i = 0; i < 4; i++) +branch 0 taken 80% +branch 1 taken 20% (fallthrough) + -: 800: { + 4: 801: drawCard(currentPlayer, state); +call 0 returned 100% + -: 802: } + -: 803: + -: 804: //other players discard hand and redraw if hand size > 4 + 5: 805: for (i = 0; i < state->numPlayers; i++) +branch 0 taken 80% +branch 1 taken 20% (fallthrough) + -: 806: { + 4: 807: if (i != currentPlayer) +branch 0 taken 75% (fallthrough) +branch 1 taken 25% + -: 808: { + -: 809: //if ( state->handCount[i] > 4 ) + -: 810: { + -: 811: //discard hand + 9: 812: while( state->handCount[i] > 0 ) +branch 0 taken 50% +branch 1 taken 50% (fallthrough) + -: 813: { + 3: 814: discardCard(handPos, i, state, 0); +call 0 returned 100% + -: 815: } + -: 816: + -: 817: //draw 4 + 15: 818: for (j = 0; j < 4; j++) +branch 0 taken 80% +branch 1 taken 20% (fallthrough) + -: 819: { + 12: 820: drawCard(i, state); +call 0 returned 100% + -: 821: } + -: 822: } + -: 823: } + -: 824: } + -: 825: } + 2: 826:} + -: 827: +function printDeck called 0 returned 0% blocks executed 0% + #####: 828:void printDeck(struct gameState *state, int p) { + #####: 829: printf("Deck:"); +call 0 never executed + #####: 830: for (int i=0; i < state->deckCount[p]; i++) +branch 0 never executed +branch 1 never executed + #####: 831: printf(" %d", state->deck[p][i]); +call 0 never executed + #####: 832: printf("\n"); +call 0 never executed + #####: 833:} + -: 834: +function printHand called 0 returned 0% blocks executed 0% + #####: 835:void printHand(struct gameState *state, int p) { + #####: 836: printf("Hand:"); +call 0 never executed + #####: 837: for (int i=0; i < state->handCount[p]; i++) +branch 0 never executed +branch 1 never executed + #####: 838: printf(" %d", state->hand[p][i]); +call 0 never executed + #####: 839: printf("\n"); +call 0 never executed + #####: 840:} + -: 841: +function doTribute called 3 returned 100% blocks executed 93% + 3: 842:void doTribute(struct gameState *state, int currentPlayer, int nextPlayer, int tributeRevealedCards[2]) + -: 843:{ + -: 844: int i; + -: 845: + 3: 846: if ((state->discardCount[nextPlayer] + state->deckCount[nextPlayer]) <= 1) { +branch 0 taken 33% (fallthrough) +branch 1 taken 67% + 1: 847: if (state->deckCount[nextPlayer] > 0) { +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + #####: 848: tributeRevealedCards[0] = state->deck[nextPlayer][state->deckCount[nextPlayer]-1]; + #####: 849: state->deckCount[nextPlayer]--; + -: 850: } + 1: 851: else if (state->discardCount[nextPlayer] > 0) { +branch 0 taken 100% (fallthrough) +branch 1 taken 0% + 1: 852: tributeRevealedCards[0] = state->discard[nextPlayer][state->discardCount[nextPlayer]-1]; + 1: 853: state->discardCount[nextPlayer]--; + -: 854: } + -: 855: else { + -: 856: //No Card to Reveal + -: 857: if (DEBUG) { + -: 858: printf("No cards to reveal\n"); + -: 859: } + -: 860: } + -: 861: } + -: 862: + -: 863: else { + 2: 864: if (state->deckCount[nextPlayer] == 0) { +branch 0 taken 50% (fallthrough) +branch 1 taken 50% + 2: 865: for (i = 0; i < state->discardCount[nextPlayer]; i++) { +branch 0 taken 50% +branch 1 taken 50% (fallthrough) + 1: 866: state->deck[nextPlayer][i] = state->discard[nextPlayer][i];//Move to deck + 1: 867: state->deckCount[nextPlayer]++; + 1: 868: state->discard[nextPlayer][i] = -1; + 1: 869: state->discardCount[nextPlayer]--; + -: 870: } + -: 871: + 1: 872: shuffle(nextPlayer,state);//Shuffle the deck +call 0 returned 100% + -: 873: } + 2: 874: tributeRevealedCards[0] = state->deck[nextPlayer][state->deckCount[nextPlayer]-1]; + -: 875: //state->deck[nextPlayer][state->deckCount[nextPlayer]--] = -1; + -: 876: //state->deckCount[nextPlayer]--; + -: 877: //tributeRevealedCards[1] = state->deck[nextPlayer][state->deckCount[nextPlayer]-1]; + 2: 878: tributeRevealedCards[1] = state->deck[nextPlayer][state->deckCount[nextPlayer]-2]; + -: 879: //state->deck[nextPlayer][state->deckCount[nextPlayer]--] = -1; + -: 880: //state->deckCount[nextPlayer]--; + -: 881: } + -: 882: + 3: 883: if (tributeRevealedCards[0] == tributeRevealedCards[1]) { //If we have a duplicate card, just drop one +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + #####: 884: state->playedCards[state->playedCardCount] = tributeRevealedCards[1]; + #####: 885: state->playedCardCount++; + #####: 886: tributeRevealedCards[1] = -1; + -: 887: } + -: 888: + 9: 889: for (i = 0; i < 2; i ++) { +branch 0 taken 67% +branch 1 taken 33% (fallthrough) + 6: 890: if (tributeRevealedCards[i] == copper || tributeRevealedCards[i] == silver || tributeRevealedCards[i] == gold) { //Treasure cards +branch 0 taken 83% (fallthrough) +branch 1 taken 17% +branch 2 taken 100% (fallthrough) +branch 3 taken 0% +branch 4 taken 0% (fallthrough) +branch 5 taken 100% + 1: 891: state->numActions = state->numActions + 2; + -: 892: } + -: 893: + 5: 894: else if (tributeRevealedCards[i] == estate || tributeRevealedCards[i] == duchy || tributeRevealedCards[i] == province || tributeRevealedCards[i] == gardens || tributeRevealedCards[i] == great_hall) { //Victory Card Found +branch 0 taken 60% (fallthrough) +branch 1 taken 40% +branch 2 taken 100% (fallthrough) +branch 3 taken 0% +branch 4 taken 100% (fallthrough) +branch 5 taken 0% +branch 6 taken 100% (fallthrough) +branch 7 taken 0% +branch 8 taken 0% (fallthrough) +branch 9 taken 100% + 2: 895: drawCard(currentPlayer, state); +call 0 returned 100% + -: 896: //drawCard(currentPlayer, state); + -: 897: } + -: 898: else { //Action Card + 3: 899: state->coins += 2; + -: 900: } + -: 901: } + 3: 902:} + -: 903: +function doAmbassador called 2 returned 100% blocks executed 89% + 2: 904:int doAmbassador(int choice1, int choice2, struct gameState *state, int handPos, int currentPlayer) + -: 905:{ + -: 906: int i; + -: 907: int j; + -: 908: + 2: 909: j = 0; //used to check if player has enough cards to discard + -: 910: + 2: 911: if (choice2 > 3 || choice2 < 0) +branch 0 taken 100% (fallthrough) +branch 1 taken 0% +branch 2 taken 0% (fallthrough) +branch 3 taken 100% + -: 912: { + #####: 913: return -1; + -: 914: } + -: 915: + -: 916:/* + -: 917: if (choice1 == handPos) + -: 918: { + -: 919: return -1; + -: 920: } + -: 921: */ + -: 922: + 12: 923: for (i = 0; i < state->handCount[currentPlayer]; i++) +branch 0 taken 83% +branch 1 taken 17% (fallthrough) + -: 924: { + 10: 925: if (i != handPos && state->hand[currentPlayer][i] == state->hand[currentPlayer][choice1] /*&& i != choice1*/) +branch 0 taken 80% (fallthrough) +branch 1 taken 20% +branch 2 taken 50% (fallthrough) +branch 3 taken 50% + -: 926: { + 4: 927: j++; + -: 928: } + -: 929: } + 2: 930: if (j < choice2) +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + -: 931: { + #####: 932: return -1; + -: 933: } + -: 934: + -: 935: if (DEBUG) + -: 936: printf("Player %d reveals card number: %d\n", currentPlayer, state->hand[currentPlayer][choice1]); + -: 937: + -: 938: //increase supply count for choosen card by amount being discarded + 2: 939: state->supplyCount[state->hand[currentPlayer][choice1]] += choice2; + -: 940: + -: 941: //each other player gains a copy of revealed card + 6: 942: for (i = 0; i < state->numPlayers; i++) +branch 0 taken 67% +branch 1 taken 33% (fallthrough) + -: 943: { + 4: 944: if (i != currentPlayer) +branch 0 taken 50% (fallthrough) +branch 1 taken 50% + -: 945: { + 2: 946: gainCard(state->hand[currentPlayer][choice1], state, 0, i); +call 0 returned 100% + -: 947: } + -: 948: } + -: 949: + -: 950: //discard played card from hand + 2: 951: discardCard(handPos, currentPlayer, state, 0); +call 0 returned 100% + -: 952: + -: 953: //trash copies of cards returned to supply + 6: 954: for (j = 0; j < choice2; j++) +branch 0 taken 67% +branch 1 taken 33% (fallthrough) + -: 955: { + 4: 956: for (i = 0; i < state->handCount[currentPlayer]; i++) +branch 0 taken 100% +branch 1 taken 0% (fallthrough) + -: 957: { + 4: 958: if (state->hand[currentPlayer][i] == state->hand[currentPlayer][choice1]) +branch 0 taken 100% (fallthrough) +branch 1 taken 0% + -: 959: { + 4: 960: discardCard(i, currentPlayer, state, 1); +call 0 returned 100% + 4: 961: break; + -: 962: } + -: 963: } + -: 964: } + -: 965: + 2: 966: return 0; + -: 967:} + -: 968: +function cardEffect called 0 returned 0% blocks executed 0% + #####: 969:int cardEffect(int card, int choice1, int choice2, int choice3, struct gameState *state, int handPos, int *bonus) + -: 970:{ + -: 971: int i; + -: 972: int j; + -: 973: int k; + -: 974: int x; + -: 975: int index; + #####: 976: int currentPlayer = whoseTurn(state); +call 0 never executed + #####: 977: int nextPlayer = currentPlayer + 1; + -: 978: + #####: 979: int tributeRevealedCards[2] = {-1, -1}; + -: 980: int temphand[MAX_HAND];// moved above the if statement + #####: 981: int drawntreasure=0; + -: 982: int cardDrawn; + #####: 983: int z = 0;// this is the counter for the temp hand + #####: 984: if (nextPlayer > (state->numPlayers - 1)) { +branch 0 never executed +branch 1 never executed + #####: 985: nextPlayer = 0; + -: 986: } + -: 987: + -: 988: + -: 989: //uses switch to select card and perform actions + #####: 990: switch( card ) +branch 0 never executed +branch 1 never executed +branch 2 never executed +branch 3 never executed +branch 4 never executed +branch 5 never executed +branch 6 never executed +branch 7 never executed +branch 8 never executed +branch 9 never executed +branch 10 never executed +branch 11 never executed +branch 12 never executed +branch 13 never executed +branch 14 never executed +branch 15 never executed +branch 16 never executed +branch 17 never executed +branch 18 never executed +branch 19 never executed +branch 20 never executed + -: 991: { + -: 992: case adventurer: + #####: 993: while(drawntreasure<2) { +branch 0 never executed +branch 1 never executed + #####: 994: if (state->deckCount[currentPlayer] <1) { //if the deck is empty we need to shuffle discard and add to deck +branch 0 never executed +branch 1 never executed + #####: 995: shuffle(currentPlayer, state); +call 0 never executed + -: 996: } + #####: 997: drawCard(currentPlayer, state); +call 0 never executed + #####: 998: cardDrawn = state->hand[currentPlayer][state->handCount[currentPlayer]-1];//top card of hand is most recently drawn card. + #####: 999: if (cardDrawn == copper || cardDrawn == silver || cardDrawn == gold) +branch 0 never executed +branch 1 never executed +branch 2 never executed +branch 3 never executed +branch 4 never executed +branch 5 never executed + #####: 1000: drawntreasure++; + -: 1001: else { + #####: 1002: temphand[z]=cardDrawn; + #####: 1003: state->handCount[currentPlayer]--; //this should just remove the top card (the most recently drawn one). + #####: 1004: z++; + -: 1005: } + -: 1006: } + #####: 1007: while(z-1>=0) { +branch 0 never executed +branch 1 never executed + #####: 1008: state->discard[currentPlayer][state->discardCount[currentPlayer]++]=temphand[z-1]; // discard all cards in play that have been drawn + #####: 1009: z=z-1; + -: 1010: } + #####: 1011: return 0; + -: 1012: + -: 1013: case council_room: + -: 1014: //+4 Cards + #####: 1015: for (i = 0; i < 4; i++) +branch 0 never executed +branch 1 never executed + -: 1016: { + #####: 1017: drawCard(currentPlayer, state); +call 0 never executed + -: 1018: } + -: 1019: + -: 1020: //+1 Buy + #####: 1021: state->numBuys++; + -: 1022: + -: 1023: //Each other player draws a card + #####: 1024: for (i = 0; i < state->numPlayers; i++) +branch 0 never executed +branch 1 never executed + -: 1025: { + #####: 1026: if ( i != currentPlayer ) +branch 0 never executed +branch 1 never executed + -: 1027: { + #####: 1028: drawCard(i, state); +call 0 never executed + -: 1029: } + -: 1030: } + -: 1031: + -: 1032: //put played card in played card pile + #####: 1033: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + -: 1034: + #####: 1035: return 0; + -: 1036: + -: 1037: case feast: + -: 1038: //gain card with cost up to 5 + -: 1039: //Backup hand + #####: 1040: for (i = 0; i <= state->handCount[currentPlayer]; i++) { +branch 0 never executed +branch 1 never executed + #####: 1041: temphand[i] = state->hand[currentPlayer][i];//Backup card + #####: 1042: state->hand[currentPlayer][i] = -1;//Set to nothing + -: 1043: } + -: 1044: //Backup hand + -: 1045: + -: 1046: //Update Coins for Buy + #####: 1047: updateCoins(currentPlayer, state, 5); +call 0 never executed + #####: 1048: x = 1;//Condition to loop on + #####: 1049: while( x == 1) {//Buy one card +branch 0 never executed +branch 1 never executed + #####: 1050: if (supplyCount(choice1, state) <= 0) { +call 0 never executed +branch 1 never executed +branch 2 never executed + -: 1051: if (DEBUG) + -: 1052: printf("None of that card left, sorry!\n"); + -: 1053: + -: 1054: if (DEBUG) { + -: 1055: printf("Cards Left: %d\n", supplyCount(choice1, state)); + -: 1056: } + -: 1057: } + #####: 1058: else if (state->coins < getCost(choice1)) { +call 0 never executed +branch 1 never executed +branch 2 never executed + #####: 1059: printf("That card is too expensive!\n"); +call 0 never executed + -: 1060: + -: 1061: if (DEBUG) { + -: 1062: printf("Coins: %d < %d\n", state->coins, getCost(choice1)); + -: 1063: } + -: 1064: } + -: 1065: else { + -: 1066: + -: 1067: if (DEBUG) { + -: 1068: printf("Deck Count: %d\n", state->handCount[currentPlayer] + state->deckCount[currentPlayer] + state->discardCount[currentPlayer]); + -: 1069: } + -: 1070: + #####: 1071: gainCard(choice1, state, 0, currentPlayer);//Gain the card +call 0 never executed + #####: 1072: x = 0;//No more buying cards + -: 1073: + -: 1074: if (DEBUG) { + -: 1075: printf("Deck Count: %d\n", state->handCount[currentPlayer] + state->deckCount[currentPlayer] + state->discardCount[currentPlayer]); + -: 1076: } + -: 1077: + -: 1078: } + -: 1079: } + -: 1080: + -: 1081: //Reset Hand + #####: 1082: for (i = 0; i <= state->handCount[currentPlayer]; i++) { +branch 0 never executed +branch 1 never executed + #####: 1083: state->hand[currentPlayer][i] = temphand[i]; + #####: 1084: temphand[i] = -1; + -: 1085: } + -: 1086: //Reset Hand + -: 1087: + #####: 1088: return 0; + -: 1089: + -: 1090: case gardens: + #####: 1091: return -1; + -: 1092: + -: 1093: case mine: + #####: 1094: return doMine(choice1, choice2, state, handPos, currentPlayer); +call 0 never executed + -: 1095: + -: 1096: case remodel: + #####: 1097: j = state->hand[currentPlayer][choice1]; //store card we will trash + -: 1098: + #####: 1099: if ( (getCost(state->hand[currentPlayer][choice1]) + 2) > getCost(choice2) ) +call 0 never executed +call 1 never executed +branch 2 never executed +branch 3 never executed + -: 1100: { + #####: 1101: return -1; + -: 1102: } + -: 1103: + #####: 1104: gainCard(choice2, state, 0, currentPlayer); +call 0 never executed + -: 1105: + -: 1106: //discard card from hand + #####: 1107: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + -: 1108: + -: 1109: //discard trashed card + #####: 1110: for (i = 0; i < state->handCount[currentPlayer]; i++) +branch 0 never executed +branch 1 never executed + -: 1111: { + #####: 1112: if (state->hand[currentPlayer][i] == j) +branch 0 never executed +branch 1 never executed + -: 1113: { + #####: 1114: discardCard(i, currentPlayer, state, 0); +call 0 never executed + #####: 1115: break; + -: 1116: } + -: 1117: } + -: 1118: + -: 1119: + #####: 1120: return 0; + -: 1121: + -: 1122: case smithy: + -: 1123: //+3 Cards + #####: 1124: for (i = 0; i < 3; i++) +branch 0 never executed +branch 1 never executed + -: 1125: { + #####: 1126: drawCard(currentPlayer, state); +call 0 never executed + -: 1127: } + -: 1128: + -: 1129: //discard card from hand + #####: 1130: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + #####: 1131: return 0; + -: 1132: + -: 1133: case village: + -: 1134: //+1 Card + #####: 1135: drawCard(currentPlayer, state); +call 0 never executed + -: 1136: + -: 1137: //+2 Actions + #####: 1138: state->numActions = state->numActions + 2; + -: 1139: + -: 1140: //discard played card from hand + #####: 1141: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + #####: 1142: return 0; + -: 1143: + -: 1144: case baron: + #####: 1145: doBaron(choice1, state, currentPlayer); +call 0 never executed + #####: 1146: return 0; + -: 1147: + -: 1148: case great_hall: + -: 1149: //+1 Card + #####: 1150: drawCard(currentPlayer, state); +call 0 never executed + -: 1151: + -: 1152: //+1 Actions + #####: 1153: state->numActions++; + -: 1154: + -: 1155: //discard card from hand + #####: 1156: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + #####: 1157: return 0; + -: 1158: + -: 1159: case minion: + #####: 1160: doMinion(choice1, choice2, state, handPos, currentPlayer); +call 0 never executed + #####: 1161: return 0; + -: 1162: + -: 1163: case steward: + #####: 1164: if (choice1 == 1) +branch 0 never executed +branch 1 never executed + -: 1165: { + -: 1166: //+2 cards + #####: 1167: drawCard(currentPlayer, state); +call 0 never executed + #####: 1168: drawCard(currentPlayer, state); +call 0 never executed + -: 1169: } + #####: 1170: else if (choice1 == 2) +branch 0 never executed +branch 1 never executed + -: 1171: { + -: 1172: //+2 coins + #####: 1173: state->coins = state->coins + 2; + -: 1174: } + -: 1175: else + -: 1176: { + -: 1177: //trash 2 cards in hand + #####: 1178: discardCard(choice2, currentPlayer, state, 1); +call 0 never executed + #####: 1179: discardCard(choice3, currentPlayer, state, 1); +call 0 never executed + -: 1180: } + -: 1181: + -: 1182: //discard card from hand + #####: 1183: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + #####: 1184: return 0; + -: 1185: + -: 1186: case tribute: + #####: 1187: doTribute(state, currentPlayer, nextPlayer, tributeRevealedCards); +call 0 never executed + #####: 1188: return 0; + -: 1189: + -: 1190: case ambassador: + #####: 1191: return doAmbassador(choice1, choice2, state, handPos, currentPlayer); +call 0 never executed + -: 1192: + -: 1193: case cutpurse: + -: 1194: + #####: 1195: updateCoins(currentPlayer, state, 2); +call 0 never executed + #####: 1196: for (i = 0; i < state->numPlayers; i++) +branch 0 never executed +branch 1 never executed + -: 1197: { + #####: 1198: if (i != currentPlayer) +branch 0 never executed +branch 1 never executed + -: 1199: { + #####: 1200: for (j = 0; j < state->handCount[i]; j++) +branch 0 never executed +branch 1 never executed + -: 1201: { + #####: 1202: if (state->hand[i][j] == copper) +branch 0 never executed +branch 1 never executed + -: 1203: { + #####: 1204: discardCard(j, i, state, 0); +call 0 never executed + #####: 1205: break; + -: 1206: } + #####: 1207: if (j == state->handCount[i]) +branch 0 never executed +branch 1 never executed + -: 1208: { + #####: 1209: for (k = 0; k < state->handCount[i]; k++) +branch 0 never executed +branch 1 never executed + -: 1210: { + -: 1211: if (DEBUG) + -: 1212: printf("Player %d reveals card number %d\n", i, state->hand[i][k]); + -: 1213: } + #####: 1214: break; + -: 1215: } + -: 1216: } + -: 1217: + -: 1218: } + -: 1219: + -: 1220: } + -: 1221: + -: 1222: //discard played card from hand + #####: 1223: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + -: 1224: + #####: 1225: return 0; + -: 1226: + -: 1227: + -: 1228: case embargo: + -: 1229: //+2 Coins + #####: 1230: state->coins = state->coins + 2; + -: 1231: + -: 1232: //see if selected pile is in play + #####: 1233: if ( state->supplyCount[choice1] == -1 ) +branch 0 never executed +branch 1 never executed + -: 1234: { + #####: 1235: return -1; + -: 1236: } + -: 1237: + -: 1238: //add embargo token to selected supply pile + #####: 1239: state->embargoTokens[choice1]++; + -: 1240: + -: 1241: //trash card + #####: 1242: discardCard(handPos, currentPlayer, state, 1); +call 0 never executed + #####: 1243: return 0; + -: 1244: + -: 1245: case outpost: + -: 1246: //set outpost flag + #####: 1247: state->outpostPlayed++; + -: 1248: + -: 1249: //discard card + #####: 1250: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + #####: 1251: return 0; + -: 1252: + -: 1253: case salvager: + -: 1254: //+1 buy + #####: 1255: state->numBuys++; + -: 1256: + #####: 1257: if (choice1) +branch 0 never executed +branch 1 never executed + -: 1258: { + -: 1259: //gain coins equal to trashed card + #####: 1260: state->coins = state->coins + getCost( handCard(choice1, state) ); +call 0 never executed +call 1 never executed + -: 1261: //trash card + #####: 1262: discardCard(choice1, currentPlayer, state, 1); +call 0 never executed + -: 1263: } + -: 1264: + -: 1265: //discard card + #####: 1266: discardCard(handPos, currentPlayer, state, 0); +call 0 never executed + #####: 1267: return 0; + -: 1268: + -: 1269: case sea_hag: + #####: 1270: for (i = 0; i < state->numPlayers; i++) { +branch 0 never executed +branch 1 never executed + #####: 1271: if (i != currentPlayer) { +branch 0 never executed +branch 1 never executed + #####: 1272: state->discard[i][state->discardCount[i]] = state->deck[i][state->deckCount[i]--]; + #####: 1273: state->deckCount[i]--; + #####: 1274: state->discardCount[i]++; + #####: 1275: state->deck[i][state->deckCount[i]--] = curse;//Top card now a curse + -: 1276: } + -: 1277: } + #####: 1278: return 0; + -: 1279: + -: 1280: case treasure_map: + -: 1281: //search hand for another treasure_map + #####: 1282: index = -1; + #####: 1283: for (i = 0; i < state->handCount[currentPlayer]; i++) +branch 0 never executed +branch 1 never executed + -: 1284: { + #####: 1285: if (state->hand[currentPlayer][i] == treasure_map && i != handPos) +branch 0 never executed +branch 1 never executed +branch 2 never executed +branch 3 never executed + -: 1286: { + #####: 1287: index = i; + #####: 1288: break; + -: 1289: } + -: 1290: } + #####: 1291: if (index > -1) +branch 0 never executed +branch 1 never executed + -: 1292: { + -: 1293: //trash both treasure cards + #####: 1294: discardCard(handPos, currentPlayer, state, 1); +call 0 never executed + #####: 1295: discardCard(index, currentPlayer, state, 1); +call 0 never executed + -: 1296: + -: 1297: //gain 4 Gold cards + #####: 1298: for (i = 0; i < 4; i++) +branch 0 never executed +branch 1 never executed + -: 1299: { + #####: 1300: gainCard(gold, state, 1, currentPlayer); +call 0 never executed + -: 1301: } + -: 1302: + -: 1303: //return success + #####: 1304: return 1; + -: 1305: } + -: 1306: + -: 1307: //no second treasure_map found in hand + #####: 1308: return -1; + -: 1309: } + -: 1310: + #####: 1311: return -1; + -: 1312:} + -: 1313: +function discardCard called 18 returned 100% blocks executed 89% + 18: 1314:int discardCard(int handPos, int currentPlayer, struct gameState *state, int trashFlag) + -: 1315:{ + -: 1316: + -: 1317: //if card is not trashed, added to Played pile + 18: 1318: if (trashFlag < 1) +branch 0 taken 78% (fallthrough) +branch 1 taken 22% + -: 1319: { + -: 1320: //add card to played pile + 14: 1321: state->playedCards[state->playedCardCount] = state->hand[currentPlayer][handPos]; + 14: 1322: state->playedCardCount++; + -: 1323: } + -: 1324: + -: 1325: //set played card to -1 + 18: 1326: state->hand[currentPlayer][handPos] = -1; + -: 1327: + -: 1328: //remove card from player's hand + 18: 1329: if ( handPos == (state->handCount[currentPlayer] - 1) ) //last card in hand array is played +branch 0 taken 11% (fallthrough) +branch 1 taken 89% + -: 1330: { + -: 1331: //reduce number of cards in hand + 2: 1332: state->handCount[currentPlayer]--; + -: 1333: } + 16: 1334: else if ( state->handCount[currentPlayer] == 1 ) //only one card in hand +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + -: 1335: { + -: 1336: //reduce number of cards in hand + #####: 1337: state->handCount[currentPlayer]--; + -: 1338: } + -: 1339: else + -: 1340: { + -: 1341: //replace discarded card with last card in hand + 16: 1342: state->hand[currentPlayer][handPos] = state->hand[currentPlayer][ (state->handCount[currentPlayer] - 1)]; + -: 1343: //set last card to -1 + 16: 1344: state->hand[currentPlayer][state->handCount[currentPlayer] - 1] = -1; + -: 1345: //reduce number of cards in hand + 16: 1346: state->handCount[currentPlayer]--; + -: 1347: } + -: 1348: + 18: 1349: return 0; + -: 1350:} + -: 1351: +function gainCard called 4 returned 100% blocks executed 70% + 4: 1352:int gainCard(int supplyPos, struct gameState *state, int toFlag, int player) + -: 1353:{ + -: 1354: //Note: supplyPos is enum of choosen card + -: 1355: + -: 1356: //check if supply pile is empty (0) or card is not used in game (-1) + 4: 1357: if ( supplyCount(supplyPos, state) < 1 ) +call 0 returned 100% +branch 1 taken 0% (fallthrough) +branch 2 taken 100% + -: 1358: { + #####: 1359: return -1; + -: 1360: } + -: 1361: + -: 1362: //added card for [whoseTurn] current player: + -: 1363: // toFlag = 0 : add to discard + -: 1364: // toFlag = 1 : add to deck + -: 1365: // toFlag = 2 : add to hand + -: 1366: + 4: 1367: if (toFlag == 1) +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + -: 1368: { + #####: 1369: state->deck[ player ][ state->deckCount[player] ] = supplyPos; + #####: 1370: state->deckCount[player]++; + -: 1371: } + 4: 1372: else if (toFlag == 2) +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + -: 1373: { + #####: 1374: state->hand[ player ][ state->handCount[player] ] = supplyPos; + #####: 1375: state->handCount[player]++; + -: 1376: } + -: 1377: else + -: 1378: { + 4: 1379: state->discard[player][ state->discardCount[player] ] = supplyPos; + 4: 1380: state->discardCount[player]++; + -: 1381: } + -: 1382: + -: 1383: //decrease number in supply pile + 4: 1384: state->supplyCount[supplyPos]--; + -: 1385: + 4: 1386: return 0; + -: 1387:} + -: 1388: +function updateCoins called 5 returned 100% blocks executed 82% + 5: 1389:int updateCoins(int player, struct gameState *state, int bonus) + -: 1390:{ + -: 1391: int i; + -: 1392: + -: 1393: //reset coin count + 5: 1394: state->coins = 0; + -: 1395: + -: 1396: //add coins for each Treasure card in player's hand + 30: 1397: for (i = 0; i < state->handCount[player]; i++) +branch 0 taken 83% +branch 1 taken 17% (fallthrough) + -: 1398: { + 25: 1399: if (state->hand[player][i] == copper) +branch 0 taken 60% (fallthrough) +branch 1 taken 40% + -: 1400: { + 15: 1401: state->coins += 1; + -: 1402: } + 10: 1403: else if (state->hand[player][i] == silver) +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + -: 1404: { + #####: 1405: state->coins += 2; + -: 1406: } + 10: 1407: else if (state->hand[player][i] == gold) +branch 0 taken 0% (fallthrough) +branch 1 taken 100% + -: 1408: { + #####: 1409: state->coins += 3; + -: 1410: } + -: 1411: } + -: 1412: + -: 1413: //add bonus + 5: 1414: state->coins += bonus; + -: 1415: + 5: 1416: return 0; + -: 1417:} + -: 1418: + -: 1419: + -: 1420://end of dominion.c diff --git a/projects/alghanmz/a3/dominion.gcda b/projects/alghanmz/a3/dominion.gcda new file mode 100644 index 0000000000000000000000000000000000000000..231f0fbf2c6b2f6e5027184f02bb224b2e86d00a GIT binary patch literal 5848 zcmeHLTWnNS6ul!LOcfcR*h+y2jHRIui;vLM+GweUA(0Sm2qEwR9SS&Lq$U!pSRVuo ziO+}{KLi4aC9S*+(Ud4nWBq^zI$D+C*ur*#6;7b&Rys1 zv-djZo^{VT_jXybapjX$l@C;Wn0U_fyqzhz^zZJ89gKLM{CPhNmy6h-4*_0Ht%#Z{ zEhLca*!@zc8)eu8`Q4%=&zot880$8`Tg5lR+NT&I27Xwf56VB%%3&O3zK0CaXP%Yw z4bkr%Rwja~;@DrUwIPoB5#gI;?L>^F#C*Mmh@*Z)jF0-A zu((`wY?7S3^5hroLJs~tHhHd&t*K;29p@q0v8ht08)aC5{HSAvdi*+d#Ip~B4%G2( zIKokGc@yqdvr3^ugXZ zdg8#8{Xzt;9e<1EEknGq!Ql}ebSh{sKTKv>!hDQ0CQ6H|E>(vMM&$Y*S2N!v! zh5Ddo)CA*Y4l%6R%a)5cYDI*PS`p!+Rz&!y6)_jhnk0W*&xnuOga}+4Y@%{qQ}dDR zSh3XUMj3{=!T4a@GY~_~h!}P(`M@49dwbuy=-o;s`{>-9n zP8==8nBr;1ggp@EVu(xIxn~g>&odz#@*E&C9$ll1Z=elJ244HR=2fBg_fhTm`Yy_W zcfwJh{$BD=IPMgVHPO7`(dM$Xu8zEC7kMv4R~N>!oyaqh=;p~#^u8uY;pfWg<8ME_ z=zEL_-v{Jm4(mkf#P=iW$#!z%%>S%u)i>Sej{N~{oEePGh7#(Uj(5Cx2io80-`(2z z3^*~T?APTaK{kJeIPDW>T5sQA^`=KsUFZ|vZ0wV{F0!3{yY2shy59R(8R*9=;&n3% zpODw0%xgzB0yUyklmpMyn4bFahZpTR3J!ih`qBT|RmU<$x;s(PHK$-s-6t4}yjcC8 zOz#ov?DG4iy?d86%Ikb)&C=Ywa^QO^(RJv{!m@j7!QsB|rOC_WQcmne`Rlr)7cMUS z37l9P++(DuF}F$K)OQQ7{MvC~%gyQ+XW{Bt-^OsiJTKWV{&6tSy*%>Uyw6`kzoBtS zOJF)i8}*Zf(lU#~k2UjF|jV7#${a^t+)5<9)Vzc%tMxI^#W zH^%zcEbRk({d@0tXU^AeZKfW0Heiq1CijA0^;~2eQNolHb5wAlqpG2O;Z|@~OPyzm zi$?8rTVGcUxo(M!U; literal 0 HcmV?d00001 diff --git a/projects/alghanmz/a3/dominion.gcno b/projects/alghanmz/a3/dominion.gcno new file mode 100644 index 0000000000000000000000000000000000000000..53cd4ee4f2bbe7c18a9a960172cfddfb41f65e0e GIT binary patch literal 41668 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 literal 0 HcmV?d00001 diff --git a/projects/alghanmz/a3/dominion.h b/projects/alghanmz/a3/dominion.h new file mode 100644 index 000000000..f9d9039b8 --- /dev/null +++ b/projects/alghanmz/a3/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/alghanmz/a3/dominion.o b/projects/alghanmz/a3/dominion.o new file mode 100644 index 0000000000000000000000000000000000000000..81ae495872eaf1634fdc4f966be5455639ae2c5c GIT binary patch literal 53784 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 literal 0 HcmV?d00001 diff --git a/projects/alghanmz/a3/dominion_helpers.h b/projects/alghanmz/a3/dominion_helpers.h new file mode 100644 index 000000000..0887fda15 --- /dev/null +++ b/projects/alghanmz/a3/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/alghanmz/a3/rngs.c b/projects/alghanmz/a3/rngs.c new file mode 100644 index 000000000..a85bbc961 --- /dev/null +++ b/projects/alghanmz/a3/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/alghanmz/a3/rngs.gcda b/projects/alghanmz/a3/rngs.gcda new file mode 100644 index 0000000000000000000000000000000000000000..e0619095e55deb95836cfd95fb950e6e6c7e4c50 GIT binary patch literal 2664 zcmd6py=xRv6vbzv>qjsW7C+(#OQQJ@ab-b;fTAD~O$w193Sy&CCWv6Xzc=@+!>~pdQsj`GbLYH!?|bvkydhVTYvZGX zmBWQ6!#ATSnyT7mVP?MbO&mq`7kyf57sFCY4PLBX-{?|P8m2ghLv}Bj7;Lp)TZp1) zzcV>LZG+dDR`BtXGdbv>E2YqXy~kPJ;M!4V=4|(Pi!<|X_E=1Rjn^`HyF3r426!sDw45k$Pl#i;Vf7UBf$&qJzFPeGAoSLtfLIeFeL-dEq z(|pH$j6C@#M%(SHo?%FYn{sYO<`4 zBNXS*WA~DY!FKz}$Advh@8u)!KEMb0*o|OdOg`#7Qm2|CNrq-VlBct$TGpmBC#IJ? zt62=llUHIioi8z(d=aC`A8{-G@NMka`L*=g8qsU=Fa9k3!=LjM=g?>Ol8HgHbJk(H z{22&Ysb}&>XXbzX;rVs;wD0s%pFNp5AV;2wS%xpA@vY*l@B=$i3cc7< zpzj=YE8$NqbWNW@zKB_~d=aC`7cpAmeZ(#J6SE&Y-^7=h(Qk9{MLSh-x81J-gtg(v z^Lw+OyM7eS&dHd4*Ex_^dA5{Li%;K2N<*{vE7R2Ky)YSs9G<`J!R7Hsm3kjJ{2!zK zVv<)FVQ$uQ;^Ddah4&|in49_X&r2G E4U(X2kN^Mx literal 0 HcmV?d00001 diff --git a/projects/alghanmz/a3/rngs.gcno b/projects/alghanmz/a3/rngs.gcno new file mode 100644 index 0000000000000000000000000000000000000000..f05d60f398fd41c66d260b99fc2ff1b903c8838c GIT binary patch literal 4032 zcmcJS%WG9h5XR5({Td(ffh)m-F@%a=-_bAj`r;f z9~_v-vMgUNW|8Ra|E79AyvzINOZjjy(d-!*9U428W%HyyJ~}+Hbuh~wN;%6K`G)ZQ zUZx{w4hUl}2&ImEVXV^zmWwJ++YE>2+YDbSIBi*`e9EjlM6u+%u< zjN|8Aj+HNi89_AQNJ$m)uQlx8}S2gi*3XK z3=WuIEA_PzTPI%?jW_su(bQVurrH<>oO$Y8J9A=2ULf_{d?eW8&|;=DXHW2hc>WWG zqE()*rOJDn;1MIl`+KHPwCayMLOk!eLeVOZoI*TrN}*_#$6652OU;iMA)fcULeX~S zF z#PjYeWHy{{{CzyQY5&`6?T_Jh70uqF7^?KU5_&Xd-U@SI_Y-yc>fCg#)LG|TYsL3< z(Ho*p!rX}6ykCzE-)x`Wg1_#`*>fvGr$%l$>3n=+aqiq8#D*g>P|%L!G;cGUwHN(GQ%r!t=R%>@D>E>2GgheQfIfP2~QtacJW#a`#a7 zZOj4O-aU(ne+w-p_69On{|4fdHxP_+ea_&l31R)VR>rn?=v-UBUxjeTL{E#BqUT2A zUp+VDB}q!H&*4OZ#~Kjw*M8eI17b$~rQW4UqlB;WQt#541kYmR$32_irQWY|30~^` zI-lUNuZSP_fiI@n{x^DZhBt@7A!#PjOwWv%Qz;(3>(emS5sCj176v*)+&>ArvW z?PtHcM+Qd2%_1A<`*($IjnHSt!&epNzB|ac-cqdFgWr-|PjL<)-bq;l`(KdFpeCcH-$V>ONn1I~WV$ oYj+}R*eSY8bhqdp(NbFH%HEPBCFSY(RsZ`EJY7$f*Wq|y049j=G5`Po literal 0 HcmV?d00001 diff --git a/projects/alghanmz/a3/rngs.h b/projects/alghanmz/a3/rngs.h new file mode 100644 index 000000000..c9f3f451a --- /dev/null +++ b/projects/alghanmz/a3/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/alghanmz/a3/rngs.o b/projects/alghanmz/a3/rngs.o new file mode 100644 index 0000000000000000000000000000000000000000..4f59e8b8858b66e06efab315b3b5fba6fc2bf7e7 GIT binary patch literal 11728 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 C!5^{! literal 0 HcmV?d00001 diff --git a/projects/alghanmz/a3/unittest1.gcda b/projects/alghanmz/a3/unittest1.gcda new file mode 100644 index 0000000000000000000000000000000000000000..b7727784087622b716814eb741f67cf607b9134c GIT binary patch literal 936 zcmYdHNlp*4FfiFX-Lsg1fnjkrka)fFsK8c61_mHvxWWP?fZ#ubg45r#Q#qkRSSe4C zW;9?7IsoXTg^YF}2_Oc6kw$~O3fb>0Js!h6ccgK2|9-t5ypob$+5Nr=9uHx27bUQ7v iX@Tj1We$*?AONF*Ot2o1S#Pdw%SF}$%LiEOVE_O+PAiT8 literal 0 HcmV?d00001 diff --git a/projects/alghanmz/a3/unittest1.gcno b/projects/alghanmz/a3/unittest1.gcno new file mode 100644 index 0000000000000000000000000000000000000000..f88979db76f3fd158b74f43d7fde9fe185b0ced7 GIT binary patch literal 3924 zcmd6q+iDa+5Qb;s`Fz%BG;RU`^&%)nj2e~Ay2g0G7|$Am>l!3rHkjR9dgqjQWv zDkz9g;+29A;6qs7RJXfZyS0J{T2M7TfBiGl-8KDB&wQo)Xma@A(8rhK)g(#MH4>JI z4~!jn)%#|mr%T#%rP+!ck|pAcmDyTtrdm5RSWflzy3< z1}6u;(aC{ta&q9CogDZUCkMXO$$@Wka^TyY9QY0=2j1=Ez;`-1@Lf(0yvNCb?{;$F zdz>72uag7c>*T<5;=JFDYlU?J-Y3p`#`*!{93Gw|#guo7^@fqRy0KrdLGdB+x)oF2 zZ}^zK?uf!6Dp&i^$~|hhyvK|Mv-ceq?3nm*@e|@B;&s#Ku$D1YZ$ZKyuu+CQ`RN(k6G@hU5H<;z#Q8+~9qCc4B zPAMFsa?vBqa_=e}qH@t7%yOp{4pF&i5@xyg6b@0j=n!VP_cJsG<>tbv<(48%kC`^1 z8@(^eQ*S@a9)@2oEj%pDFIH;Ow%2Qa^O-j3Eq)i9_aLe}ilK>UNyIqvJo-Z$R}EEu z#5qQ-g=6o*IrqWPA2^ZUxYvjndkmhV&njm7K2NV1Ki`U+c-?f)<1_7?_0@^eQm&4n zb$-Q|5{WFAnm_u`o8*9Nla(^&f z*H`C%jL3(p{9@XvCiE|UN2Mv&xhC;D+Q{{462GI$)&D{I^yAB?Ip&V>>D;x}h e5^I>9HidsXZ}hKu9e18LYEZY%8W#6k@P7idJtGDH literal 0 HcmV?d00001 diff --git a/projects/alghanmz/a3/unittest2 b/projects/alghanmz/a3/unittest2 new file mode 100644 index 0000000000000000000000000000000000000000..f7d8220357f8a8b7268449702c7ba5b31c522acb GIT binary patch literal 62352 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 literal 0 HcmV?d00001 diff --git a/projects/alghanmz/a3/unittest2.gcda b/projects/alghanmz/a3/unittest2.gcda new file mode 100644 index 0000000000000000000000000000000000000000..afbec273256495ff84f4e27bcecfc2e0852828af GIT binary patch literal 792 zcmYdHNlp*4FfjQ(-Lsg1fnjk0kkIw8QCY&szyL%H^I3re5d4QwaC-muBu=OhR>~Em z84V}{`7mJ+8w9w3mz77i1^QJ{7PG#JvJgHjD4BvKm>w7nR0`Gu T@^7YdQ!=t1BsFN(FfafBe(@&b literal 0 HcmV?d00001 diff --git a/projects/alghanmz/a3/unittest2.gcno b/projects/alghanmz/a3/unittest2.gcno new file mode 100644 index 0000000000000000000000000000000000000000..4fc66e70d95c0ce7eb1f89899db80bb458f74f0a GIT binary patch literal 2512 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⋙zyNW9uVS9*Rf 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 F{Q=Nw^K1YB literal 0 HcmV?d00001 diff --git a/projects/alghanmz/a3/unittest4 b/projects/alghanmz/a3/unittest4 new file mode 100644 index 0000000000000000000000000000000000000000..19ad1d52e84065def9ab7ce0cbad4222350de986 GIT binary patch literal 62552 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 literal 0 HcmV?d00001 diff --git a/projects/alghanmz/a3/unittest4.gcno b/projects/alghanmz/a3/unittest4.gcno new file mode 100644 index 0000000000000000000000000000000000000000..c33bc567f3f44aee445d14a7d696678d93e4efd0 GIT binary patch literal 3900 zcmd6qId4-z6oubo-}f~vN)Sjufg*ue!;%;yBKEKd#A=)nq69}^r>3C-egHp!7Db|> zqUS$ALyKssxu4HW;#|LRK@+ZY?i-&uv)(uNjVEi>(V^qLM;adn>sglNE6pu7EOfo0o>fo0q>fo0dXz%9&zudrhD-1Ht6P}n9%>`|$4t`al9sKG< z9sHU^9sJrv9sD{&(fZ)mhjtt6DbxDkHyVo8hc;CQzbVlUesiJ@eoLYberuu*ew(3a zeel~uyDodmv_AM9hNAVMP1V8gH2Cp&Z{c?t=#%#uj^DgjAj`@*G3GpA)cbRLz_?z+ zQNyg2bKW=fm~VGXbnwz@4(-|#PD`9w3+DShY1}D8pW(FOjNz=|oT1+^V3;+H%UQ#G zUnSAOOUv2Ay!O24;HBj(VqRMo9lW&c73Q@UL=JqJx(<<{PiQTc9PUU|xGqbnxnz9D{l7ebK>}bJj)9!Myf?aSsiT437;@ z3>CvuL)9>A8k78l`F@5)2QMx83iH|#(ZNeg{=&TWndso9C7)qlJ1RPOX=5(*+OYyH z`402ianZr6U-BR3wG*PFZ{|Sq)5P%G?9=D5!|1D(SHq>rsanIzzCAgV`%FC7&7U3J z+`EVJn>cbWIVy5I8ISo;2FlgaN1kWQ>1cc({H7m_yoM&~;~k^55Aqq~XsmMce#hLf zqV;o^>!xzXwC8b5-==3qM?qSR-`@Y80=P&lesWq0AiFJ%+{2k-)FR|wvl!`s;k9o?9W}V|6b5W}{ z75A8nTD4khdmM`9kcxZEFX}g&x%0gL{jzJ|W8WM0s#33yylRwRPE{t_VyBk?u(U@4hj=xjDS^zQwzl_M-E?#rqc8zwP5LjQ{`u literal 0 HcmV?d00001 diff --git a/projects/alghanmz/a3/unittest5 b/projects/alghanmz/a3/unittest5 new file mode 100644 index 0000000000000000000000000000000000000000..5855f8fc467f719037917ca6a50ceebd3deb8132 GIT binary patch literal 62552 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 literal 0 HcmV?d00001 diff --git a/projects/alghanmz/a3/unittest5.gcno b/projects/alghanmz/a3/unittest5.gcno new file mode 100644 index 0000000000000000000000000000000000000000..7982f5a17dae658092b5eab161beab6f8d033114 GIT binary patch literal 3096 zcmd6p$!Zi)6o&70p63AsB?^LW#Gt{TiP~w(80WM&8?osGX`}Jo-xL*6}Mb4 z`(=LSrGkE^9mjLMc;rya9Dp=6yFI!73s<*{i7}65Nvm#|ANR!I zY}z(PV~#J2!SQ@q41Pr*2EQ^8gI^Vh!LJU);MW9V@Z_Rwp784eG5Ga?82pAn41QxE z2EQo~gWnv8!EXt~;I|6c^TGU)JNRt^)=p00xJL(!i7e}+1~B4&T^duI4hVEoD-ZETo7CoToPOsToGiZOSQU&;{NU{(dzt*+MyC{=p66QX^rJvFwYmChsVEu z`|yVOw7Q*GKGD6ptHS=GXV`UE|Zp#H+EV>{YYZn_GyZ$NlER zLeBY~lXEwhIUdXf`$+$AK+jk8zm?OYRefZua^n6sM4no8PTYH2#nm}+@7uKF q