int main(void)
{
int status=0, flash=1;
char received[256]="(NULL)";
char r;
// Init
DDRE |= 0xf0;
initDevice();
PORTE = 0x30; // Status Report (Initialized)
#ifdef SIM
int i;
for(i=0;i<=10;i++)
#else
while(1)
#endif
{
PORTE = 0x20; // Status Report (Not Connected)
#ifndef SIM
// Wait for BT Connection
while(!status)
status = PING & (1 << PING0);
PORTE = 0x10; // Status Report (Connected)
// Flash the led so we know we are alive
if(flash) PORTE |= 0x80; else PORTE &= ~0x80;
_delay_ms(500);
#endif
flash ^=1;
// Monitor Supply Voltage
checkSupply();
if(flash)
OCR1BL = 18;
else
OCR1BL = 5;
//printf("Press M (More) or L (Less): \n");
//r = getCHAR(stdin);
//switch(r){
// case 'M':
// printf("incrementing OCR1BL\n");
// OCR1BL += 1; // ~1ms
// printf("OCR1BL=%u\n", 0x00FF & OCR1BL);
// break;
// case 'L':
// printf("decrementing OCR1BL\n");
// OCR1BL -= 1; // ~1ms
// printf("OCR1BL=%u\n", 0x00FF & OCR1BL);
// break;
// default:
// break;
//}
}
sleep_cpu();
}
int main () {
int i, j;
int result; //return value for function calls
int failed, changed; //flags for tests
int cardsBefore[treasure_map]; //cards in hand before shuffle
int cardsAfter[treasure_map]; //cards in hand after shuffle
struct gameState *g = malloc(sizeof(struct gameState)); //working game state
struct gameState *pre = malloc(sizeof(struct gameState)); //reference game state; stored before functions run
int selectedCards[10] = {adventurer, council_room, feast, gardens, mine, smithy, village, tribute, salvager, sea_hag};
int seed = 10;
//---Test deckCount = 0
//---Expected result: error
printf("*** Testing deckCount = 0 ***\n");
printf("Errors: ");
//Create clean game
if (initializeGame(NUM_PLAYERS, selectedCards, seed, g) == -1){
printf("\nCould not initialize game. Testing aborted.");
return -1;
}
//Draw all cards in deck
while (g->deckCount[whoseTurn(g)] > 0){
drawCard(whoseTurn(g), g);
}
//Save current state
memcpy(pre, g, sizeof(struct gameState));
//Attempt to shuffle
result = shuffle(whoseTurn(g), g);
failed = 0;
if (result != -1){
printf("\nReturn value: %d, Expected: %d", result, -1);
failed = 1;
}
//Check game state is unchanged
if (checkGameState(pre, g) < 0){
printf("\ngameState changed");
failed = 1;
}
//Final check
if (failed){
printf("\nResult: FAIL\n\n");
} else {
printf("none");
printf("\nResult: PASS\n\n");
}
//---Test deckCount = 1
//---Expected result: gameState is unchanged
printf("*** Testing deckCount = 1 ***\n");
printf("Errors: ");
//Create clean game
if (initializeGame(NUM_PLAYERS, selectedCards, seed, g) == -1){
printf("\nCould not initialize game. Testing aborted.");
return -1;
}
//Draw all cards but 1 in deck
while (g->deckCount[whoseTurn(g)] > 1){
drawCard(whoseTurn(g), g);
}
//Save current state
memcpy(pre, g, sizeof(struct gameState));
//Run shuffle and check results
failed = 0;
result = shuffle(whoseTurn(g), g);
if (result == -1){
printf("\nReturn value: %d, Expected: %d", result, 0);
failed = 1;
}
//Check game state is unchanged
if (checkGameState(pre, g) < 0){
printf("\ngameState changed");
failed = 1;
}
//Final check
if (failed){
printf("\nResult: FAIL\n\n");
} else {
printf("none");
printf("\nResult: PASS\n\n");
}
//---Test deckCount > 1
/*---Expected results:
- Game and turn settings are unchanged
- Other player's cards (hand, deck, discard) are unchanged
- Current player's hand and discard are unchanged
- Played cards are unchanged
- Current player's deck Count is unchanged
- Current player's deck contains same cards as before shuffle
- Current player's deck cards are in different order than before shuffle
*/
printf("*** Testing deckCount > 1 ***\n");
printf("Errors: ");
//Create clean game
if (initializeGame(NUM_PLAYERS, selectedCards, seed, g) == -1){
printf("\nCould not initialize game. Testing aborted.");
return -1;
}
//Confirm deckCount > 1
if (g->deckCount[whoseTurn(g)] <= 1){
printf("\nCould not create suitable game. Testing aborted.");
return -1;
}
//Save current state
memcpy(pre, g, sizeof(struct gameState));
//Initialize card count arrays
for (i = 0; i < treasure_map; i++){
cardsAfter[i] = 0;
cardsBefore[i] = 0;
}
//Get before deck card counts
for (i = 0; i < g->deckCount[(whoseTurn(g))]; i++){
cardsBefore[g->deck[whoseTurn(g)][i]]++;
}
//Run shuffle and check results
failed = 0;
result = shuffle(whoseTurn(g), g);
if (result == -1){
printf("\nReturn value: %d, Expected: %d", result, 0);
failed = 1;
}
//Check game/turn settings
if (checkNumPlayers(pre, g) < 0){
printf("\nNumPlayers: %d, Expected: %d", g->numPlayers, pre->numPlayers);
failed = 1;
}
result = checkSupply(pre, g);
if (result != 0){
printf("\nSupply count for card %d: %d, Expected: %d", result, g->supplyCount[result], pre->supplyCount[result]);
failed = 1;
}
result = checkEmbargo(pre, g);
if (result != 0){
printf("\nEmbargo for card %d: %d, Expected: %d", result, g->embargoTokens[result], pre->embargoTokens[result]);
failed = 1;
}
if (checkOutpost(pre, g) < 0){
printf("\noutpostPlayed: %d, Expected: %d", g->outpostPlayed, pre->outpostPlayed);
printf("\noutpostTurn: %d, Expected: %d", g->outpostTurn, pre->outpostTurn);
failed = 1;
}
if (checkTurn(pre, g) < 0){
printf("\nwhoseTurn: %d, Expected: %d", g->whoseTurn, pre->whoseTurn);
failed = 1;
}
if (checkPhase(pre, g) < 0){
printf("\nphase: %d, Expected: %d", g->phase, pre->phase);
failed = 1;
}
if (checkNumActions(pre, g) < 0){
printf("\nnumActions: %d, Expected: %d", g->numActions, pre->numActions);
failed = 1;
}
if (checkCoins(pre, g) < 0){
printf("\ncoins: %d, Expected: %d", g->coins, pre->coins);
failed = 1;
}
if (checkNumBuys(pre, g) < 0){
printf("\nnumBuys: %d, Expected: %d", g->numBuys, pre->numBuys);
failed = 1;
}
//Check all hand, discard, play cards unchanged
if (checkHands(pre, g) < 0){
printf("\nHands changed after shuffle\n");
//Print expected and actual hand for each player
for (i = 0; i < NUM_PLAYERS; i++){
printf(" Hand for player %d:\n", i);
printf(" Count: %d, Expected: %d\n", g->handCount[i], pre->handCount[i]);
if (g->handCount[i] > 0){
printf(" Actual Cards: ");
for (j = 0; j < g->handCount[i]; j++){
printf("%d ", g->hand[i][j]);
}
printf("\n Expected Cards: ");
for (j = 0; j < pre->handCount[i]; j++){
printf("%d ", pre->hand[i][j]);
}
}
}
failed = 1;
}
if (checkDiscards(pre, g) < 0){
printf("\nDiscards changed after shuffle\n");
//Print expected and actual discards for each player
for (i = 0; i < NUM_PLAYERS; i++){
printf(" Discard pile for player %d:\n", i);
printf(" Count: %d, Expected: %d\n", g->discardCount[i], pre->discardCount[i]);
if (g->discardCount[i] > 0){
printf(" Actual Cards: ");
for (j = 0; j < g->discardCount[i]; j++){
printf("%d ", g->discard[i][j]);
}
printf("\n Expected Cards: ");
for (j = 0; j < pre->discardCount[i]; j++){
printf("%d ", pre->discard[i][j]);
}
}
}
failed = 1;
}
if (checkPlayed(pre, g) < 0){
printf("\nPlayed cards changed after shuffle\n");
//Print expected and actual discards for each player
printf(" Played count: %d, Expected: %d\n", g->playedCardCount, pre->playedCardCount);
if (g->playedCardCount > 0){
printf(" Actual Cards: ");
for (i = 0; i < g->playedCardCount; i++){
printf("%d ", g->playedCards[i]);
}
printf("\n Expected Cards: ");
for (i = 0; i < pre->playedCardCount; i++){
printf("%d ", pre->playedCards[i]);
}
}
failed = 1;
}
//Check deck unchanged for other players
for (i = 0; i < g->numPlayers; i++){
//skip if current player
if (i == whoseTurn(g)){
continue;
}
if (pre->deckCount[i] != g->deckCount[i]){
printf("\nPlayer %d's deckCount: %d, Expected: %d", i, g->deckCount[i], pre->deckCount[i]);
failed = 1;
} else { //check each card
for (j = 0; j < g->deckCount[i]; j++){
if (pre->deck[i][j] != g->deck[i][j]){
printf("\nPlayer %d's deck[%d]: %d, Expected: %d", i, j, g->deck[i][j], pre->deck[i][j]);
failed = 1;
}
}
}
}
//Check current player's deck is same size
if (pre->deckCount[whoseTurn(g)] != g->deckCount[whoseTurn(g)]){
printf("\nCurrent player's deckCount: %d, Expected: %d", g->deckCount[whoseTurn(g)], pre->deckCount[whoseTurn(g)]);
failed = 1;
}
//Check current player's deck contains same cards as before
for (i = 0; i < g->deckCount[(whoseTurn(g))]; i++){
cardsAfter[g->deck[whoseTurn(g)][i]]++;
}
for (i = 0; i < treasure_map; i++){
if (cardsBefore[i] != cardsAfter[i]){
printf("\nCount for card %d in deck: %d, Expected: %d", i, cardsAfter[i], cardsBefore[i]);
failed = 1;
break;
}
}
//Check current player's deck has cards in different order than before
if (pre->deckCount[whoseTurn(g)] == g->deckCount[whoseTurn(g)]){
changed = 0;
for (i = 0; i < g->deckCount[whoseTurn(g)]; i++){
if (pre->deck[whoseTurn(g)][i] != g->deck[whoseTurn(g)][i]){
changed = 1;
break;
}
}
if (!changed){
printf("\nCards in current player's deck not shuffled");
failed = 1;
}
}
//Final check
if (failed){
printf("\nResult: FAIL\n");
} else {
printf("none");
printf("\nResult: PASS\n");
}
return 0;
}
void main(void)
{
int status=0, flash=1;
uint16_t data;
char received[256]="(NULL)";
char r;
// Init
//DDRE |= 0xf0;
initDevice();
//PORTE = 0x30; // Status Report (Initialized)
#ifdef SIM
int i;
for(i=0;i<=10;i++)
#else
while(1)
#endif
{
//PORTE = 0x20; // Status Report (Not Connected)
#ifndef SIM
//PORTE = 0x10; // Status Report (Connected)
// Flash the led so we know we are alive
//if(flash) PORTE |= 0x80; else PORTE &= ~0x80;
_delay_ms(5000);
#endif
flash ^=1;
// Monitor Supply Voltage
checkSupply();
//if(flash)
// OCR1BL = 18;
//else
// OCR1BL = 5;
// Setup from INA219
// BRNG = Bus Voltage Range (0=16V 1=24V)
// RST::-::BRNG::PG1::PG0::BADC4::BADC3::BADC2
// BADC1::SADC4::SADC3::SADC2::SADC1::MODE3::MODE2::MODE1
// Breakout uses 0.1 Ohm Rshunt
// At +-320mV FSR -> +-3.2A
// Using PGA/8 max 400mA
if(!configINA219()){
getAmpINA219();
}
while(zg_get_conn_state() != 1) {
zg_drv_process();
}
//printf("Press M (More) or L (Less): \n");
//r = getCHAR(stdin);
//switch(r){
// case 'M':
// printf("incrementing OCR1BL\n");
// OCR1BL += 1; // ~1ms
// printf("OCR1BL=%u\n", 0x00FF & OCR1BL);
// break;
// case 'L':
// printf("decrementing OCR1BL\n");
// OCR1BL -= 1; // ~1ms
// printf("OCR1BL=%u\n", 0x00FF & OCR1BL);
// break;
// default:
// break;
//}
}
sleep_cpu();
}
int main () {
int i, j; //loop controls
int result; //return value for function calls
int failed; //flags for tests
struct gameState *g = malloc(sizeof(struct gameState)); //working game state
struct gameState *pre = malloc(sizeof(struct gameState)); //reference game state; stored before functions run
int selectedCards[10] = {adventurer, council_room, feast, gardens, mine, smithy, village, tribute, salvager, sea_hag};
int seed = 10;
int choice1, choice2, choice3; //choices for card effect
int coin_bonus; //coins added by card
//---Test smithy (all choices = -1, no bonus)
/*---Expected result:
- Game and turn settings are unchanged
- Other player's cards (hand, deck, discard) are unchanged
- Current player's discard is unchanged
- Played card count increased by 1
- Smithy card added to played pile (in last position)
- Smithy card removed from hand
- Last 3 cards of current player's deck moved to hand
- Current player's deckCount is decreased by 3
- Current player's handCount is increased by 2 (+3 new cards, -1 smithy)
- No bonus coins
*/
printf("*** Testing valid smithy ***\n");
printf("Errors: ");
//Setup card options
choice1 = -1;
choice2 = -1;
choice3 = -1;
coin_bonus = 0;
//Create clean game
if (initializeGame(NUM_PLAYERS, selectedCards, seed, g) == -1){
printf("\nCould not initialize game. Testing aborted.\n");
return -1;
}
//Set deck to 5 copper cards
g->deckCount[whoseTurn(g)] = 5;
for (i = 0; i < 5; i++){
g->deck[whoseTurn(g)][i] = copper;
}
//Set test position in hand to test card
g->hand[whoseTurn(g)][TEST_POS] = TEST_CARD;
//Save current state
memcpy(pre, g, sizeof(struct gameState));
//Attempt to execute card
result = cardEffect(TEST_CARD, choice1, choice2, choice3, g, TEST_POS, &coin_bonus);
failed = 0;
if (result != 0){
printf("\nReturn value: %d, Expected: %d\n", result, 0);
failed = 1;
}
//Check game/turn settings
if (checkNumPlayers(pre, g) < 0){
printf("\nNumPlayers: %d, Expected: %d\n", g->numPlayers, pre->numPlayers);
failed = 1;
}
result = checkSupply(pre, g);
if (result != 0){
printf("\nSupply count for card %d: %d, Expected: %d\n", result, g->supplyCount[result], pre->supplyCount[result]);
failed = 1;
}
result = checkEmbargo(pre, g);
if (result != 0){
printf("\nEmbargo for card %d: %d, Expected: %d\n", result, g->embargoTokens[result], pre->embargoTokens[result]);
failed = 1;
}
if (checkOutpost(pre, g) < 0){
printf("\noutpostPlayed: %d, Expected: %d\n", g->outpostPlayed, pre->outpostPlayed);
printf("\noutpostTurn: %d, Expected: %d\n", g->outpostTurn, pre->outpostTurn);
failed = 1;
}
if (checkTurn(pre, g) < 0){
printf("\nwhoseTurn: %d, Expected: %d\n", g->whoseTurn, pre->whoseTurn);
failed = 1;
}
if (checkPhase(pre, g) < 0){
printf("\nphase: %d, Expected: %d\n", g->phase, pre->phase);
failed = 1;
}
if (checkNumActions(pre, g) < 0){
printf("\nnumActions: %d, Expected: %d\n", g->numActions, pre->numActions);
failed = 1;
}
if (checkCoins(pre, g) < 0){
printf("\ncoins: %d, Expected: %d\n", g->coins, pre->coins);
failed = 1;
}
if (checkNumBuys(pre, g) < 0){
printf("\nnumBuys: %d, Expected: %d\n", g->numBuys, pre->numBuys);
failed = 1;
}
//Check all player's discard unchanged
if (checkDiscards(pre, g) < 0){
printf("\nDiscards changed after smithy\n");
//Print expected and actual discards for each player
for (i = 0; i < NUM_PLAYERS; i++){
printf(" Discard pile for player %d:\n", i);
printf(" Count: %d, Expected: %d\n", g->discardCount[i], pre->discardCount[i]);
if (g->discardCount[i] > 0){
printf(" Actual Cards: ");
for (j = 0; j < g->discardCount[i]; j++){
printf("%d ", g->discard[i][j]);
}
printf("\n Expected Cards: ");
for (j = 0; j < pre->discardCount[i]; j++){
printf("%d ", pre->discard[i][j]);
}
}
}
failed = 1;
}
//Check deck unchanged for other players
for (i = 0; i < g->numPlayers; i++){
//skip if current player
if (i == whoseTurn(g)){
continue;
}
if (pre->deckCount[i] != g->deckCount[i]){
printf("\nPlayer %d's deckCount: %d, Expected: %d", i, g->deckCount[i], pre->deckCount[i]);
failed = 1;
} else { //check each card
for (j = 0; j < g->deckCount[i]; j++){
if (pre->deck[i][j] != g->deck[i][j]){
printf("\nPlayer %d's deck[%d]: %d, Expected: %d", i, j, g->deck[i][j], pre->deck[i][j]);
failed = 1;
}
}
}
}
//Check hand unchanged for other players
for (i = 0; i < g->numPlayers; i++){
//skip if current player
if (i == whoseTurn(g)){
continue;
}
if (pre->handCount[i] != g->handCount[i]){
printf("\nPlayer %d's handCount: %d, Expected: %d", i, g->handCount[i], pre->handCount[i]);
failed = 1;
} else { //check each card
for (j = 0; j < g->handCount[i]; j++){
if (pre->hand[i][j] != g->hand[i][j]){
printf("\nPlayer %d's hand[%d]: %d, Expected: %d", i, j, g->hand[i][j], pre->hand[i][j]);
failed = 1;
}
}
}
}
//Check smithy added to played pile
if (g->playedCardCount != pre->playedCardCount + 1){
printf("\nPlayed card count: %d, Expected: %d", g->playedCardCount, pre->playedCardCount + 1);
failed = 1;
} else if (g->playedCards[g->playedCardCount - 1] != TEST_CARD){
printf("\nLast played card: %d, Expected: %d", g->playedCards[g->playedCardCount - 1], TEST_CARD);
failed = 1;
}
//Check 3 cards added to hand and smithy removed
if (g->handCount[whoseTurn(g)] != pre->handCount[whoseTurn(g)] + 2){
printf("\nCurrent player's hand count: %d, Expected: %d", g->handCount[whoseTurn(g)], pre->handCount[whoseTurn(g)] + 2);
failed = 1;
}
//Check 3 cards removed from deck
if (g->deckCount[whoseTurn(g)] != pre->deckCount[whoseTurn(g)] - 3){
printf("\nCurrent player's deck count: %d, Expected: %d", g->deckCount[whoseTurn(g)], pre->deckCount[whoseTurn(g)] - 3);
failed = 1;
}
//Check cards removed from deck = cards added to hand (last 2 cards, plus position 0...last card replaces test card when discarded)
if (g->hand[whoseTurn(g)][g->handCount[whoseTurn(g)] - 1] != pre->deck[whoseTurn(g)][pre->deckCount[whoseTurn(g)] - 1]){
printf("\nCurrent player's hand[%d]: %d, Expected: %d", g->handCount[whoseTurn(g)] - 1, g->hand[whoseTurn(g)][g->handCount[whoseTurn(g)] - 1], pre->deck[whoseTurn(g)][pre->deckCount[whoseTurn(g)] - 1]);
failed = 1;
}
if (g->hand[whoseTurn(g)][g->handCount[whoseTurn(g)] - 2] != pre->deck[whoseTurn(g)][pre->deckCount[whoseTurn(g)] - 2]){
printf("\nCurrent player's hand[%d]: %d, Expected: %d", g->handCount[whoseTurn(g)] - 2, g->hand[whoseTurn(g)][g->handCount[whoseTurn(g)] - 2], pre->deck[whoseTurn(g)][pre->deckCount[whoseTurn(g)] - 2]);
failed = 1;
}
if (g->hand[whoseTurn(g)][0] != pre->deck[whoseTurn(g)][pre->deckCount[whoseTurn(g)] - 3]){
printf("\nCurrent player's hand[0]: %d, Expected: %d", g->hand[whoseTurn(g)][0], pre->deck[whoseTurn(g)][pre->deckCount[whoseTurn(g)] - 3]);
failed = 1;
}
//Check no bonus coins added
if (coin_bonus != 0){
printf("\nCoin bonus after smithy: %d, Expected: %d", coin_bonus, 0);
failed = 1;
}
//Final check
if (failed){
printf("\nResult: FAIL\n");
} else {
printf("none");
printf("\nResult: PASS\n");
}
return 0;
}
int main () {
int i, j; //loop controls
int result; //return value for function calls
int failed; //flags for tests
struct gameState *g = malloc(sizeof(struct gameState)); //working game state
struct gameState *pre = malloc(sizeof(struct gameState)); //reference game state; stored before functions run
int selectedCards[10] = {adventurer, council_room, feast, gardens, mine, smithy, village, tribute, salvager, sea_hag};
int seed = 10;
int choice1, choice2, choice3; //choices for card effect
int coin_bonus; //coins added by card
//---Test adventurer with 2 treasure cards in deck
//---(all choices = -1, no bonus)
/*---Expected result:
- Game and turn settings are unchanged
- Other player's cards (hand, deck, discard) are unchanged
- Played card count increased by 1
- Adventurer card added to played pile (in last position)
- Adventurer card removed from hand
- Current player's deck count decreased by 2 treasures + extras
- Other cards in player's deck unchanged
- Current player's discard count increased by extras
- Current player's hand count increased by 1 (+2 treasures, -1 adventurer)
- Cards added to player's hand are treasure
- Cards added to player's discard are extras
- No bonus coins
*/
printf("*** Testing 2 treasure cards in deck ***\n");
printf("Errors: ");
//Setup card options
choice1 = -1;
choice2 = -1;
choice3 = -1;
coin_bonus = 0;
//Create clean game
if (initializeGame(NUM_PLAYERS, selectedCards, seed, g) == -1){
printf("\nCould not initialize game. Testing aborted.\n");
return -1;
}
//Set deck to 5 extras - 2 treasures - 5 extras
g->deckCount[whoseTurn(g)] = 0;
for (i = 1; i <= EXTRA_COUNT; i++){
g->deck[whoseTurn(g)][g->deckCount[whoseTurn(g)]] = EXTRA_CARD;
g->deckCount[whoseTurn(g)]++;
}
for (i = 1; i <= 2; i++){
g->deck[whoseTurn(g)][g->deckCount[whoseTurn(g)]] = TREASURE;
g->deckCount[whoseTurn(g)]++;
}
for (i = 1; i <= EXTRA_COUNT; i++){
g->deck[whoseTurn(g)][g->deckCount[whoseTurn(g)]] = EXTRA_CARD;
g->deckCount[whoseTurn(g)]++;
}
//Set test position in hand to test card
g->hand[whoseTurn(g)][TEST_POS] = TEST_CARD;
//Save current state
memcpy(pre, g, sizeof(struct gameState));
//Attempt to execute card
result = cardEffect(TEST_CARD, choice1, choice2, choice3, g, TEST_POS, &coin_bonus);
failed = 0;
if (result != 0){
printf("\nReturn value: %d, Expected: %d", result, 0);
failed = 1;
}
//Check game/turn settings
if (checkNumPlayers(pre, g) < 0){
printf("\nNumPlayers: %d, Expected: %d", g->numPlayers, pre->numPlayers);
failed = 1;
}
result = checkSupply(pre, g);
if (result != 0){
printf("\nSupply count for card %d: %d, Expected: %d", result, g->supplyCount[result], pre->supplyCount[result]);
failed = 1;
}
result = checkEmbargo(pre, g);
if (result != 0){
printf("\nEmbargo for card %d: %d, Expected: %d", result, g->embargoTokens[result], pre->embargoTokens[result]);
failed = 1;
}
if (checkOutpost(pre, g) < 0){
printf("\noutpostPlayed: %d, Expected: %d", g->outpostPlayed, pre->outpostPlayed);
printf("\noutpostTurn: %d, Expected: %d", g->outpostTurn, pre->outpostTurn);
failed = 1;
}
if (checkTurn(pre, g) < 0){
printf("\nwhoseTurn: %d, Expected: %d", g->whoseTurn, pre->whoseTurn);
failed = 1;
}
if (checkPhase(pre, g) < 0){
printf("\nphase: %d, Expected: %d", g->phase, pre->phase);
failed = 1;
}
if (checkNumActions(pre, g) < 0){
printf("\nnumActions: %d, Expected: %d", g->numActions, pre->numActions);
failed = 1;
}
if (checkCoins(pre, g) < 0){
printf("\ncoins: %d, Expected: %d", g->coins, pre->coins);
failed = 1;
}
if (checkNumBuys(pre, g) < 0){
printf("\nnumBuys: %d, Expected: %d", g->numBuys, pre->numBuys);
failed = 1;
}
//Check discard unchanged for other players
for (i = 0; i < g->numPlayers; i++){
//skip if current player
if (i == whoseTurn(g)){
continue;
}
if (pre->discardCount[i] != g->discardCount[i]){
printf("\nPlayer %d's discardCount: %d, Expected: %d", i, g->discardCount[i], pre->discardCount[i]);
failed = 1;
} else { //check each card
for (j = 0; j < g->discardCount[i]; j++){
if (pre->discard[i][j] != g->discard[i][j]){
printf("\nPlayer %d's discard[%d]: %d, Expected: %d", i, j, g->discard[i][j], pre->discard[i][j]);
failed = 1;
}
}
}
}
//Check deck unchanged for other players
for (i = 0; i < g->numPlayers; i++){
//skip if current player
if (i == whoseTurn(g)){
continue;
}
if (pre->deckCount[i] != g->deckCount[i]){
printf("\nPlayer %d's deckCount: %d, Expected: %d", i, g->deckCount[i], pre->deckCount[i]);
failed = 1;
} else { //check each card
for (j = 0; j < g->deckCount[i]; j++){
if (pre->deck[i][j] != g->deck[i][j]){
printf("\nPlayer %d's deck[%d]: %d, Expected: %d", i, j, g->deck[i][j], pre->deck[i][j]);
failed = 1;
}
}
}
}
//Check hand unchanged for other players
for (i = 0; i < g->numPlayers; i++){
//skip if current player
if (i == whoseTurn(g)){
continue;
}
if (pre->handCount[i] != g->handCount[i]){
printf("\nPlayer %d's handCount: %d, Expected: %d", i, g->handCount[i], pre->handCount[i]);
failed = 1;
} else { //check each card
for (j = 0; j < g->handCount[i]; j++){
if (pre->hand[i][j] != g->hand[i][j]){
printf("\nPlayer %d's hand[%d]: %d, Expected: %d", i, j, g->hand[i][j], pre->hand[i][j]);
failed = 1;
}
}
}
}
//Check adventurer added to played pile
if (g->playedCardCount != pre->playedCardCount + 1){
printf("\nPlayed card count: %d, Expected: %d", g->playedCardCount, pre->playedCardCount + 1);
failed = 1;
} else if (g->playedCards[g->playedCardCount - 1] != TEST_CARD){
printf("\nLast played card: %d, Expected: %d", g->playedCards[g->playedCardCount - 1], TEST_CARD);
failed = 1;
}
//Check 2 treasures + extras removed from deck; other cards remain
if (g->deckCount[whoseTurn(g)] != pre->deckCount[whoseTurn(g)] - EXTRA_COUNT - 2){
printf("\nCurrent player's deck count: %d, Expected: %d", g->deckCount[whoseTurn(g)], pre->deckCount[whoseTurn(g)] - EXTRA_COUNT - 2);
failed = 1;
}
for (i = 0; i < g->deckCount[whoseTurn(g)]; i++){
if (g->deck[whoseTurn(g)][i] != EXTRA_CARD){
printf("\nCurrent player's deck[%d]: %d, Expected: %d", i, g->deck[whoseTurn(g)][i], EXTRA_CARD);
failed = 1;
}
}
//Check 2 treasure cards added to hand, adventurer removed
if (g->handCount[whoseTurn(g)] != pre->handCount[whoseTurn(g)] + 1){
printf("\nCurrent player's hand count: %d, Expected: %d", g->handCount[whoseTurn(g)], pre->handCount[whoseTurn(g)] + 1);
failed = 1;
}
if ( (g->hand[whoseTurn(g)][g->handCount[whoseTurn(g)] - 1] != TREASURE) && (g->hand[whoseTurn(g)][g->handCount[whoseTurn(g)] - 2] != TREASURE) ){
printf("\nCurrent player's hand[%d]: %d, Expected: %d", g->handCount[whoseTurn(g)] - 1, g->hand[whoseTurn(g)][g->handCount[whoseTurn(g)] - 1], TREASURE);
printf("\nCurrent player's hand[%d]: %d, Expected: %d", g->handCount[whoseTurn(g)] - 2, g->hand[whoseTurn(g)][g->handCount[whoseTurn(g)] - 2], TREASURE);
failed = 1;
}
//Check extra cards added to discard
if (g->discardCount[whoseTurn(g)] != pre->discardCount[whoseTurn(g)] + EXTRA_COUNT){
printf("\nCurrent player's discard count: %d, Expected: %d", g->discardCount[whoseTurn(g)], pre->discardCount[whoseTurn(g)] + EXTRA_COUNT);
failed = 1;
}
for (i = 1; i <= EXTRA_COUNT; i++){
if (g->discard[whoseTurn(g)][g->discardCount[whoseTurn(g)] - i] != EXTRA_CARD){
printf("\nCurrent player's discard[%d]: %d, Expected: %d", g->discardCount[whoseTurn(g)] - i, g->discard[whoseTurn(g)][g->discardCount[whoseTurn(g)] - i], EXTRA_CARD);
failed = 1;
}
}
//Check no bonus coins added
if (coin_bonus != 0){
printf("\nCoin bonus after adventurer: %d, Expected: %d", coin_bonus, 0);
failed = 1;
}
//Final check
if (failed){
printf("\nResult: FAIL\n\n");
} else {
printf("none");
printf("\nResult: PASS\n\n");
}
//---Test adventurer with 1 treasure card in deck, 1 in discard
//---(all choices = -1, no bonus)
/*---Expected result:
- Game and turn settings are unchanged
- Other player's cards (hand, deck, discard) are unchanged
- Played card count increased by 1
- Adventurer card added to played pile (in last position)
- Adventurer card removed from hand
- Current player's deck count decreased by 1 treasure + extras
- Current player's discard count increased by extras, decreased by 1 treasure
- Current player's hand count increased by 1 (+2 treasures, -1 adventurer)
- Cards added to player's hand are treasure
- Cards added to player's discard are extras
- No bonus coins
-------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------
NOTICE: Test disabled because of bug in current code causing infinite loop.
When deck is empty, adventurer code does not add discard pile to deck before shuffle.
-------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------
*/
printf("*** Testing 1 treasure in deck + 1 in discard ***\n");
//printf("Errors: ");
printf("Test disabled because of infinite loop\n");
printf("Result: FAIL\n\n");
/*
//Setup card options
choice1 = -1;
choice2 = -1;
choice3 = -1;
coin_bonus = 0;
//Create clean game
if (initializeGame(NUM_PLAYERS, selectedCards, seed, g) == -1){
printf("\nCould not initialize game. Testing aborted.\n");
return -1;
}
//Set deck to 1 treasure - 5 extras
g->deckCount[whoseTurn(g)] = 0;
g->deck[whoseTurn(g)][g->deckCount[whoseTurn(g)]] = TREASURE;
g->deckCount[whoseTurn(g)]++;
for (i = 1; i <= EXTRA_COUNT; i++){
g->deck[whoseTurn(g)][g->deckCount[whoseTurn(g)]] = EXTRA_CARD;
g->deckCount[whoseTurn(g)]++;
}
//Set discard to 1 treasure
g->discardCount[whoseTurn(g)] = 0;
g->discard[whoseTurn(g)][g->deckCount[whoseTurn(g)]] = TREASURE;
g->discardCount[whoseTurn(g)]++;
//Set test position in hand to test card
g->hand[whoseTurn(g)][TEST_POS] = TEST_CARD;
//Save current state
memcpy(pre, g, sizeof(struct gameState));
//Attempt to execute card
result = cardEffect(TEST_CARD, choice1, choice2, choice3, g, TEST_POS, &coin_bonus);
failed = 0;
if (result != 0){
printf("\nReturn value: %d, Expected: %d", result, 0);
failed = 1;
}
//Check game/turn settings
if (checkNumPlayers(pre, g) < 0){
printf("\nNumPlayers: %d, Expected: %d", g->numPlayers, pre->numPlayers);
failed = 1;
}
result = checkSupply(pre, g);
if (result != 0){
printf("\nSupply count for card %d: %d, Expected: %d", result, g->supplyCount[result], pre->supplyCount[result]);
failed = 1;
}
result = checkEmbargo(pre, g);
if (result != 0){
printf("\nEmbargo for card %d: %d, Expected: %d", result, g->embargoTokens[result], pre->embargoTokens[result]);
failed = 1;
}
if (checkOutpost(pre, g) < 0){
printf("\noutpostPlayed: %d, Expected: %d", g->outpostPlayed, pre->outpostPlayed);
printf("\noutpostTurn: %d, Expected: %d", g->outpostTurn, pre->outpostTurn);
failed = 1;
}
if (checkTurn(pre, g) < 0){
printf("\nwhoseTurn: %d, Expected: %d", g->whoseTurn, pre->whoseTurn);
failed = 1;
}
if (checkPhase(pre, g) < 0){
printf("\nphase: %d, Expected: %d", g->phase, pre->phase);
failed = 1;
}
if (checkNumActions(pre, g) < 0){
printf("\nnumActions: %d, Expected: %d", g->numActions, pre->numActions);
failed = 1;
}
if (checkCoins(pre, g) < 0){
printf("\ncoins: %d, Expected: %d", g->coins, pre->coins);
failed = 1;
}
if (checkNumBuys(pre, g) < 0){
printf("\nnumBuys: %d, Expected: %d", g->numBuys, pre->numBuys);
failed = 1;
}
//Check discard unchanged for other players
for (i = 0; i < g->numPlayers; i++){
//skip if current player
if (i == whoseTurn(g)){
continue;
}
if (pre->discardCount[i] != g->discardCount[i]){
printf("\nPlayer %d's discardCount: %d, Expected: %d", i, g->discardCount[i], pre->discardCount[i]);
failed = 1;
} else { //check each card
for (j = 0; j < g->discardCount[i]; j++){
if (pre->discard[i][j] != g->discard[i][j]){
printf("\nPlayer %d's discard[%d]: %d, Expected: %d", i, j, g->discard[i][j], pre->discard[i][j]);
failed = 1;
}
}
}
}
//Check deck unchanged for other players
for (i = 0; i < g->numPlayers; i++){
//skip if current player
if (i == whoseTurn(g)){
continue;
}
if (pre->deckCount[i] != g->deckCount[i]){
printf("\nPlayer %d's deckCount: %d, Expected: %d", i, g->deckCount[i], pre->deckCount[i]);
failed = 1;
} else { //check each card
for (j = 0; j < g->deckCount[i]; j++){
if (pre->deck[i][j] != g->deck[i][j]){
printf("\nPlayer %d's deck[%d]: %d, Expected: %d", i, j, g->deck[i][j], pre->deck[i][j]);
failed = 1;
}
}
}
}
//Check hand unchanged for other players
for (i = 0; i < g->numPlayers; i++){
//skip if current player
if (i == whoseTurn(g)){
continue;
}
if (pre->handCount[i] != g->handCount[i]){
printf("\nPlayer %d's handCount: %d, Expected: %d", i, g->handCount[i], pre->handCount[i]);
failed = 1;
} else { //check each card
for (j = 0; j < g->handCount[i]; j++){
if (pre->hand[i][j] != g->hand[i][j]){
printf("\nPlayer %d's hand[%d]: %d, Expected: %d", i, j, g->hand[i][j], pre->hand[i][j]);
failed = 1;
}
}
}
}
//Check adventurer added to played pile
if (g->playedCardCount != pre->playedCardCount + 1){
printf("\nPlayed card count: %d, Expected: %d", g->playedCardCount, pre->playedCardCount + 1);
failed = 1;
} else if (g->playedCards[g->playedCardCount - 1] != TEST_CARD){
printf("\nLast played card: %d, Expected: %d", g->playedCards[g->playedCardCount - 1], TEST_CARD);
failed = 1;
}
//Check 1 treasure + extras removed from deck
if (g->deckCount[whoseTurn(g)] != pre->deckCount[whoseTurn(g)] - EXTRA_COUNT - 1){
printf("\nCurrent player's deck count: %d, Expected: %d", g->deckCount[whoseTurn(g)], pre->deckCount[whoseTurn(g)] - EXTRA_COUNT - 1);
failed = 1;
}
//Check 2 treasure cards added to hand, adventurer removed
if (g->handCount[whoseTurn(g)] != pre->handCount[whoseTurn(g)] + 1){
printf("\nCurrent player's hand count: %d, Expected: %d", g->handCount[whoseTurn(g)], pre->handCount[whoseTurn(g)] + 1);
failed = 1;
}
if ( (g->hand[whoseTurn(g)][g->handCount[whoseTurn(g)] - 1] != TREASURE) && (g->hand[whoseTurn(g)][g->handCount[whoseTurn(g)] - 2] != TREASURE) ){
printf("\nCurrent player's hand[%d]: %d, Expected: %d", g->handCount[whoseTurn(g)] - 1, g->hand[whoseTurn(g)][g->handCount[whoseTurn(g)] - 1], TREASURE);
printf("\nCurrent player's hand[%d]: %d, Expected: %d", g->handCount[whoseTurn(g)] - 2, g->hand[whoseTurn(g)][g->handCount[whoseTurn(g)] - 2], TREASURE);
failed = 1;
}
//Check extra cards added to discard and treasure removed
if (g->discardCount[whoseTurn(g)] != pre->discardCount[whoseTurn(g)] + EXTRA_COUNT - 1){
printf("\nCurrent player's discard count: %d, Expected: %d", g->discardCount[whoseTurn(g)], pre->discardCount[whoseTurn(g)] + EXTRA_COUNT - 1);
failed = 1;
}
for (i = 1; i <= EXTRA_COUNT; i++){
if (g->discard[whoseTurn(g)][g->discardCount[whoseTurn(g)] - i] != EXTRA_CARD){
printf("\nCurrent player's discard[%d]: %d, Expected: %d", g->discardCount[whoseTurn(g)] - i, g->discard[whoseTurn(g)][g->discardCount[whoseTurn(g)] - i], EXTRA_CARD);
failed = 1;
}
}
//Check no bonus coins added
if (coin_bonus != 0){
printf("\nCoin bonus after adventurer: %d, Expected: %d", coin_bonus, 0);
failed = 1;
}
//Final check
if (failed){
printf("\nResult: FAIL\n\n");
} else {
printf("none");
printf("\nResult: PASS\n\n");
}
*/
//---Test adventurer with 1 treasure card in deck (only 1 treasure total)
//---(all choices = -1, no bonus)
/*---Expected result:
- Game and turn settings are unchanged
- Other player's cards (hand, deck, discard) are unchanged
- Played card count increased by 1
- Adventurer card added to played pile (in last position)
- Adventurer removed from hand
- Current player's deck count decreased by 1 treasure + extras
- Other cards in player's deck unchanged
- Current player's discard count increased by extras
- Current player's hand count is unchanged (+1 treasure, -1 adventurer)
- Card added to player's hand is treasure
- Cards added to player's discard are extras
- No bonus coins
-------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------
NOTICE: Test disabled because of bug in current code causing infinite loop.
While loop does not have exit condition for case when only 1 treasure exists.
-------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------
*/
printf("*** Testing 1 treasure card in deck ***\n");
//printf("Errors: ");
printf("Test disabled because of infinite loop\n");
printf("Result: FAIL\n");
/*
//Setup card options
choice1 = -1;
choice2 = -1;
choice3 = -1;
coin_bonus = 0;
//Create clean game
if (initializeGame(NUM_PLAYERS, selectedCards, seed, g) == -1){
printf("\nCould not initialize game. Testing aborted.\n");
return -1;
}
//Set deck to 5 extras - 1 treasure - 5 extras
g->deckCount[whoseTurn(g)] = 0;
for (i = 1; i <= EXTRA_COUNT; i++){
g->deck[whoseTurn(g)][g->deckCount[whoseTurn(g)]] = EXTRA_CARD;
g->deckCount[whoseTurn(g)]++;
}
g->deck[whoseTurn(g)][g->deckCount[whoseTurn(g)]] = TREASURE;
g->deckCount[whoseTurn(g)]++;
for (i = 1; i <= EXTRA_COUNT; i++){
g->deck[whoseTurn(g)][g->deckCount[whoseTurn(g)]] = EXTRA_CARD;
g->deckCount[whoseTurn(g)]++;
}
//Set test position in hand to test card
g->hand[whoseTurn(g)][TEST_POS] = TEST_CARD;
//Save current state
memcpy(pre, g, sizeof(struct gameState));
//Attempt to execute card
result = cardEffect(TEST_CARD, choice1, choice2, choice3, g, TEST_POS, &coin_bonus);
failed = 0;
if (result != 0){
printf("\nReturn value: %d, Expected: %d", result, 0);
failed = 1;
}
//Check game/turn settings
if (checkNumPlayers(pre, g) < 0){
printf("\nNumPlayers: %d, Expected: %d", g->numPlayers, pre->numPlayers);
failed = 1;
}
result = checkSupply(pre, g);
if (result != 0){
printf("\nSupply count for card %d: %d, Expected: %d", result, g->supplyCount[result], pre->supplyCount[result]);
failed = 1;
}
result = checkEmbargo(pre, g);
if (result != 0){
printf("\nEmbargo for card %d: %d, Expected: %d", result, g->embargoTokens[result], pre->embargoTokens[result]);
failed = 1;
}
if (checkOutpost(pre, g) < 0){
printf("\noutpostPlayed: %d, Expected: %d", g->outpostPlayed, pre->outpostPlayed);
printf("\noutpostTurn: %d, Expected: %d", g->outpostTurn, pre->outpostTurn);
failed = 1;
}
if (checkTurn(pre, g) < 0){
printf("\nwhoseTurn: %d, Expected: %d", g->whoseTurn, pre->whoseTurn);
failed = 1;
}
if (checkPhase(pre, g) < 0){
printf("\nphase: %d, Expected: %d", g->phase, pre->phase);
failed = 1;
}
if (checkNumActions(pre, g) < 0){
printf("\nnumActions: %d, Expected: %d", g->numActions, pre->numActions);
failed = 1;
}
if (checkCoins(pre, g) < 0){
printf("\ncoins: %d, Expected: %d", g->coins, pre->coins);
failed = 1;
}
if (checkNumBuys(pre, g) < 0){
printf("\nnumBuys: %d, Expected: %d", g->numBuys, pre->numBuys);
failed = 1;
}
//Check discard unchanged for other players
for (i = 0; i < g->numPlayers; i++){
//skip if current player
if (i == whoseTurn(g)){
continue;
}
if (pre->discardCount[i] != g->discardCount[i]){
printf("\nPlayer %d's discardCount: %d, Expected: %d", i, g->discardCount[i], pre->discardCount[i]);
failed = 1;
} else { //check each card
for (j = 0; j < g->discardCount[i]; j++){
if (pre->discard[i][j] != g->discard[i][j]){
printf("\nPlayer %d's discard[%d]: %d, Expected: %d", i, j, g->discard[i][j], pre->discard[i][j]);
failed = 1;
}
}
}
}
//Check deck unchanged for other players
for (i = 0; i < g->numPlayers; i++){
//skip if current player
if (i == whoseTurn(g)){
continue;
}
if (pre->deckCount[i] != g->deckCount[i]){
printf("\nPlayer %d's deckCount: %d, Expected: %d", i, g->deckCount[i], pre->deckCount[i]);
failed = 1;
} else { //check each card
for (j = 0; j < g->deckCount[i]; j++){
if (pre->deck[i][j] != g->deck[i][j]){
printf("\nPlayer %d's deck[%d]: %d, Expected: %d", i, j, g->deck[i][j], pre->deck[i][j]);
failed = 1;
}
}
}
}
//Check hand unchanged for other players
for (i = 0; i < g->numPlayers; i++){
//skip if current player
if (i == whoseTurn(g)){
continue;
}
if (pre->handCount[i] != g->handCount[i]){
printf("\nPlayer %d's handCount: %d, Expected: %d", i, g->handCount[i], pre->handCount[i]);
failed = 1;
} else { //check each card
for (j = 0; j < g->handCount[i]; j++){
if (pre->hand[i][j] != g->hand[i][j]){
printf("\nPlayer %d's hand[%d]: %d, Expected: %d", i, j, g->hand[i][j], pre->hand[i][j]);
failed = 1;
}
}
}
}
//Check adventurer added to played pile
if (g->playedCardCount != pre->playedCardCount + 1){
printf("\nPlayed card count: %d, Expected: %d", g->playedCardCount, pre->playedCardCount + 1);
failed = 1;
} else if (g->playedCards[g->playedCardCount - 1] != TEST_CARD){
printf("\nLast played card: %d, Expected: %d", g->playedCards[g->playedCardCount - 1], TEST_CARD);
failed = 1;
}
//Check 1 treasure + extras removed from deck; other cards remain
if (g->deckCount[whoseTurn(g)] != pre->deckCount[whoseTurn(g)] - EXTRA_COUNT - 1){
printf("\nCurrent player's deck count: %d, Expected: %d", g->deckCount[whoseTurn(g)], pre->deckCount[whoseTurn(g)] - EXTRA_COUNT - 1);
failed = 1;
}
for (i = 0; i < g->deckCount[whoseTurn(g)]; i++){
if (g->deck[whoseTurn(g)][i] != EXTRA_CARD){
printf("\nCurrent player's deck[%d]: %d, Expected: %d", i, g->deck[whoseTurn(g)][i], EXTRA_CARD);
failed = 1;
}
}
//Check 1 treasure card added to hand, adventurer removed
if (g->handCount[whoseTurn(g)] != pre->handCount[whoseTurn(g)]){
printf("\nCurrent player's hand count: %d, Expected: %d", g->handCount[whoseTurn(g)], pre->handCount[whoseTurn(g)]);
failed = 1;
}
if (g->hand[whoseTurn(g)][g->handCount[whoseTurn(g)] - 1] != TREASURE){
printf("\nCurrent player's hand[%d]: %d, Expected: %d", g->handCount[whoseTurn(g)] - 1, g->hand[whoseTurn(g)][g->handCount[whoseTurn(g)] - 1], TREASURE);
failed = 1;
}
//Check extra cards added to discard
if (g->discardCount[whoseTurn(g)] != pre->discardCount[whoseTurn(g)] + EXTRA_COUNT){
printf("\nCurrent player's discard count: %d, Expected: %d", g->discardCount[whoseTurn(g)], pre->discardCount[whoseTurn(g)] + EXTRA_COUNT);
failed = 1;
}
for (i = 1; i <= EXTRA_COUNT; i++){
if (g->discard[whoseTurn(g)][g->discardCount[whoseTurn(g)] - i] != EXTRA_CARD){
printf("\nCurrent player's discard[%d]: %d, Expected: %d", g->discardCount[whoseTurn(g)] - i, g->discard[whoseTurn(g)][g->discardCount[whoseTurn(g)] - i], EXTRA_CARD);
failed = 1;
}
}
//Check no bonus coins added
if (coin_bonus != 0){
printf("\nCoin bonus after adventurer: %d, Expected: %d", coin_bonus, 0);
failed = 1;
}
//Final check
if (failed){
printf("\nResult: FAIL\n");
} else {
printf("none");
printf("\nResult: PASS\n");
}
*/
return 0;
}