static int getKPILeader(Game g) {
    int i = 1;
    int kpileader = 0;
    while(i <= 3) {
        if(getKPIpoints(g, i) > kpileader) {
            kpileader = getKPIpoints(g, i);
        }
        i++;
    }
    return kpileader;
}
static int getWinner(Game g) {
    int i = 1;
    int winner = 0;
    int kpileader = 0;
    while(i <= 3) {
        if(getKPIpoints(g, i) > kpileader) {
            kpileader = getKPIpoints(g, i);
            winner = i;
        }
        i++;
    }
    if(getTurnNumber(g) > 9002) {
        winner = 0;
    }
    printf("\nTurn: %d\n", getTurnNumber(g));
    return winner;
}
Exemple #3
0
int checkForWinner(Game g) {
   int winner = NO_ONE;
   int playerIndex;

   playerIndex = UNI_A;
   while (playerIndex <= UNI_C) {
      // check if the player is over or equal the WINNING_KPI
      if (getKPIpoints(g, playerIndex) >= WINNING_KPI) {
         winner = playerIndex;
      }
      playerIndex++;
   }

   return winner;
}
Exemple #4
0
// function to identify whether we've reached the game over
// not sure if it's to be implemented in Game.c yet?
int getWinner (Game g) {
    int player = 1;
    int points = 0;
    int max = 0;
    int max_player = 0;
    while (player <= 3) {
        points = getKPIpoints (g, player);
        if (points > max) {
            max = points;
            max_player = player;
        }
        player++;
    }
    if (max < 150) {
        max_player = 0;
    }
    return max_player;
}
Exemple #5
0
void printScore (Game g) {
    int player = getWhoseTurn (g);
    printf ("============== YOUR STUFF ==============\n");
    printf ("Students:\n");
    printf ("THD: %d ", getStudents (g, player, STUDENT_THD));
    printf ("BPS: %d ", getStudents (g, player, STUDENT_BPS));
    printf ("BQN: %d ", getStudents (g, player, STUDENT_BQN));
    printf ("MJ: %d ", getStudents (g, player, STUDENT_MJ));
    printf ("MTV: %d ", getStudents (g, player, STUDENT_MTV));
    printf ("M$: %d\n", getStudents (g, player, STUDENT_MMONEY));
    printf ("Your current score:\n");
    printf ("KPI: %d ", getKPIpoints (g, player));
    printf ("Pubs: %d ", getPublications (g, player));
    printf ("IPs: %d\n", getIPs (g, player));
    printf ("Built:\n");
    printf ("ARCs: %d ", getARCs (g, player));
    printf ("Campuses: %d ", getCampuses (g, player));
    printf ("GO8s: %d\n", getGO8s (g, player));
    printf ("========================================\n");
}
Exemple #6
0
void testInitialisation (Game testGame){
   
   action testAction;
   
   printf ("Testing initial conditions.\n");
   
   printf ("Testing getDiscipline.\n");
   assert (getDiscipline(testGame, 0) == STUDENT_BQN);
   assert (getDiscipline(testGame, 1) == STUDENT_MMONEY);
   assert (getDiscipline(testGame, 2) == STUDENT_MJ);
   assert (getDiscipline(testGame, 3) == STUDENT_MMONEY);
   assert (getDiscipline(testGame, 4) == STUDENT_MJ);
   assert (getDiscipline(testGame, 5) == STUDENT_BPS);
   assert (getDiscipline(testGame, 6) == STUDENT_MTV);
   assert (getDiscipline(testGame, 7) == STUDENT_MTV);
   assert (getDiscipline(testGame, 8) == STUDENT_BPS);
   assert (getDiscipline(testGame, 9) == STUDENT_MTV);
   assert (getDiscipline(testGame, 10) == STUDENT_BQN);
   assert (getDiscipline(testGame, 11) == STUDENT_MJ);
   assert (getDiscipline(testGame, 12) == STUDENT_BQN);
   assert (getDiscipline(testGame, 13) == STUDENT_THD);
   assert (getDiscipline(testGame, 14) == STUDENT_MJ);
   assert (getDiscipline(testGame, 15) == STUDENT_MMONEY);
   assert (getDiscipline(testGame, 16) == STUDENT_MTV);
   assert (getDiscipline(testGame, 17) == STUDENT_BQN);
   assert (getDiscipline(testGame, 18) == STUDENT_BPS);
   
   printf ("Testing getDiceValue\n");
   assert (getDiceValue(testGame, 0) == 9);
   assert (getDiceValue(testGame, 1) == 10);
   assert (getDiceValue(testGame, 2) == 8);
   assert (getDiceValue(testGame, 3) == 12);
   assert (getDiceValue(testGame, 4) == 6);
   assert (getDiceValue(testGame, 5) == 5);
   assert (getDiceValue(testGame, 6) == 3);
   assert (getDiceValue(testGame, 7) == 11);
   assert (getDiceValue(testGame, 8) == 3);
   assert (getDiceValue(testGame, 9) == 11);
   assert (getDiceValue(testGame, 10) == 4);
   assert (getDiceValue(testGame, 11) == 6);
   assert (getDiceValue(testGame, 12) == 4);
   assert (getDiceValue(testGame, 13) == 7);
   assert (getDiceValue(testGame, 14) == 9);
   assert (getDiceValue(testGame, 15) == 2);
   assert (getDiceValue(testGame, 16) == 8);
   assert (getDiceValue(testGame, 17) == 10);
   assert (getDiceValue(testGame, 18) == 5);
   
   printf ("Testing Most ARC\n");
   assert (getMostARCs(testGame) == NO_ONE);
   
   printf ("Testing most publications\n");
   assert (getMostPublications (testGame) == NO_ONE);
   
   printf ("Testing turnNumber\n");
   assert (getTurnNumber(testGame) == -1);
   
   printf ("Testing whoseTurn.\n");
   assert (getWhoseTurn (testGame) == NO_ONE);

   printf("Testing getCampus (content of given vertex) \n");
   assert (getCampus (testGame, "RLBLR") == VACANT_VERTEX);
   assert (getCampus (testGame, "RLBBR") == VACANT_VERTEX);
   assert (getCampus (testGame, "LRL") == VACANT_VERTEX);
   
   printf("Testing getARC (content of given edge) \n");
   assert (getARC (testGame, "L") == VACANT_ARC);
   assert (getARC (testGame, "R") == VACANT_ARC);
   assert (getARC (testGame, "LR") == VACANT_ARC);
   assert (getARC (testGame, "RR") == VACANT_ARC);
   
   printf ("Testing isLegalAction\n");
   assert (isLegalAction (testGame, testAction) == FALSE);
   
   printf ("Testing KPI points\n");
   assert (getKPIpoints (testGame, UNI_A) == 0);
   assert (getKPIpoints (testGame, UNI_B) == 0);
   assert (getKPIpoints (testGame, UNI_C) == 0);
   
   printf ("Testing getARCs (number of ARC grants) \n");
   assert (getARCs (testGame, UNI_A) == 0);
   assert (getARCs (testGame, UNI_B) == 0);
   assert (getARCs (testGame, UNI_C) == 0);
   
   printf ("Testing GO8 (number of G08 campus) \n");
   assert (getGO8s (testGame, UNI_A) == 0);
   assert (getGO8s (testGame, UNI_B) == 0);
   assert (getGO8s (testGame, UNI_C) == 0);
   
   printf ("Testing getCampuses (number of normal campuses)\n");
   assert (getCampuses (testGame, UNI_A) == 2);
   assert (getCampuses (testGame, UNI_B) == 2);
   assert (getCampuses (testGame, UNI_C) == 2);
   
   printf ("Testing IPs (number of IP patent) \n");
   assert (getIPs(testGame, UNI_A) == 0);
   assert (getIPs(testGame, UNI_B) == 0);
   assert (getIPs(testGame, UNI_C) == 0);
   
   printf ("Testing publications\n");
   assert (getPublications(testGame, UNI_A) == 0);
   assert (getPublications(testGame, UNI_B) == 0);
   assert (getPublications(testGame, UNI_C) == 0);
 
   printf ("Testing number of students of UNI_A\n");
   assert (getStudents (testGame, UNI_A, STUDENT_THD) == 0);
   assert (getStudents (testGame, UNI_A, STUDENT_BPS) == 3);
   assert (getStudents (testGame, UNI_A, STUDENT_BQN) == 3);
   assert (getStudents (testGame, UNI_A, STUDENT_MJ) == 1);
   assert (getStudents (testGame, UNI_A, STUDENT_MTV) == 1);
   assert (getStudents (testGame, UNI_A, STUDENT_MMONEY) == 1);

   printf ("Testing number of students of UNI_B\n");
   assert (getStudents (testGame, UNI_B, STUDENT_THD) == 0);
   assert (getStudents (testGame, UNI_B, STUDENT_BPS) == 3);
   assert (getStudents (testGame, UNI_B, STUDENT_BQN) == 3);
   assert (getStudents (testGame, UNI_B, STUDENT_MJ) == 1);
   assert (getStudents (testGame, UNI_B, STUDENT_MTV) == 1);
   assert (getStudents (testGame, UNI_B, STUDENT_MMONEY) == 1);
   
   printf ("Testing number of students of UNI_C\n");
   assert (getStudents (testGame, UNI_C, STUDENT_THD) == 0);
   assert (getStudents (testGame, UNI_C, STUDENT_BPS) == 3);
   assert (getStudents (testGame, UNI_C, STUDENT_BQN) == 3);
   assert (getStudents (testGame, UNI_C, STUDENT_MJ) == 1);
   assert (getStudents (testGame, UNI_C, STUDENT_MTV) == 1);
   assert (getStudents (testGame, UNI_C, STUDENT_MMONEY) == 1);
   

   printf ("Testing getExchangeRate for UNI_A\n");
   assert (getExchangeRate (testGame, UNI_A, STUDENT_BPS, STUDENT_BPS) == 3);
   assert (getExchangeRate (testGame, UNI_A, STUDENT_BPS, STUDENT_BQN) == 3);
   assert (getExchangeRate (testGame, UNI_A, STUDENT_BPS, STUDENT_MJ) == 3);
   assert (getExchangeRate (testGame, UNI_A, STUDENT_BPS, STUDENT_MTV) == 3);
   assert (getExchangeRate (testGame, UNI_A, STUDENT_BPS, STUDENT_MMONEY) == 3);
   
   assert (getExchangeRate (testGame, UNI_A, STUDENT_MMONEY, STUDENT_MMONEY) == 3);
   assert (getExchangeRate (testGame, UNI_A, STUDENT_MMONEY, STUDENT_BPS) == 3);
   assert (getExchangeRate (testGame, UNI_A, STUDENT_MMONEY, STUDENT_BQN) == 3);
   assert (getExchangeRate (testGame, UNI_A, STUDENT_MMONEY, STUDENT_MJ) == 3);
   assert (getExchangeRate (testGame, UNI_A, STUDENT_MMONEY, STUDENT_MTV) == 3);
   
   assert (getExchangeRate (testGame, UNI_A, STUDENT_MTV, STUDENT_MTV) == 3);
   assert (getExchangeRate (testGame, UNI_A, STUDENT_MTV, STUDENT_BPS) == 3);
   assert (getExchangeRate (testGame, UNI_A, STUDENT_MTV, STUDENT_BQN) == 3);
   assert (getExchangeRate (testGame, UNI_A, STUDENT_MTV, STUDENT_MJ) == 3);
   assert (getExchangeRate (testGame, UNI_A, STUDENT_MTV, STUDENT_MMONEY) == 3);
   
   assert (getExchangeRate (testGame, UNI_A, STUDENT_BQN, STUDENT_BQN) == 3);
   assert (getExchangeRate (testGame, UNI_A, STUDENT_BQN, STUDENT_BPS) == 3);
   assert (getExchangeRate (testGame, UNI_A, STUDENT_BQN, STUDENT_MJ) == 3);
   assert (getExchangeRate (testGame, UNI_A, STUDENT_BQN, STUDENT_MTV) == 3);
   assert (getExchangeRate (testGame, UNI_A, STUDENT_BQN, STUDENT_MMONEY) == 3);
   
   assert (getExchangeRate (testGame, UNI_A, STUDENT_MJ, STUDENT_MJ) == 3);
   assert (getExchangeRate (testGame, UNI_A, STUDENT_MJ, STUDENT_BPS) == 3);
   assert (getExchangeRate (testGame, UNI_A, STUDENT_MJ, STUDENT_BQN) == 3);
   assert (getExchangeRate (testGame, UNI_A, STUDENT_MJ, STUDENT_MTV) == 3);
   assert (getExchangeRate (testGame, UNI_A, STUDENT_MJ, STUDENT_MMONEY) == 3);
  
   printf ("All tests passed\n\n");
   
   
}
Exemple #7
0
//initially everyone has 0
//already in testGame.c
void testgetKPIpoints (void) {
    assert (getKPIpoints(g, UNI_A) == 0);
    assert (getKPIpoints(g, UNI_B) == 0);
    assert (getKPIpoints(g, UNI_C) == 0);
}
Exemple #8
0
int main(int argc, char * argv[]){
    int disciplines[] = DEFAULT_DISCIPLINES;
    int dice[] = DEFAULT_DICE;
    int turnOver = FALSE;
    int winner = NO_ONE;
    int diceValue;
    action move;
    int whoseTurn = NO_ONE;

    srand(time(NULL)); //initialises a seed
    Game g = newGame(disciplines,dice);

    while (winner == NO_ONE) {

        diceValue = rollDice(2,6);

        throwDice(g,diceValue);

        printf("[Turn %d] The turn now belongs to University %d!\n",
            getTurnNumber(g),
            getWhoseTurn(g));
        printf("The dice casted a %d!\n", diceValue);

        whoseTurn = getWhoseTurn(g);
        //loop until player action is PASS
        turnOver = FALSE;
        while (!turnOver) {
            move = getMove(g);
            //print info about move
            printf("Move %d \n",move.actionCode);
            assert(isLegalAction(g, move));

            if (move.actionCode == START_SPINOFF) {

                //decide if outcome is patent or publication
                if (rand() % 3 <= 1) {
                    move.actionCode = OBTAIN_PUBLICATION;
                } else {
                    move.actionCode = OBTAIN_IP_PATENT;
                }
            }

            if(move.actionCode == PASS){
                 turnOver = TRUE;
                 printf("Pass\n");
            }
            makeAction(g, move);


            if(getKPIpoints(g, whoseTurn) >= WINNING_KPI){
                winner = whoseTurn;
                turnOver = TRUE;
                printf("Winner %d\n",whoseTurn);
            }

        }
    }


    // TODO print statistics

    // TODO free memory

    return EXIT_SUCCESS;
}
Exemple #9
0
int main(int argc, char *argv[]) {
   // miscellaneous
   /*int disciplines[NUM_REGIONS];
   int dice[NUM_REGIONS];*/
   Game g;
   
   // store the winner of each game
   int winner;
   
   // store game states within the game
   int keepPlaying;
   int turnFinished;
   int diceRollAmount;
   
   // random
   char *actions[] = ACTION_NAMES;
   int diceRoll;
   
   int passedTurns = 0;
            
   // seed rand!
   srand(time(NULL));
   
   // while the game is wanting to be played, create new game, etc.
   keepPlaying = TRUE;
   while (keepPlaying == TRUE) {
      // create the game
      //randomDisciplines(disciplines);
      //randomDice(dice);
      
      // you can change this to randomiseDisciplines() and randomiseDice() later
      int disciplines[NUM_REGIONS] = {CYAN,PURP,YELL,PURP,YELL,RED ,GREE,GREE, RED ,GREE,CYAN,YELL,CYAN,BLUE,YELL,PURP,GREE,CYAN,RED };
      int dice[NUM_REGIONS] = {9,10,8,12,6,5,3,7,3,11,4,6,4,9,9,2,8,10,5};

      // rig board like the real game
      rigBoard(disciplines, dice);
      g = newGame(disciplines, dice);
      
      printf("Game created! Now playing...\n");
      
      // start the game with noone as the winner
      winner = NO_ONE;
      while (winner == NO_ONE) {
         printLineBreak();
         // start new turn by setting turnFinished to false then
         // rolling the dice
         
         diceRollAmount = 0;
         diceRoll = 0;
         while (diceRollAmount < DICE_AMOUNT) {
            diceRoll += rollDice();
            diceRollAmount++;
         }
         
         throwDice(g, diceRoll);
         
         // new turn means new line break!
         printf("[Turn %d] The turn now belongs to University %c!\n", 
            getTurnNumber(g),
            getWhoseTurn(g) + UNI_CHAR_NAME);
//         printf("The dice has casted a %d!\n", diceRoll);
         
         printf("\n");
         
         
         // keep going through the player's turn until
         // he/she decided to pass and finish the turn
         turnFinished = FALSE;
         while (turnFinished == FALSE && passedTurns < MAX_PASS) {
            // processes requests and all subrequests for a move and
            // checks if they are legal. only gives a move within the
            // scope of the defined actionCodes that is legal
            int turnPerson = getWhoseTurn(g);
/*            printf("Stats for %c:\n", turnPerson + UNI_CHAR_NAME);
            printf("KPIs: %d\n", getKPIpoints(g, turnPerson));
            printf("ARCs: %d\n", getARCs(g, turnPerson));
            printf("Campuses: %d\n", getCampuses(g, turnPerson));
            printf("GO8s: %d\n", getGO8s(g, turnPerson));
            printf("Publications: %d\n", 
               getPublications(g, turnPerson));
            printf("Patents: %d\n", 
               getIPs(g, turnPerson));
            int discipleIndex = 0;
            char *discipleNames[] = DISCIPLE_NAMES;
            while (discipleIndex < NUM_DISCIPLINES) {
               printf("Type %s: %d\n", discipleNames[discipleIndex],
                  getStudents(g, turnPerson, discipleIndex));
               discipleIndex++;
            } 
*/            printf("\n");
            
            action a = decideAction(g);
            
            // if not passing, make the move; otherwise end the turn
            if (a.actionCode == PASS) {
               turnFinished = TRUE;
               printf("You have passed onto the next person.\n");
            } else {
              
               // write what the player did, for a logs sake.
 /*              printf("The action '%s' has being completed.\n", 
                       actions[a.actionCode]);
               if (a.actionCode == BUILD_CAMPUS 
                   || a.actionCode == OBTAIN_ARC 
                   || a.actionCode == BUILD_GO8) {
                  printf(" -> Destination: %s\n", a.destination);
               } else if (a.actionCode == RETRAIN_STUDENTS) {
                  printf(" -> DisciplineTo: %d\n", a.disciplineTo);
                  printf(" -> DisciplineFrom: %d\n", a.disciplineFrom);
               }
*/
               assert(isLegalAction(g, a));                                   
            
               // break this and the code dies. trololol!
               if (a.actionCode == START_SPINOFF) {
                  if (rand() % 3 <= 1) {
                     a.actionCode = OBTAIN_PUBLICATION;
                  } else {
                     a.actionCode = OBTAIN_IP_PATENT;               
                  }
               }

               makeAction(g, a);
               
               if (a.actionCode == PASS) {
                  passedTurns++;
               } else {
                  passedTurns = 0;
               }
               
               if (passedTurns >= MAX_PASS || getKPIpoints(g, turnPerson) >= WINNING_KPI) {
                  turnFinished = TRUE;
                  
               }
            }
            
            // if there is not a winner or pass, add a seperating line
            // to seperate actions being clumped together
            if (turnFinished == FALSE) {
               printf("\n");
            }
         }
         
         // check if there is a winner
         winner = checkForWinner(g);
      }
      
      if (passedTurns >= MAX_PASS) {
         printf("AI passes too much.\n");
         return EXIT_FAILURE;
      }
      
      printLineBreak();
      printf("GAME OVER!\n");
      printf("Vice Chanceller %c Won in %d Turns!!\n", 
             winner + UNI_CHAR_NAME,
             getTurnNumber(g));
             
      printf("\n");
      int counter = UNI_A;
      while (counter < NUM_UNIS + UNI_A) {
         printf("Uni %c scored %d KPIs\n", counter + UNI_CHAR_NAME,
                getKPIpoints(g, counter));
         counter++;
      }
      printLineBreak();
      
      disposeGame(g);
      
      // ask to play again
      printf("Ctrl+C will exit the game.\nOtherwise, the game will "
             "recommence by hitting enter.");
      int a = scanf("%*c");
      a++;
   }     
   
   return EXIT_SUCCESS;
}
Exemple #10
0
//Sample out testing simple things
void testInitialState(Game g){
   printf("Testing initialState!\n");
   int disciplines[] = DEFAULT_DISCIPLINES;
   int dice[] = DEFAULT_DICE;
   //Check each region produces correct disciplines
   int regionID = 0;
   while (regionID < NUM_REGIONS) {
      assert(getDiscipline(g,regionID) == disciplines[regionID]);
      regionID ++;
   }

   //Check what dice value produces students in the specified region
   regionID = 0;
   while (regionID < NUM_REGIONS) {
      assert(getDiceValue(g,regionID) == dice[regionID]);
      regionID ++;
   }

   assert(getMostARCs(g) == NO_ONE);
   assert(getMostPublications(g) == NO_ONE);
   assert(getTurnNumber(g) == -1);
   assert(getWhoseTurn(g) == NO_ONE);

   //Check individual uni values
   int uni = UNI_A;
   while(uni <= UNI_C){

      //Check Uni's exchange rates
      int testStudentFrom = STUDENT_BPS;
      int testStudentTo = STUDENT_BPS;
      while (testStudentFrom <= STUDENT_MMONEY) {
         while (testStudentTo <= STUDENT_MMONEY) {
            if (testStudentFrom != testStudentTo) {
               assert(getExchangeRate (g, uni, testStudentFrom, testStudentTo) == 3);
            }
            testStudentTo ++;
         }
         testStudentFrom ++;
         testStudentTo = STUDENT_BPS;
      }

      assert(getKPIpoints(g,uni) == 20);
      assert(getARCs(g,uni) == 0);
      assert(getGO8s(g,uni) == 0);
      assert(getCampuses(g,uni) == 2);
      assert(getPublications(g,uni) == 0);
      assert(getIPs(g,uni) == 0);

      //Check initial student values
      assert(getStudents(g,uni,STUDENT_THD)==0);
      assert(getStudents(g,uni,STUDENT_BPS)==3);
      assert(getStudents(g,uni,STUDENT_BQN)==3);
      assert(getStudents(g,uni,STUDENT_MJ)==1);
      assert(getStudents(g,uni,STUDENT_MTV)==1);
      assert(getStudents(g,uni,STUDENT_MMONEY)==1);

      uni++;
   }
   //Test isLegalAction at Terra Nullis
   action passAction;
   action CampusAction;
   action GO8Action;
   action ARCAction;
   action spinoffAction;
   action publicationAction;
   action patentAction;
   action retrainAction;
   passAction.actionCode = PASS;
   CampusAction.actionCode = BUILD_CAMPUS;
   GO8Action.actionCode = BUILD_GO8;
   ARCAction.actionCode = OBTAIN_ARC;
   spinoffAction.actionCode = START_SPINOFF;
   publicationAction.actionCode = OBTAIN_PUBLICATION;
   patentAction.actionCode = OBTAIN_IP_PATENT;
   retrainAction.actionCode = RETRAIN_STUDENTS;
   assert(isLegalAction(g, passAction) == FALSE);
   assert(isLegalAction(g, CampusAction) == FALSE);
   assert (isLegalAction(g, GO8Action) == FALSE);
   assert(isLegalAction(g, ARCAction) == FALSE);
   assert(isLegalAction(g, spinoffAction) == FALSE);
   assert(isLegalAction(g, publicationAction) == FALSE);
   assert(isLegalAction(g, patentAction) == FALSE);
   assert(isLegalAction(g, retrainAction) == FALSE);
   printf ("All initialState tests passed!\n");
}
int main (int argc, char * argv[]) {

	int disciplines[19] = {STUDENT_BQN, STUDENT_MMONEY, STUDENT_MJ, \
		STUDENT_MMONEY, STUDENT_MJ, STUDENT_BPS, STUDENT_MTV, \
		STUDENT_MTV, STUDENT_BPS,STUDENT_MTV, STUDENT_BQN, \
		STUDENT_MJ, STUDENT_BQN, STUDENT_THD, STUDENT_MJ, \
		STUDENT_MMONEY, STUDENT_MTV, STUDENT_BQN, STUDENT_BPS};

	int dice[19] = {9,10,8,12,6,5,3,11,3,11,4,6,4,7,9,2,8,10,5};

	Game g = newGame (disciplines, dice);
	action a;
//	int score = 0; //This stores the KPI points of current player 
	int curPlayer = NO_ONE; 
	int curTurn = 0; 
	int playerKPI = 0;
	int numStudents[MAX_STU_TYPES];
	int legal = 0;
	int diceScore = 0; 
	int spinoffDice = 0;
	//int discipline = 0;
	int counter = 0; 

	char *degrees[] = \
		  {"THDs", "BPSs", "BQNs", "MJs", "MTVs", "MMONEYs"};
	


	printf ("New game created, variables are initialized.\n");
	printf ("Let the game begin!\n\n");

	while (playerKPI < MAX_KPIPTS) {
		
		//To simulate an actual real life dice, we throw two dice 
		diceScore = rollDice();
		throwDice (g, diceScore);

		curTurn = getTurnNumber (g);
		curPlayer = getWhoseTurn (g);
		printf ("Turn number: %d\n", curTurn);
		printf ("Player %d's turn. Rolling dice.\n", curPlayer);
		printf ("The two dice rolled a %d! \n", diceScore);

		printf ("You currently have: \n");
		counter = 0;
		while (counter < MAX_STU_TYPES) {
			numStudents[counter] = getStudents (g, curPlayer, counter);
			printf ("    %d: %s\n", numStudents[counter],\
								    degrees[counter]);
			counter ++;
		}
		actionOptions ();
		a = actionPrompt (g);
		legal = isLegalAction (g, a);

		while (a.actionCode != PASS) {
			while (legal == FALSE) {
				printf ("The chosen action is illegal, try again.\n");
				actionPrompt (g);
				legal = isLegalAction (g, a);
			}

			if (a.actionCode == START_SPINOFF) {
				//Ensures dice returns 1, 2 or 3.
				spinoffDice = (rand()%3 + 1);
				if (spinoffDice == 1) {
					a.actionCode = OBTAIN_IP_PATENT;
				} else {
					a.actionCode = OBTAIN_PUBLICATION;
				}
			}

			makeAction (g, a);
			printf("Action made!");

			printf ("Your current stats:\n");
			printf ("    ARC Grants: %d\n", getARCs (g, curPlayer));
			printf ("    No of Campuses: %d\n", getCampuses (g, curPlayer));
			printf ("    No of G08s: %d\n", getGO8s (g, curPlayer));
			printf ("    No of Pubs: %d\n", getPublications (g, curPlayer));
			printf ("    No of IP Patents: %d\n", getIPs (g, curPlayer));

			playerKPI = getKPIpoints (g, curPlayer);
			printf ("Player %d KPI Score: %d\n\n", curPlayer, playerKPI);
		}

		printf ("Next player's turn.\n\n");

	}

	printf ("Congratulations, player %d won.\n", curPlayer);
	printf ("Game completed. Disposing game.\n");
	
	disposeGame (g);

	return EXIT_SUCCESS;
}
int main(int argc, char *argv[]) {
    int disciplines[] = DEFAULT_DISCIPLINES;
    disciplines[2] = STUDENT_BPS;
    disciplines[7] = STUDENT_BPS;
    disciplines[11] = STUDENT_BQN;
    disciplines[16] = STUDENT_BQN;
    int dice[] = DEFAULT_DICE;
    int i = 0;
    int automation = TRUE;
    int diceRoll = 1;
    char *vertices[54];
    char *sides[72];

    //nanosecond seeding
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);

    populatePaths(vertices);
    populateSides(sides);

    printf("Automatic(1) or Human(0): ");
    scanf("%d", &automation);

    //seeding starts now
    srand((time_t)ts.tv_nsec);

    Game g = newGame(disciplines, dice);
    action a;

    while(getKPILeader(g) < 150  &&  getTurnNumber(g) < 9003) {
        if(automation == FALSE) {
            printf("Enter dice roll: ");
            scanf("%d", &diceRoll);
        } else {
            diceRoll = rand() % 10 + 2;
        }

        throwDice(g, diceRoll);
        printf("diceRoll = %d\n", diceRoll);

        printf("\n");
        printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
        printf("Turn: %d\n", getTurnNumber(g));
        printf("Player %d's turn\n", getWhoseTurn(g));

        printf("\n");
        printf("You have %d ARCs\n", getARCs(g, getWhoseTurn(g)));
        i = 0;
        while(i < 72) {
            if(getARC(g, sides[i]) == getWhoseTurn(g)) { 
                printf("You have an ARC on %s\\0\n", sides[i]);
            }
            i++;
        }
        printf("You have %d Campuses\n", getCampuses(g, getWhoseTurn(g)));
        printf("You have %d GO8s\n", getGO8s(g, getWhoseTurn(g)));
        i = 0;
        while(i < 54) {
            if(getCampus(g, vertices[i]) == getWhoseTurn(g)) { 
                printf("You have a campus on %s\\0\n", vertices[i]);
            }
            if(getCampus(g, vertices[i]) == getWhoseTurn(g) + 3) {
                printf("You have a GO8 on %s\\0\n", vertices[i]);
            }
            i++;
        }
        printf("You have %d Publications\n", getPublications(g, getWhoseTurn(g)));
        printf("You have %d IP Patents\n", getIPs(g, getWhoseTurn(g)));
        printf("\n");
        
        printf("Students:\n");
        printf("You have %d THD Students\n", getStudents(g, getWhoseTurn(g), STUDENT_THD));
        printf("You have %d BPS Students\n", getStudents(g, getWhoseTurn(g), STUDENT_BPS));
        printf("You have %d BQN Students\n", getStudents(g, getWhoseTurn(g), STUDENT_BQN));
        printf("You have %d MJ Students\n", getStudents(g, getWhoseTurn(g), STUDENT_MJ));
        printf("You have %d MTV Students\n", getStudents(g, getWhoseTurn(g), STUDENT_MTV));
        printf("You have %d MMONEY Students\n", getStudents(g, getWhoseTurn(g), STUDENT_MMONEY));
        printf("\n");

        if(automation == FALSE) {
            a = getHumanAction();
        } else {
            a = getAIAction(g);
        }

        while(a.actionCode != PASS) {
            if(isLegalAction(g, a)) {
                if(a.actionCode == START_SPINOFF) {
                    if(rand() % 3 > 1) {
                        a.actionCode = OBTAIN_IP_PATENT;
                    } else {
                        a.actionCode = OBTAIN_PUBLICATION;
                    }
                }
                makeAction(g, a);
            } else {
                printf("Illegal Action");
            }
            printf("\n");
            printf("Player %d's turn\n", getWhoseTurn(g));

            printf("You have %d ARCs\n", getARCs(g, getWhoseTurn(g)));
            printf("You have %d Campuses\n", getCampuses(g, getWhoseTurn(g)));
            printf("You have %d GO8s\n", getGO8s(g, getWhoseTurn(g)));
            printf("You have %d Publications\n", getPublications(g, getWhoseTurn(g)));
            printf("You have %d IP Patents\n", getIPs(g, getWhoseTurn(g)));
            printf("\n");
            printf("Students:\n");
            printf("You have %d THD Students\n", getStudents(g, getWhoseTurn(g), STUDENT_THD));
            printf("You have %d BPS Students\n", getStudents(g, getWhoseTurn(g), STUDENT_BPS));
            printf("You have %d BQN Students\n", getStudents(g, getWhoseTurn(g), STUDENT_BQN));
            printf("You have %d MJ Students\n", getStudents(g, getWhoseTurn(g), STUDENT_MJ));
            printf("You have %d MTV Students\n", getStudents(g, getWhoseTurn(g), STUDENT_MTV));
            printf("You have %d MMONEY Students\n", getStudents(g, getWhoseTurn(g), STUDENT_MMONEY));
            printf("\n");

            if(automation == FALSE) {
                a = getHumanAction();
            } else {
                a = getAIAction(g);
            }

        }
        printf("Player 1 KPI points : %d\n", getKPIpoints(g, UNI_A));
        printf("Player 2 KPI points : %d\n", getKPIpoints(g, UNI_B));
        printf("Player 3 KPI points : %d\n", getKPIpoints(g, UNI_C));
    }
    printf("Winner: Player %d\n", getWinner(g));    
    disposeGame(g);
    return EXIT_SUCCESS;
}