Exemple #1
0
int main(int argc, char ** argv)
{
	createFrame();
	createNewBlockBatch();
	renderCanvas();

	while (inGame)
	{
		checkGameState();
		checkRowCompletion();
		spawnNewBlock();

		fetchUserInput();

		if(timer++ % 10 == 0 
			&& gameState == 0) {
			moveDown();
		}
		
		renderCanvas();
		usleep(wait);
	}

	endwin();

	return 0;
}
Exemple #2
0
int dispThread(SceSize args, void *argp)
{
  sceIoChdir(cwd);
  initBackground();
  
  while (exit_state != EXCEPTION)
  {
    if (exit_state)
    {
      setFadeMode(&main_fade,FADE_IN,0);
      if (getFadeState(&main_fade) == FADE_DONE) break;
    }
 
    if (checkGameState(GSQUARE))
    {
      g2dClear(BLACK);
      dispgSquare();
    }
    if (checkGameState(BANNER))
    {
      g2dClear(BLACK);
      dispBanner();
    }
    if (checkGameState(MENU))
    {
      drawMovingBackground();
      dispMenu();
    }
    if (checkGameState(INGAME))
    {
      drawMovingBackground();
      camera();
      drawLevel();
      drawUI();
    }
    if (checkGameState(LEVEL_TITLE))
    {
      g2dClear(WHITE);
      intraFontSetStyle(seriffont,1.f,BLACK,0,0,INTRAFONT_ALIGN_CENTER);
      intraFontPrint(seriffont,G2D_SCR_W/2,G2D_SCR_H/2,lvl.title);
    }
    if (checkGameState(END))
    {
      g2dClear(WHITE);
      g2dBeginRects(img.end);
      {
        g2dAdd();
      }
      g2dEnd();
    }
    
    drawFade(&main_fade);
    g2dFlip(G2D_VSYNC);
  }
  
  if (exit_state == EXCEPTION) dispException();
  
  return 0;
}
Exemple #3
0
int main() {
	srand(time(NULL));
	
	//new gameState
	struct gameState * randomState = malloc(sizeof(struct gameState));
	
	int i;
	int numPlayers;
	int kingdomCards[10];
	int randomSeed;
	int firstRun = 1;
	int returnValue;
	
	printf("Unit test 1\r\n");
	printf("Conducting %d random trials.\r\n", UNITTEST1_TRIALS);
	
	int foundErrors = 0;
	int trials;
	for (trials = 0; trials < UNITTEST1_TRIALS; trials++ ){
		//fuzz the state
		fuzzState(randomState);
	
		//semi-randomize inputs (within reason)
		numPlayers = randomNumPlayers();	
		unittest1_initiateKingdomCards(kingdomCards);
		randomSeed = rand();
		
		//run function and store results
		returnValue = initializeGame(numPlayers, kingdomCards, randomSeed, randomState);
		
		//test outputs:
		if (firstRun == 1)
			TestRandom();
		
		if (returnValue != -1) {
			foundErrors -= checkGameState(randomState, returnValue, numPlayers, kingdomCards);	//subtracts a negative to add
		}
		
		firstRun = 0;
	
	}
	
	printf("Unit Test 1 Complete.  I found %d errors\r\n", foundErrors);
	return 0;
}
Exemple #4
0
int main(int argc, char** argv) {

    srand(time(NULL));
    Square** board = randomizeBoard();
    int gameOver, gameWon, i;
    while(1)
    {
        printBoard(board);
        
        int gameWon = checkGameState(board);
        if(gameWon == 1)
        {
            printf("\nYou won! Congratulations!\n");
            return 0;
        }
        printf("\n\nEnter the row of the space you want to hit: ");
        int row;
        scanf("%d", &row);

        printf("\nEnter the column of the space you want to hit: ");
        int column;
        scanf("%d", &column);
        
        gameOver = updateBoard(board, row, column);
        if(gameOver == 1)
        {
            printf("\nYou hit a mine! Game Over");
            printUncoveredBoard(board);
            return 0;
        }
        
    }
    free(board);
    for(i = 0; i < SIZE; i++)
    {
        free(board[i]);
    }
    return (EXIT_SUCCESS);
}
//step through one cycle of the game
int step(int cycle,Agent agents[],Graph g,int maxCycles){
    
    int i;
    cycle++;
    
    for(i=0;i<=NUM_DETECTIVES;i++){
      if(i == THIEF) {
        //location of thief stored in graph
        setThiefLocation(g, getCurrentLocation(agents[i]));
      }

       Edge  nextMove = getNextMove(agents[i],g);  
       makeNextMove(g, agents[i], nextMove);
     
    }
    display(cycle,agents,g);
    int gameState = checkGameState(agents,g,cycle,maxCycles);
    if(gameState == CONTINUE){
        return cycle;
    } else {
        return gameState;
    }
}
Exemple #6
0
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;
}
int main(int argc, char * argv[]){
    Agent agents[NUM_DETECTIVES+1];
    
    if(argc < 4){
      printf("Incorrect usage: please enter filename1 filename2 maxCycles\n");
      exit(0);
    }

    int maxCycles = atoi(argv[3]);
    int cycle = 0;
    int seed = time(NULL);

    if(argc == 5) 
         seed = atoi(argv[4]);
 
    
    srand(seed);

    Graph g = readGraph(argv[1]);
    #ifdef DEBUG
        show(g);
    #endif
    
    initialiseAgents(argv[2],agents,maxCycles,g);
    #ifdef DEBUG
        stats(cycle,agents);
    #endif
    

  
    char command[MAXLINE];
    printf("\nPOLICE ACADEMY 1927");
    printf("\n\nRed alert! A thief is on the run.\n");
    printf("Agents, to your cars. You have %d hours.\n\n",maxCycles);
    display(cycle,agents,g);
    
    if(checkGameState(agents,g,cycle,maxCycles) != CONTINUE){
        freeResources(agents,g);
        return 0;
    }
    printf("Enter command: ");
    scanf("%s",command);
   
    
    while (strcmp(command,"quit") != 0){
        if(strcmp(command,"display") == 0){
             display(cycle,agents,g);
        }else if(strcmp(command,"run") == 0){
             cycle = run(cycle,maxCycles,agents,g);
        }else if(strcmp(command,"step") == 0){
             cycle = step(cycle,agents,g,maxCycles);
        }else if(strcmp(command,"stats") == 0){
             stats(cycle,agents);
        }else if(strcmp(command,"map") == 0){
             show(g);
             printf("\n");
        }
        if(cycle < 0) break;
        printf("Enter command: ");
        scanf("%s",command);
    }    
    freeResources(agents,g);
    return 0;
}
Exemple #8
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;

	
//---Test numBuys = 0 
//---Expected result: error
	printf("*** Testing numBuys = 0 ***\n");
	printf("Errors: ");
	//Create clean game
	if (initializeGame(NUM_PLAYERS, selectedCards, seed, g) == -1){
		printf("\nCould not initialize game. Testing aborted.");
		return -1;
	}
	//Set numBuys to 0
	g->numBuys = 0;
	//Save current state
	memcpy(pre, g, sizeof(struct gameState));
	//Attempt to buy card
	result = buyCard(TEST_CARD, 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 no supply remaining 
//---Expected result: error
	printf("*** Testing supplyCount = 0 ***\n");
	printf("Errors: ");
	//Create clean game
	if (initializeGame(NUM_PLAYERS, selectedCards, seed, g) == -1){
		printf("\nCould not initialize game. Testing aborted.");
		return -1;
	}
	//Set supplyCount for test card to 0
	g->supplyCount[TEST_CARD] = 0;
	//Save current state
	memcpy(pre, g, sizeof(struct gameState));
	//Attempt to buy card
	result = buyCard(TEST_CARD, 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 insufficient funds
//---Expected result: error
	printf("*** Testing coins < cost ***\n");
	printf("Errors: ");
	//Create clean game
	if (initializeGame(NUM_PLAYERS, selectedCards, seed, g) == -1){
		printf("\nCould not initialize game. Testing aborted.");
		return -1;
	}
	//Set coins to cost of card - 1
	g->coins = getCost(TEST_CARD) - 1;
	//Save current state
	memcpy(pre, g, sizeof(struct gameState));
	//Attempt to buy card
	result = buyCard(TEST_CARD, 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 invalid supply position
//---Expected result: error
	printf("*** Testing invalid position ***\n");
	printf("Errors: ");
	//Create clean game
	if (initializeGame(NUM_PLAYERS, selectedCards, seed, g) == -1){
		printf("\nCould not initialize game. Testing aborted.");
		return -1;
	}
	//Save current state
	memcpy(pre, g, sizeof(struct gameState));
	//Attempt to buy card at invalid position
	result = buyCard(treasure_map+1, 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 valid buy
/*---Expected results: 
	- Game and turn settings are unchanged except as noted below
	- Phase set to 1
	- numBuys decreased by 1
	- coins decreased by card cost
	- Supply count for other cards are unchanged
	- Supply count for selected card is decreased by 1
	- Other player's cards (hand, deck, discard) are unchanged
	- Played cards are unchanged		
	- Current player's hand and deck are unchanged
	- Current player's discardCount is 1 more than before buyCard
	- Current player's discard is the same except additional card in last position
*/
	printf("*** Testing valid buy ***\n");
	printf("Errors: ");
	//Create clean game
	if (initializeGame(NUM_PLAYERS, selectedCards, seed, g) == -1){
		printf("\nCould not initialize game. Testing aborted.");
		return -1;
	} 
	//Add sufficient coins and numBuys
	g->coins = getCost(TEST_CARD);
	g->numBuys = 1;
	//Save current state
	memcpy(pre, g, sizeof(struct gameState));
	//Run buyCard and check results
	failed = 0;
	result = buyCard(TEST_CARD, 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 = 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 (checkNumActions(pre, g) < 0){
		printf("\nnumActions: %d, Expected: %d", g->numActions, pre->numActions);
		failed = 1;
	}	
	//Check phase = 1
	if (g->phase != 1){
		printf("\nphase: %d, Expected: %d", g->phase, 1);
		failed = 1;
	}	
	//Check coins = coins_before - cost of card
	if (g->coins != pre->coins - getCost(TEST_CARD)){
		printf("\ncoins: %d, Expected: %d", g->coins, pre->coins - getCost(TEST_CARD));
		failed = 1;
	}
	//Check numBuys decreased by 1
	if (g->numBuys != pre->numBuys - 1){
		printf("\nnumBuys: %d, Expected: %d", g->numBuys, pre->numBuys - 1);
		failed = 1;
	}
	//Check supply for bought card is decreased by 1
	if (g->supplyCount[TEST_CARD] != pre->supplyCount[TEST_CARD]-1){
		printf("\nSupply count for card %d: %d, Expected: %d", TEST_CARD, g->supplyCount[TEST_CARD], pre->supplyCount[TEST_CARD]-1);
		failed = 1;
	}
	//Check supply for other cards remains the same
	for (i = 0; i <= treasure_map; i++){
		//if test card, skip
		if (i == TEST_CARD){
			continue;
		}
		if (pre->supplyCount[i] != g->supplyCount[i]){
			printf("\nSupply count for card %d: %d, Expected: %d", i, g->supplyCount[i], pre->supplyCount[i]);
			failed = 1;
		}
	}
	//Check all hand, deck and played cards unchanged
	if (checkHands(pre, g) < 0){
		printf("\nHands changed after buyCard\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 (checkDecks(pre, g) < 0){
		printf("\nDecks changed after buyCard\n");
		//Print expected and actual deck for each player
		for (i = 0; i < NUM_PLAYERS; i++){
			printf("    Deck for player %d:\n", i);
			printf("      Count: %d, Expected: %d\n", g->deckCount[i], pre->deckCount[i]);
			if (g->deckCount[i] > 0){
				printf("      Actual Cards: ");
				for (j = 0; j < g->deckCount[i]; j++){
					printf("%d ", g->deck[i][j]);
				}
				printf("\n      Expected Cards: ");
				for (j = 0; j < pre->deckCount[i]; j++){
					printf("%d ", pre->deck[i][j]);
				}
			}
		}
		failed = 1;
	}
	if (checkPlayed(pre, g) < 0){
		printf("\nPlayed cards changed after buyCard\n");
		//Print expected and actual played cards
		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 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 current player's discardCount increased by 1
	if (g->discardCount[whoseTurn(g)] != pre->discardCount[whoseTurn(g)]+1){
			printf("\nCurrent player's discardCount: %d, Expected: %d", g->discardCount[whoseTurn(g)], pre->discardCount[whoseTurn(g)]+1);
			failed = 1;
	}
	//Check current player's discard contains same cards plus new card in last position
	for (i = 0; i < g->discardCount[whoseTurn(g)]-1; i++){
		if (pre->discard[whoseTurn(g)][i] != g->discard[whoseTurn(g)][i]){
			printf("\nCurrent player's discard[%d]: %d, Expected: %d", i, g->discard[whoseTurn(g)][i], pre->discard[whoseTurn(g)][i]);
			failed = 1;
		}
	}
	if (g->discard[whoseTurn(g)][g->discardCount[whoseTurn(g)]-1] != TEST_CARD){
		printf("\nGained card: %d, Expected: %d", g->discard[whoseTurn(g)][g->discardCount[whoseTurn(g)]-1], TEST_CARD);
		failed = 1;		
	}
	
	//Final check
	if (failed){
		printf("\nResult: FAIL\n\n");
	} else {
		printf("none");
		printf("\nResult: PASS\n\n");
	}

//---Test buy with embargo
/*---Expected results: 
	- Game and turn settings are unchanged except as noted below
	- Phase set to 1
	- numBuys decreased by 1
	- coins decreased by card cost
	- Supply count for other cards are unchanged
	- Supply count for selected card is decreased by 1
	- Supply count for curse card decreased by 1
	- Embargo tokens for other cards are unchanged
	- Embargo tokens for selected card is decreased by 1
	- Other player's cards (hand, deck, discard) are unchanged
	- Played cards are unchanged		
	- Current player's hand and deck are unchanged
	- Current player's discardCount is 2 more than before buyCard
	- Current player's discard is the same except additional card and curse card
*/
	printf("*** Testing valid buy with embargo ***\n");
	printf("Errors: ");
	//Create clean game
	if (initializeGame(NUM_PLAYERS, selectedCards, seed, g) == -1){
		printf("\nCould not initialize game. Testing aborted.");
		return -1;
	} 
	//Add sufficient coins and numBuys
	g->coins = getCost(TEST_CARD);
	g->numBuys = 1;
	//Add embargo to test card
	g->embargoTokens[TEST_CARD] = 1;
	//Save current state
	memcpy(pre, g, sizeof(struct gameState));
	//Run buyCard and check results
	failed = 0;
	result = buyCard(TEST_CARD, 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;
	}
	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 (checkNumActions(pre, g) < 0){
		printf("\nnumActions: %d, Expected: %d", g->numActions, pre->numActions);
		failed = 1;
	}	
	//Check phase = 1
	if (g->phase != 1){
		printf("\nphase: %d, Expected: %d", g->phase, 1);
		failed = 1;
	}	
	//Check coins = coins_before - cost of card
	if (g->coins != pre->coins - getCost(TEST_CARD)){
		printf("\ncoins: %d, Expected: %d", g->coins, pre->coins - getCost(TEST_CARD));
		failed = 1;
	}
	//Check numBuys decreased by 1
	if (g->numBuys != pre->numBuys - 1){
		printf("\nnumBuys: %d, Expected: %d", g->numBuys, pre->numBuys - 1);
		failed = 1;
	}
	//Check supply for bought card is decreased by 1
	if (g->supplyCount[TEST_CARD] != pre->supplyCount[TEST_CARD]-1){
		printf("\nSupply count for card %d: %d, Expected: %d", TEST_CARD, g->supplyCount[TEST_CARD], pre->supplyCount[TEST_CARD]-1);
		failed = 1;
	}
	//Check supply for curse card is decreased by 1
	if (g->supplyCount[0] != pre->supplyCount[0]-1){
		printf("\nSupply count for curse card: %d, Expected: %d", g->supplyCount[0], pre->supplyCount[0]-1);
		failed = 1;
	}
	//Check supply for other cards remains the same
	for (i = 1; i <= treasure_map; i++){
		//if test card, skip
		if (i == TEST_CARD){
			continue;
		}
		if (pre->supplyCount[i] != g->supplyCount[i]){
			printf("\nSupply count for card %d: %d, Expected: %d", i, g->supplyCount[i], pre->supplyCount[i]);
			failed = 1;
		}
	}
	//Check embargo tokens for bought card is decreased by 1
	if (g->embargoTokens[TEST_CARD] != pre->embargoTokens[TEST_CARD]-1){
		printf("\nEmbargo tokens for card %d: %d, Expected: %d", TEST_CARD, g->embargoTokens[TEST_CARD], pre->embargoTokens[TEST_CARD]-1);
		failed = 1;
	}
	//Check embargo tokens for other cards remains the same
	for (i = 0; i <= treasure_map; i++){
		//if test card, skip
		if (i == TEST_CARD){
			continue;
		}
		if (pre->embargoTokens[i] != g->embargoTokens[i]){
			printf("\nEmbargo tokens for card %d: %d, Expected: %d", i, g->embargoTokens[i], pre->embargoTokens[i]);
			failed = 1;
		}
	}
	//Check all hand, deck and played cards unchanged
	if (checkHands(pre, g) < 0){
		printf("\nHands changed after buyCard\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 (checkDecks(pre, g) < 0){
		printf("\nDecks changed after buyCard\n");
		//Print expected and actual deck for each player
		for (i = 0; i < NUM_PLAYERS; i++){
			printf("    Deck for player %d:\n", i);
			printf("      Count: %d, Expected: %d\n", g->deckCount[i], pre->deckCount[i]);
			if (g->deckCount[i] > 0){
				printf("      Actual Cards: ");
				for (j = 0; j < g->deckCount[i]; j++){
					printf("%d ", g->deck[i][j]);
				}
				printf("\n      Expected Cards: ");
				for (j = 0; j < pre->deckCount[i]; j++){
					printf("%d ", pre->deck[i][j]);
				}
			}
		}
		failed = 1;
	}
	if (checkPlayed(pre, g) < 0){
		printf("\nPlayed cards changed after buyCard\n");
		//Print expected and actual played cards
		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 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 current player's discardCount increased by 2
	if (g->discardCount[whoseTurn(g)] != pre->discardCount[whoseTurn(g)]+2){
			printf("\nCurrent player's discardCount: %d, Expected: %d", g->discardCount[whoseTurn(g)], pre->discardCount[whoseTurn(g)]+2);
			failed = 1;
	}
	//Check current player's discard contains same cards plus new card and curse in last two positions
	for (i = 0; i < g->discardCount[whoseTurn(g)]-2; i++){
		if (pre->discard[whoseTurn(g)][i] != g->discard[whoseTurn(g)][i]){
			printf("\nCurrent player's discard[%d]: %d, Expected: %d", i, g->discard[whoseTurn(g)][i], pre->discard[whoseTurn(g)][i]);
			failed = 1;
		}
	}
	if (g->discard[whoseTurn(g)][g->discardCount[whoseTurn(g)]-1] == TEST_CARD){
		if (g->discard[whoseTurn(g)][g->discardCount[whoseTurn(g)]-2] != 0){
			printf("\nGained card: %d, Expected: %d", g->discard[whoseTurn(g)][g->discardCount[whoseTurn(g)]-1], 0);
			failed = 1;		
		}
	} else if (g->discard[whoseTurn(g)][g->discardCount[whoseTurn(g)]-1] == 0){
		if (g->discard[whoseTurn(g)][g->discardCount[whoseTurn(g)]-2] != TEST_CARD){
			printf("\nGained card: %d, Expected: %d", g->discard[whoseTurn(g)][g->discardCount[whoseTurn(g)]-1], TEST_CARD);
			failed = 1;		
		}
	} else {
		printf("\nGained card: %d, Expected: %d or %d", g->discard[whoseTurn(g)][g->discardCount[whoseTurn(g)]-1], TEST_CARD, 0);
		failed = 1;			
	}
	
	//Final check
	if (failed){
		printf("\nResult: FAIL\n");
	} else {
		printf("none");
		printf("\nResult: PASS\n");
	}

	
	return 0;
}
Exemple #9
0
void renderCanvas()
{
	clear();
	checkGameState();
	refresh();
}