//If the player has more than 3 or the non-core students
static int canTradeJunkResources(Game g, int player) {
int resourceFrom = 0;
if (getStudents(g, player, STUDENT_MTV) >=
getExchangeRate(g, player, STUDENT_MTV, 1)) {
resourceFrom = STUDENT_MTV;
} else if (getStudents(g, player, STUDENT_MMONEY) >=
getExchangeRate(g, player, STUDENT_MMONEY, 1)) {
resourceFrom = STUDENT_MMONEY;
}
return resourceFrom;
}
// retrains the current player's students
static void retrainStudents(Game g, action a) {
int player = getWhoseTurn(g);
int ratio = getExchangeRate(g, player,
a.disciplineFrom, a.disciplineTo);
g->players[player - 1]->students[a.disciplineFrom] += -1 * ratio;
g->players[player - 1]->students[a.disciplineTo]++;
}
//Returns true/false based on whether it suits retraining conditions
//Ensures valid discipline numbers used
//Ensures enough students for retraining
//THDs cannot be retrained, (code 0)
int retrainConditions (Game g, action a, int player) {
int answer = FALSE;
int rate = 0;
int numStudents = 0;
rate = getExchangeRate (g, player, a.disciplineFrom, a.disciplineTo);
numStudents = getStudents (g, player, a.disciplineFrom);
if (numStudents < rate) {
return FALSE;
}
if ((answer == TRUE) && (a.disciplineTo >= 0)
&& (a.disciplineFrom > 0)
&& (a.disciplineTo < MAX_STU_TYPES)
&& (a.disciplineFrom < MAX_STU_TYPES)
&& (numStudents >= rate)) {
answer = TRUE;
} else {
answer = FALSE;
}
return answer;
printf ("answer is %d\n", answer);
}
// test getExchangeRate
void test6(void) {
printf("\n\n\n\n");
action a;
int disciplines[] = {2,5,3,5,3,1,4,4,1,4,2,3,2,0,3,5,4,2,1};
int dice[] = {9,10,8,12,6,5,3,11,3,11,4,6,4,7,9,2,8,10,5};
Game g = newGame(disciplines, dice);
throwDice(g, 5);
a.actionCode = BUILD_CAMPUS;
strncpy(a.destination, "R", PATH_LIMIT - 1);
a.destination[PATH_LIMIT - 1] = 0;
a.disciplineFrom = 1, a.disciplineTo = -1217678112;
makeAction(g, a);
assert(getExchangeRate (g, 1, 4, 1) == 2);
}
//DONE
//given resources
//given disciplineFrom & disciplineTo
//calulate number to convert
//cant be THD
static int isLegalRetrain(Game g, action a) {
int isLegal = TRUE;
int player = getWhoseTurn(g);
//if trying to retrain a thd student
if(a.disciplineFrom <= STUDENT_THD || a.disciplineFrom >= NUM_STUDENT_TYPES ||
a.disciplineTo < STUDENT_THD || a.disciplineTo >= NUM_STUDENT_TYPES) {
isLegal = FALSE;
}
//if not enough resources
if(isLegal == TRUE) {
if(g->students[player][a.disciplineFrom] <
getExchangeRate(g, player, a.disciplineFrom, a.disciplineTo)) {
isLegal = FALSE;
}
}
return isLegal;
}
// make the specified action for the current player and update the
// game state accordingly.
// The function may assume that the action requested is legal.
// START_SPINOFF is not a legal action here
void makeAction (Game g, action a) {
// determine the current player
int curPlayer;
curPlayer = getWhoseTurn (g);
int rate = 0;
// peforms a particular action given the action code
if (a.actionCode == PASS) {
throwDice (g, rollDice());
} else if (a.actionCode == BUILD_CAMPUS) {
// deduct the resources from the player
g->uni[curPlayer].numStudents[STUDENT_BPS] -= 1;
g->uni[curPlayer].numStudents[STUDENT_BQN] -= 1;
g->uni[curPlayer].numStudents[STUDENT_MJ] -= 1;
g->uni[curPlayer].numStudents[STUDENT_MTV] -= 1;
makeCampus (g, a.destination, curPlayer);
g->uni[curPlayer].numCmps++;
} else if (a.actionCode == BUILD_GO8) {
// deduct the resources from the player
g->uni[curPlayer].numStudents[STUDENT_MJ] -= 2;
g->uni[curPlayer].numStudents[STUDENT_MMONEY] -= 3;
makeG08 (g, a.destination, curPlayer);
g->uni[curPlayer].numCmps--;
g->uni[curPlayer].numG08s++;
} else if (a.actionCode == OBTAIN_ARC) {
// deduct the resources from the player
g->uni[curPlayer].numStudents[STUDENT_BQN] -= 1;
g->uni[curPlayer].numStudents[STUDENT_BPS] -= 1;
makeArc (g, a.destination, curPlayer);
g->uni[curPlayer].numArcs++;
//change mostArcs
if (g->mostArcs == NO_ONE) {
g->mostArcs = curPlayer;
}
else if(g->uni[curPlayer].numArcs > g->uni[g->mostArcs].numArcs){
g->mostArcs = curPlayer;
}
} else if (a.actionCode == OBTAIN_PUBLICATION) {
g->uni[curPlayer].numPubs++;
//change mostPubs
if (g->mostPubs == NO_ONE) {
g->mostPubs = curPlayer;
}
else if(g->uni[curPlayer].numPubs > g->uni[g->mostPubs].numPubs){
g->mostPubs = curPlayer;
}
} else if (a.actionCode == OBTAIN_IP_PATENT) {
g->uni[curPlayer].numIPs++;
} else if (a.actionCode == RETRAIN_STUDENTS) {
rate = getExchangeRate (g, curPlayer, a.disciplineFrom, a.disciplineTo);
g->uni[curPlayer].numStudents[a.disciplineFrom] -= rate;
g->uni[curPlayer].numStudents[a.disciplineTo]++;
}
}
//DONE [DO NOTHING MIGHT NOT WORK]
void makeAction (Game g, action a) {
//function protection
assert(g != NULL);
assert(isLegalMoves(g, a) == TRUE);
coordinates xycoord = getCoords(a.destination);
coordinates xysides = convertToSides(xycoord);
int player = getWhoseTurn(g);
if(a.actionCode == PASS) {
//do nothing
} else if(a.actionCode == BUILD_CAMPUS) {
//given coordinate
//put campus + player on to that vertex
//remove resources from player
g->vertices[xycoord.x][xycoord.y] = player;
g->campuses[player]++;
g->students[player][STUDENT_BPS]--;
g->students[player][STUDENT_BQN]--;
g->students[player][STUDENT_MJ]--;
g->students[player][STUDENT_MTV]--;
} else if(a.actionCode == BUILD_GO8) {
//given coordinate
//put GO8 + player on to that vertex
//remove resources from player
g->vertices[xycoord.x][xycoord.y] = player + 3;
g->GO8s[player]++;
g->campuses[player]--;
g->students[player][STUDENT_MJ] -= 2;
g->students[player][STUDENT_MMONEY] -= 3;
} else if(a.actionCode == OBTAIN_ARC) {
//given coordinate
//put arc + player on that side
//remove resources from player
g->sides[xysides.x][xysides.y] = player;
g->ARCs[player]++;
g->students[player][STUDENT_BPS]--;
g->students[player][STUDENT_BQN]--;
} else if(a.actionCode == OBTAIN_PUBLICATION) {
g->students[player][STUDENT_MJ]--;
g->students[player][STUDENT_MTV]--;
g->students[player][STUDENT_MMONEY]--;
g->pubs[player]++;
} else if(a.actionCode == OBTAIN_IP_PATENT) {
g->students[player][STUDENT_MJ]--;
g->students[player][STUDENT_MTV]--;
g->students[player][STUDENT_MMONEY]--;
g->IPs[player]++;
} else if(a.actionCode == RETRAIN_STUDENTS) {
//given discipline from and dicipline to
//get retrain value from function
//if value = 2 --> -2 --> + 1
//if value = 3 --> -3 --> + 1
int retrainvalue = getExchangeRate(g, getWhoseTurn(g),
a.disciplineFrom, a.disciplineTo);
if(retrainvalue == 2) {
g->students[player][a.disciplineFrom] -= 2;
g->students[player][a.disciplineTo]++;
} else if(retrainvalue == 3) {
g->students[player][a.disciplineFrom] -= 3;
g->students[player][a.disciplineTo]++;
}
}
setMostPublications(g);
setMostARCs(g);
calculateKPI(g);
}
// returns TRUE if it is legal for the current
// player to make the specified action, FALSE otherwise->
//
// "legal" means everything is legal:
// * that the action code is a valid action code which is legal to
// be made at this time
// * that any path is well formed and legal ie consisting only of
// the legal direction characters and of a legal length,
// and which does not leave the island into the sea at any stage->
// * that disciplines mentioned in any retraining actions are valid
// discipline numbers, and that the university has sufficient
// students of the correct type to perform the retraining
//
// eg when placing a campus consider such things as:
// * is the path a well formed legal path
// * does it lead to a vacent vertex?
// * under the rules of the game are they allowed to place a
// campus at that vertex? (eg is it adjacent to one of their ARCs?)
// * does the player have the 4 specific students required to pay for
// that campus?
// It is not legal to make any action during Terra Nullis ie
// before the game has started->
// It is not legal for a player to make the moves OBTAIN_PUBLICATION
// or OBTAIN_IP_PATENT (they can make the move START_SPINOFF)
// you can assume that any pths passed in are NULL terminated strings->
int isLegalAction(Game g, action a) {
int isLegal = TRUE;
printf("Checking if an action is legal\n");
int player = getWhoseTurn(g);
int flag = 1;
// Protect from stupid shit
if ((a.actionCode < PASS) || (a.actionCode > RETRAIN_STUDENTS)) {
printf("Invalid Action Code\n");
flag = 0;
} else if (a.actionCode == RETRAIN_STUDENTS) {
printf("You've Called a retrain, checking if discipline");
printf("within the bounds\n");
// If it's a retrain action make sure the to
// and from are in a nice range.
if ((a.disciplineTo < STUDENT_THD)
|| (a.disciplineTo > STUDENT_MMONEY)) {
printf("Invalid Discpline Code\n");
flag = 0;
}
if ((a.disciplineFrom < STUDENT_THD)
|| (a.disciplineFrom > STUDENT_MMONEY)) {
printf("Invalid Discpline Code\n");
flag = 0;
}
}
printf("The Flag when testing is %d\n", flag);
if (flag == 1) {
// Check all the basic stuff
if (getTurnNumber(g) == TERRA_NULLIS) {
isLegal = FALSE;
} else if ((a.actionCode < 0) || (a.actionCode > MAX_ACTION)) {
isLegal = FALSE;
} else if ((getWhoseTurn(g) < 0) || (getWhoseTurn(g) > NUM_UNIS)) {
isLegal = FALSE;
} else if (a.actionCode == OBTAIN_IP_PATENT ||
a.actionCode == OBTAIN_PUBLICATION) {
isLegal = FALSE;
}
if (a.actionCode <= 3 && a.actionCode > 0 && isLegal) {
if (validString(a.destination) == FALSE) {
isLegal = FALSE;
} else if (validPoint(pathToPoint(a.destination).x,
pathToPoint(a.destination).y) == FALSE) {
isLegal = FALSE;
}
}
// edge actionEdge = pathToEdgeF (a.destination);
// Check that someone can get an arc
if (a.actionCode == OBTAIN_ARC && isLegal) {
printf("Checking if the arc is legal. Arc:%s\n", a.destination);
if (validNewEdge(g, pathToEdgeF(a.destination), player) == FALSE) {
printf("Geographically Valid Edge\n");
isLegal = FALSE;
} else if (getStudents(g, player, STUDENT_BQN) < 1) {
isLegal = FALSE;
} else if (getStudents(g, player, STUDENT_BPS) < 1) {
isLegal = FALSE;
}
}
// Check that someone can get a Campus
if (a.actionCode == BUILD_CAMPUS && isLegal) {
if (validNewContents(g, a.destination, player) == FALSE) {
isLegal = FALSE;
} else if (getStudents(g, player, STUDENT_BQN) < 1) {
isLegal = FALSE;
} else if (getStudents(g, player, STUDENT_BPS) < 1) {
isLegal = FALSE;
} else if (getStudents(g, player, STUDENT_MJ) < 1) {
isLegal = FALSE;
} else if (getStudents(g, player, STUDENT_MTV) < 1) {
isLegal = FALSE;
}
}
if (a.actionCode == BUILD_GO8 && isLegal) {
point actionPoint = pathToPoint(a.destination);
if (g->gameBoard->points[actionPoint.x][actionPoint.y]->contents !=
player) {
isLegal = FALSE;
} else if (getStudents(g, player, STUDENT_MJ) < 2) {
isLegal = FALSE;
} else if (getStudents(g, player, STUDENT_MMONEY) < 3) {
isLegal = FALSE;
} else if (getTotalGO8s(g) == 8) {
isLegal = FALSE;
}
}
if (a.actionCode == START_SPINOFF && isLegal) {
if (getStudents(g, player, STUDENT_MJ) < 1) {
isLegal = FALSE;
} else if (getStudents(g, player, STUDENT_MTV) < 1) {
isLegal = FALSE;
} else if (getStudents(g, player, STUDENT_MMONEY) < 1) {
isLegal = FALSE;
}
}
if (a.actionCode == RETRAIN_STUDENTS && isLegal) {
int exchange = getExchangeRate(g, player, a.disciplineFrom,
a.disciplineTo);
if (getStudents(g, player, a.disciplineFrom) < exchange) {
isLegal = FALSE;
} else if (a.disciplineFrom == STUDENT_THD) {
isLegal = FALSE;
}
}
} else if (flag == 0) {
isLegal = FALSE;
}
return isLegal;
}
//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 enoughToBuildCampus(Game g, int playerId, fromToArc arcPath[2]) {
int result = FALSE;
int pathResources = 2;
if (arcPath[0].alreadyOwned) {
pathResources--;
}
if (arcPath[1].alreadyOwned) {
pathResources--;
}
int conRateBPS = getExchangeRate(g, playerId, STUDENT_BPS, STUDENT_BPS);
int conRateBQN = getExchangeRate(g, playerId, STUDENT_BPS, STUDENT_BQN);
int conRateMJ = getExchangeRate(g, playerId, STUDENT_BPS, STUDENT_MJ);
int conRateMTV = getExchangeRate(g, playerId, STUDENT_BPS, STUDENT_MTV);
int conRateMMONEY = getExchangeRate(g, playerId, STUDENT_BPS, STUDENT_MMONEY);
int numBPS = getStudents(g, playerId, STUDENT_BPS);
int numBQN = getStudents(g, playerId, STUDENT_BQN);
int numMJ = getStudents(g, playerId, STUDENT_MJ);
int numMTV = getStudents(g, playerId, STUDENT_MTV);
int numMMONEY = getStudents(g, playerId, STUDENT_MMONEY);
if (numMTV < 1) {
if (numBPS - conRateBPS >= pathResources + 1) {
convertStudents(g, STUDENT_BPS, STUDENT_MTV, 1);
numBPS = numBPS - conRateBPS;
numMTV++;
} else if (numBQN - conRateBQN >= pathResources + 1) {
convertStudents(g, STUDENT_BQN, STUDENT_MTV, 1);
numBQN = numBQN - conRateBQN;
numMTV++;
} else if (numMJ - conRateMJ >= 1) {
convertStudents(g, STUDENT_MJ, STUDENT_MTV, 1);
numMJ = numMJ - conRateMJ;
numMTV++;
}
}
if (numMJ < 1) {
if (numBPS - conRateBPS >= pathResources + 1) {
convertStudents(g, STUDENT_BPS, STUDENT_MJ, 1);
numBPS = numBPS - conRateBPS;
numMJ++;
}
else if (numBQN - conRateBQN >= pathResources + 1) {
convertStudents(g, STUDENT_BQN, STUDENT_MJ, 1);
numBQN = numBQN - conRateBQN;
numMJ++;
}
else if (numMTV - conRateMTV >= 1) {
convertStudents(g, STUDENT_MTV, STUDENT_MJ, 1);
numMTV = numMTV - conRateMTV;
numMJ++;
}
}
if (numBQN <= pathResources) {
int neededBQN = pathResources + 1 - numBQN;
if (numBPS - (conRateBPS * neededBQN) >= pathResources + 1) {
convertStudents(g, STUDENT_BPS, STUDENT_BQN, neededBQN);
numBPS = numBPS - (conRateBPS * (pathResources + 1));
numBQN += neededBQN;
}
else if (numMJ - (conRateBQN * neededBQN) >= 1) {
convertStudents(g, STUDENT_MJ, STUDENT_BQN, neededBQN);
numMJ = numMJ - (conRateBQN * (pathResources + 1));
numBQN += neededBQN;
}
else if (numMTV - (conRateBQN * neededBQN) >= 1) {
convertStudents(g, STUDENT_MTV, STUDENT_BQN, neededBQN);
numMTV = numMTV - (conRateBQN * (pathResources + 1));
numBQN += neededBQN;
}
}
if (numBPS <= pathResources) {
int neededBPS = pathResources + 1 - numBPS;
if (numBQN - (conRateBQN * neededBPS) >= pathResources + 1) {
convertStudents(g, STUDENT_BQN, STUDENT_BPS, neededBPS);
numBQN = numBQN - (conRateBQN * (pathResources + 1));
numBPS += neededBPS;
} else if (numMJ - (conRateMJ * neededBPS) >= 1) {
convertStudents(g, STUDENT_MJ, STUDENT_BPS, neededBPS);
numMJ = numMJ - (conRateMJ * (pathResources + 1));
numBPS += neededBPS;
} else if (numMTV - (conRateMTV * neededBPS) >= 1) {
convertStudents(g, STUDENT_MTV, STUDENT_BPS, neededBPS);
numMTV = numMTV - (conRateMTV * (pathResources + 1));
numBPS += neededBPS;
}
}
while (numMJ <= numBQN - 1 && numMJ <= numBPS - 1 && numMTV > 1) {
convertStudents(g, STUDENT_MTV, STUDENT_MJ, 1);
numMTV -= conRateMTV;
numMJ++;
}
while (numBPS <= numBQN - 1 && numBPS <= numMJ - 1 && numMTV > 1) {
convertStudents(g, STUDENT_MTV, STUDENT_BPS, 1);
numMTV -= conRateMTV;
numBPS++;
}
while(numBQN <= numBPS - 1 && numBQN <= numMJ - 1 && numMTV > 1) {
convertStudents(g, STUDENT_MTV, STUDENT_BQN, 1);
numMTV -= conRateMTV;
numBQN++;
}
while (numMJ <= numBQN - 1 && numMJ <= numBPS - 1 && numMMONEY > 1) {
convertStudents(g, STUDENT_MMONEY, STUDENT_MJ, 1);
numMMONEY -= conRateMMONEY;
numMJ++;
}
while (numBPS <= numBQN - 1 && numBPS <= numMJ - 1 && numMMONEY > 1) {
convertStudents(g, STUDENT_MMONEY, STUDENT_BPS, 1);
numMMONEY -= conRateMMONEY;
numBPS++;
}
while(numBQN <= numBPS - 1 && numBQN <= numMJ - 1 && numMMONEY > 1) {
convertStudents(g, STUDENT_MMONEY, STUDENT_BQN, 1);
numMMONEY -= conRateMMONEY;
numBQN++;
}
if (getStudents(g, playerId, STUDENT_BPS) >= pathResources + 1 &&
getStudents(g, playerId, STUDENT_BQN) >= pathResources + 1 &&
getStudents(g, playerId, STUDENT_MJ) >= 1 &&
getStudents(g, playerId, STUDENT_MTV) >= 1) {
result = TRUE;
}
return result;
}
int enoughToStartSpinoff(Game g, int playerId) {
int result = FALSE;
int changesMade = TRUE;
int conRateBPS = getExchangeRate(g, playerId, STUDENT_BPS, STUDENT_BPS);
int conRateBQN = getExchangeRate(g, playerId, STUDENT_BQN, STUDENT_BQN);
int numMJ = 0;
int numMTV = 0;
int numMMONEY = 0;
while (changesMade && (numMTV < 1 || numMMONEY < 1 || numMJ < 1)) {
int effectiveBPS = getStudents(g, playerId, STUDENT_BPS) / conRateBPS;
int effectiveBQN = getStudents(g, playerId, STUDENT_BQN) / conRateBQN;
numMJ = getStudents(g, playerId, STUDENT_MJ);
numMTV = getStudents(g, playerId, STUDENT_MTV);
numMMONEY = getStudents(g, playerId, STUDENT_MMONEY);
if (numMJ < 1 || numMTV < 1 || numMMONEY < 1) {
int toSide;
if (numMJ < 1) {
toSide = STUDENT_MJ;
} else if (numMTV < 1) {
toSide = STUDENT_MTV;
} else {
toSide = STUDENT_MMONEY;
}
changesMade = FALSE;
if (effectiveBPS > 0) {
changesMade = TRUE;
convertStudents(g, STUDENT_BPS, toSide, 1);
} else if (effectiveBQN > 0) {
changesMade = TRUE;
convertStudents(g, STUDENT_BQN, toSide, 1);
}
}
}
int conRateMTV = getExchangeRate(g, playerId, STUDENT_MTV, STUDENT_MTV);
int conRateMJ = getExchangeRate(g, playerId, STUDENT_MJ, STUDENT_MJ);
int conRateMMONEY = getExchangeRate(g, playerId, STUDENT_MMONEY, STUDENT_MMONEY);
numMTV = getStudents(g, playerId, STUDENT_MTV);
numMJ = getStudents(g, playerId, STUDENT_MJ);
numMMONEY = getStudents(g, playerId, STUDENT_MMONEY);
while (numMTV > numMJ && numMTV > numMMONEY && numMTV >= conRateMTV) {
numMTV -= conRateMTV;
if (numMJ < numMMONEY) {
convertStudents(g, STUDENT_MTV, STUDENT_MJ, 1);
numMJ++;
} else {
convertStudents(g, STUDENT_MTV, STUDENT_MMONEY, 1);
numMMONEY++;
}
}
while (numMJ > numMTV && numMJ > numMMONEY && numMJ >= conRateMJ) {
numMJ -= conRateMJ;
if (numMTV < numMMONEY) {
convertStudents(g, STUDENT_MJ, STUDENT_MTV, 1);
numMTV++;
} else {
convertStudents(g, STUDENT_MJ, STUDENT_MMONEY, 1);
numMMONEY++;
}
}
while (numMMONEY > numMJ && numMMONEY > numMTV && numMMONEY > conRateMMONEY) {
numMMONEY -= conRateMMONEY;
if (numMJ < numMTV) {
convertStudents(g, STUDENT_MMONEY, STUDENT_MJ, 1);
numMJ++;
} else {
convertStudents(g, STUDENT_MMONEY, STUDENT_MTV, 1);
numMTV++;
}
}
if (numMTV > 0 && numMJ > 0 && numMMONEY > 0) {
result = TRUE;
}
return result;
}
int enoughToBuildGO8(Game g, int playerId) {
int result = FALSE;
int changesMade = TRUE;
int conRateBPS = getExchangeRate(g, playerId, STUDENT_BPS, STUDENT_BPS);
int conRateBQN = getExchangeRate(g, playerId, STUDENT_BQN, STUDENT_BQN);
int conRateMTV = getExchangeRate(g, playerId, STUDENT_MTV, STUDENT_MTV);
int numRequiredMJ = 1;
int numRequiredMMONEY = 1;
while (changesMade && (numRequiredMJ > 0 || numRequiredMMONEY > 0)) {
int effectiveBPS = getStudents(g, playerId, STUDENT_BPS) / conRateBPS;
int effectiveBQN = getStudents(g, playerId, STUDENT_BQN) / conRateBQN;
int numMJ = getStudents(g, playerId, STUDENT_MJ);
int effectiveMTV = getStudents(g, playerId, STUDENT_MTV) / conRateMTV;
int numMMONEY = getStudents(g, playerId, STUDENT_MMONEY);
numRequiredMJ = 2 - numMJ;
numRequiredMMONEY = 3 - numMMONEY;
if (numRequiredMJ > 0 || numRequiredMMONEY > 0) {
int toSide;
if (numRequiredMJ < numRequiredMMONEY) {
toSide = STUDENT_MMONEY;
} else {
toSide = STUDENT_MJ;
}
changesMade = FALSE;
if (effectiveBPS > 0) {
changesMade = TRUE;
convertStudents(g, STUDENT_BPS, toSide, 1);
} else if (effectiveBQN > 0) {
changesMade = TRUE;
convertStudents(g, STUDENT_BQN, toSide, 1);
} else if (effectiveMTV > 0) {
changesMade = TRUE;
convertStudents(g, STUDENT_MTV, toSide, 1);
}
}
}
int numMMONEY = getStudents(g, playerId, STUDENT_MMONEY);
int numMJ = getStudents(g, playerId, STUDENT_MJ);
int conRateMMONEY = getExchangeRate(g, playerId, STUDENT_MMONEY, STUDENT_MMONEY);
int conRateMJ = getExchangeRate(g, playerId, STUDENT_MJ, STUDENT_MJ);
while (numMMONEY > numMJ && numMMONEY >= 3 + conRateMMONEY) {
numMMONEY -= conRateMTV;
convertStudents(g, STUDENT_MMONEY, STUDENT_MJ, 1);
numMJ++;
}
while (numMJ > numMMONEY && numMJ >= 2 + conRateMTV && numMMONEY < 3) {
numMJ -= conRateMJ;
convertStudents(g, STUDENT_MJ, STUDENT_MMONEY, 1);
numMMONEY++;
}
if (numRequiredMMONEY < 1 && numRequiredMJ < 1) {
// printf("Required MMONEY: %d\n", numRequiredMMONEY);
// printf("Required MJ: %d\n", numRequiredMJ);
// printf("MMONEY: %d\n", getStudents(g, playerId, STUDENT_MMONEY));
// printf("MJ: %d\n", getStudents(g, playerId, STUDENT_MJ));
result = TRUE;
}
if (getGO8s(g, UNI_A) + getGO8s(g, UNI_B) + getGO8s(g, UNI_C) >= 8) {
result = FALSE;
}
return result;
}
static int tradeForSpinOff(Game g, int player,
int * disciplineFrom, int * disciplineTo) {
int shouldWeTrade = TRUE;
//if we have enough of the students to trade
//and still build a spinoff
int canTradeBPS = FALSE;
int canTradeBQN = FALSE;
int canTradeMJ = FALSE;
int canTradeMTV = FALSE;
int canTradeMMONEY = FALSE;
*disciplineFrom = 0;
*disciplineTo = 0;
//the total amount of resources for a spinoff
int resourcesNeeded = 3;
if (getStudents(g, player, STUDENT_BPS) >= getExchangeRate(g, player, STUDENT_BPS, 1)) {
canTradeBPS = TRUE;
if (getStudents(g, player, STUDENT_BPS) >= 2*getExchangeRate(g, player, STUDENT_BPS, 1)) {
canTradeBPS++;
}
}
if (getStudents(g, player, STUDENT_BQN) >= getExchangeRate(g, player, STUDENT_BQN, 1)) {
canTradeBQN = TRUE;
if (getStudents(g, player, STUDENT_BQN) >= 2*getExchangeRate(g, player, STUDENT_BQN, 1)) {
canTradeBQN++;
}
}
//these are >= 4 since these resources are used for
//building spinoffs
if (getStudents(g, player, STUDENT_MJ) >= 1 + getExchangeRate(g, player, STUDENT_MJ, 1)) {
canTradeMJ = TRUE;
if (getStudents(g, player, STUDENT_MJ) >= 1 + 2*getExchangeRate(g, player, STUDENT_MJ, 1)) {
canTradeMJ++;
}
}
if (getStudents(g, player, STUDENT_MTV) >= 1 + getExchangeRate(g, player, STUDENT_MTV, 1)) {
canTradeMTV = TRUE;
}
if (getStudents(g, player, STUDENT_MMONEY) >= 1 + getExchangeRate(g, player, STUDENT_MMONEY, 1)) {
canTradeMMONEY = TRUE;
}
//so if we have these resources,
//we can decrement the amount we need to trade for
if (getStudents(g, player, STUDENT_MMONEY)) {
resourcesNeeded--;
}
if (getStudents(g, player, STUDENT_MTV)) {
resourcesNeeded--;
}
if (getStudents(g, player, STUDENT_MJ)) {
resourcesNeeded--;
}
//if we can trade enough of the extra resources
//to get the resources needed for a spinoff
if (resourcesNeeded < canTradeBPS + canTradeBQN +
canTradeMJ + canTradeMTV + canTradeMMONEY) {
//if we dont have these resources that we need
if (getStudents(g, player, STUDENT_MJ) == FALSE) {
*disciplineTo = STUDENT_MJ;
} else if (getStudents(g, player, STUDENT_MTV) == FALSE) {
*disciplineTo = STUDENT_MTV;
} else if (getStudents(g, player, STUDENT_MMONEY) == FALSE) {
*disciplineTo = STUDENT_MMONEY;
}
//these are the resources that we can trade
if (canTradeMMONEY) {
*disciplineFrom = STUDENT_MMONEY;
} else if (canTradeMTV) {
*disciplineFrom = STUDENT_MTV;
} else if (canTradeMJ) {
*disciplineFrom = STUDENT_MJ;
} else if (canTradeBQN) {
*disciplineFrom = STUDENT_BQN;
} else if (canTradeBPS) {
*disciplineFrom = STUDENT_BPS;
}
} else {
shouldWeTrade = FALSE;
}
return shouldWeTrade;
}
static int tradeForCampus(Game g, int player,
int * disciplineFrom, int * disciplineTo) {
int shouldWeTrade = TRUE;
int canTradeBPS = FALSE;
int canTradeBQN = FALSE;
int canTradeMJ = FALSE;
int canTradeMTV = FALSE;
int canTradeMMONEY = FALSE;
*disciplineFrom = 0;
*disciplineTo = 0;
int resourcesNeeded = 4;
if (getStudents(g, player, STUDENT_BPS) >= 1 + getExchangeRate(g, player, STUDENT_BPS, 1)) {
canTradeBPS = TRUE;
if (getStudents(g,player,STUDENT_BPS) >= 1 + 2*getExchangeRate(g, player, STUDENT_BPS, 1)) {
canTradeBPS++;
}
}
if (getStudents(g, player, STUDENT_BQN) >= 1 + getExchangeRate(g, player, STUDENT_BQN, 1)) {
canTradeBQN = TRUE;
if (getStudents(g,player,STUDENT_BQN) >= 1 + 2*getExchangeRate(g, player, STUDENT_BQN, 1)) {
canTradeBQN++;
}
}
if (getStudents(g, player, STUDENT_MJ) >= 1 + getExchangeRate(g, player, STUDENT_MJ, 1)) {
canTradeMJ = TRUE;
if (getStudents(g,player,STUDENT_MJ) >= 1 + 2*getExchangeRate(g, player, STUDENT_MJ, 1)) {
canTradeMJ++;
}
}
if (getStudents(g, player, STUDENT_MTV) >= 1 + getExchangeRate(g, player, STUDENT_MTV, 1)) {
canTradeMTV = TRUE;
}
if (getStudents(g, player, STUDENT_MMONEY) >= getExchangeRate(g, player, STUDENT_MMONEY, 1)) {
canTradeMMONEY = TRUE;
}
if (getStudents(g, player, STUDENT_BQN)) {
resourcesNeeded--;
}
if (getStudents(g, player, STUDENT_BPS)) {
resourcesNeeded--;
}
if (getStudents(g, player, STUDENT_MTV)) {
resourcesNeeded--;
}
if (getStudents(g, player, STUDENT_MJ)) {
resourcesNeeded--;
}
if (resourcesNeeded < canTradeBPS + canTradeBQN +
canTradeMJ + canTradeMTV + canTradeMMONEY) {
if (getStudents(g, player, STUDENT_MJ) == FALSE) {
*disciplineTo = STUDENT_MJ;
} else if (getStudents(g, player, STUDENT_BQN) == FALSE) {
*disciplineTo = STUDENT_BQN;
} else if (getStudents(g, player, STUDENT_BPS) == FALSE) {
*disciplineTo = STUDENT_BPS;
} else if (getStudents(g, player, STUDENT_MTV) == FALSE) {
*disciplineTo = STUDENT_MTV;
}
if (canTradeMMONEY) {
*disciplineFrom = STUDENT_MMONEY;
} else if (canTradeMTV) {
*disciplineFrom = STUDENT_MTV;
} else if (canTradeMJ) {
*disciplineFrom = STUDENT_MJ;
} else if (canTradeBQN) {
*disciplineFrom = STUDENT_BQN;
} else if (canTradeBPS) {
*disciplineFrom = STUDENT_BPS;
}
} else {
shouldWeTrade = FALSE;
}
return shouldWeTrade;
}
//Tests each action to see if they are legal, int isLegalAction (Game g, action a);
void testLegalAction(Game g, int player){
printf("Testing isLegalAction!\n");
action passAction;
action CampusAction;
action GO8Action;
action ARCAction;
action spinoffAction;
action publicationAction;
action patentAction;
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;
assert(isLegalAction(g, passAction) == TRUE);
assert(isLegalAction(g, CampusAction) == TRUE &&
getStudents(g, player, STUDENT_BPS) >= 1 &&
getStudents(g, player, STUDENT_BQN) >= 1 &&
getStudents(g, player, STUDENT_MJ) >= 1 &&
getStudents(g, player, STUDENT_MTV) >= 1);
assert((isLegalAction(g, CampusAction) == FALSE) &&
((getStudents(g, player, STUDENT_BPS) < 1) ||
(getStudents(g, player, STUDENT_BQN) < 1) ||
(getStudents(g, player, STUDENT_MJ) < 1) ||
(getStudents(g, player, STUDENT_MTV) < 1)));
assert (isLegalAction(g, GO8Action) == TRUE &&
getStudents(g, player, STUDENT_MJ) >= 2 &&
getStudents(g, player, STUDENT_MMONEY) >= 3);
assert ((isLegalAction(g, GO8Action) == FALSE) &&
((getStudents(g, player, STUDENT_MJ) < 2) ||
(getStudents(g, player, STUDENT_MMONEY) < 3)));
assert(isLegalAction(g, ARCAction) == TRUE &&
getStudents(g, player, STUDENT_BQN) >= 1 &&
getStudents(g, player, STUDENT_BPS) >= 1);
assert((isLegalAction(g, ARCAction) == FALSE) &&
((getStudents(g, player, STUDENT_BQN) < 1) ||
(getStudents(g, player, STUDENT_BPS) < 1)));
assert(isLegalAction(g, spinoffAction) == TRUE &&
getStudents(g, player, STUDENT_MJ) >= 1 &&
getStudents(g, player, STUDENT_MTV) >= 1 &&
getStudents(g, player, STUDENT_MMONEY) >= 1);
assert((isLegalAction(g, spinoffAction) == FALSE) &&
((getStudents(g, player, STUDENT_MJ) < 1) ||
(getStudents(g, player, STUDENT_MTV) < 1) ||
(getStudents(g, player, STUDENT_MMONEY) < 1)));
assert(isLegalAction(g, publicationAction) == FALSE);
assert(isLegalAction(g, patentAction) == FALSE);
//Test Retrain_Students
int testStudentFrom = STUDENT_BPS;
int testStudentTo = STUDENT_BPS;
action retrainAction;
retrainAction.actionCode = RETRAIN_STUDENTS;
retrainAction.disciplineFrom = testStudentFrom;
retrainAction.disciplineTo = testStudentTo;
while (testStudentFrom <= STUDENT_MMONEY) {
while (testStudentTo <= STUDENT_MMONEY) {
if (testStudentFrom != testStudentTo) {
assert(isLegalAction(g, retrainAction) == TRUE &&
getStudents(g, player, testStudentFrom) - \
getExchangeRate (g, player, testStudentFrom, testStudentTo) >= 0);
}
testStudentTo ++;
retrainAction.disciplineTo = testStudentTo;
}
testStudentFrom ++;
retrainAction.disciplineFrom = testStudentFrom;
retrainAction.disciplineTo = STUDENT_BPS;
}
printf ("All isLegalAction() tests passed!\n");
}
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");
}
action decideAction (Game g) {
int me = getWhoseTurn (g);
//Number of students resources
int engineer = getStudents (g, me, STUDENT_BPS);
int scientist = getStudents (g, me, STUDENT_BQN);
int jobOwner = getStudents (g, me, STUDENT_MJ);
int tvStar = getStudents (g, me, STUDENT_MTV);
int moneyMaker = getStudents (g, me, STUDENT_MMONEY);
//Exchange rate - Retraining Conditions
//Last argument unnecessary as only disciplineFrom is important
int costSci = getExchangeRate (g, me, STUDENT_BQN, STUDENT_MJ);
int costEng = getExchangeRate (g, me, STUDENT_BPS, STUDENT_MJ);
int costJob = \
getExchangeRate (g, me, STUDENT_MJ, STUDENT_BPS);
int costTv = getExchangeRate (g, me, STUDENT_MTV, STUDENT_BPS);
int costMon = \
getExchangeRate (g, me, STUDENT_MMONEY, STUDENT_BPS);
//Possible actions to do:
//Spinoffs -> 1 MJ + 1 MTV + 1 MMNY
//Build ARCs -> 1 BPS + 1 BQN
action nextAction;
if (tvStar > costTv || jobOwner > costJob \
|| moneyMaker > costMon || scientist >= costSci \
|| engineer >= costEng) {
// > to keep some MMONEY and MJOBS and MTVs,
// to use for future spinoffs
// >= to get rid of all BPS and BQNs
nextAction.actionCode = RETRAIN_STUDENTS;
//determine which student to retrain to
if (jobOwner <= tvStar && jobOwner <= moneyMaker) {
nextAction.disciplineTo = STUDENT_MJ;
} else if (tvStar <= jobOwner && tvStar <= moneyMaker) {
nextAction.disciplineTo = STUDENT_MTV;
} else {
nextAction.disciplineTo = STUDENT_MMONEY;
}
//Find out which student to retrain from
/*Order is
MJ -> MTV -> MMONEY -> BQN -> BPS
this ensures that BQN/BPS are retrained first*/
if (jobOwner > costJob) {
nextAction.disciplineFrom = STUDENT_MJ;
} else if (tvStar > costTv) {
nextAction.disciplineFrom = STUDENT_MTV;
} else if (moneyMaker > costMon) {
nextAction.disciplineFrom = STUDENT_MMONEY;
} else if (scientist >= costSci) {
nextAction.disciplineFrom = STUDENT_BQN;
} else {
nextAction.disciplineFrom = STUDENT_BPS;
}
} else if ((jobOwner * tvStar * moneyMaker) > 0) {
//create a spinoff
nextAction.actionCode = START_SPINOFF;
} else {
//no resources so end turn
nextAction.actionCode = PASS;
}
return nextAction;
}
