Updated README, added header with group members to bot files

Author: eoin-cr

README.md

@@ -1,18 +1,61 @@
 # COMP20050 Group12
-Eoin Creavin, Mynah Bhattacharyya, Ben McDowell
+[Eoin Creavin](https://github.com/eoin-cr/), [Mynah Bhattacharyya](https://github.com/mynah-bird),
+[Ben McDowell](https://github.com/Benmc1/)
 
-Use of certain newer Java features means a requirement of at least Java 17 has been
-imposed in the gradle build file.
+## How to play
+Simply either run the jar release with `java -jar [RELEASE].jar` or run the 
+`Main` java file in your IDE of choice.  The game will
+then start.  It will ask you whether you want bot mode on or off. If you select to
+have bot mode on, two bots will play each other in cascadia, selecting where to place
+tiles, tokens, how to rotate the tiles, whether to activate a cull or not, etc.
+The bots will play their turns in under a five-second time limit.
+
+## Bot strategies
+### Tokens
+The token class will base the ranking of the deck tokens on how many points each
+token would give it if it were placed. It iterates through the possible placements
+for each token and sees what the score for each placement would be.  Due to the
+limited number of tiles, this is not incredibly time intensive, and does not come
+close to the 5-second time limit.
+
+The bot has two implementations of this—constructive and destructive. The 
+constructive method attempts to increase the current players score the most, 
+whilst the destructive tries to take the token away from the other player which
+would have increased the other player's score the most.
+
+### Tiles
+The bot first prioritises increasing the size of habitat corridors which are close
+in size (-1,0, or 1 away) to the opponents same habitat corridor. This is because
+bonus points are allocated to the player with the longest of each type of habitat
+corridor, so we don't want to lose our advantage.
+
+For any tiles that do not have habitat corridors that are close in size the bot
+finds the smallest habitat corridor and tries to increase its size, so we have
+multiple consistently sized habitat corridors to maximise scoring. The bot also
+uses a constructive and destructive version of this.
 
-Gradle should not be required to run the game, however, the tests use the Mockito
-library which requires gradle to include.
+The tile bot also selects the tile rotation which will maximise its habitat corridor
+length.
 
-A screenshot of the test coverage of the project has been included 
-(see TestCoverage.png).
+### Tile token selection
+The bot then gets the tile and token preferences.  It then iterates through, finding
+the best tile token pair for placement.  Usually you can only place a tile and token
+from the same pair, however, you can spend a nature token to select any tile and any
+token and make a pair. If the max possible score is a decent bit larger than the
+max pair, if the bot has a nature token it will spend it in order to select the
+maximum score.
 
-A modified version of the Google stylesheet has been used for the code 
-styling (see stylesheet.xml)
+# Requirements
+
+Use of certain newer Java features means a requirement of at least Java 17 has been
+imposed in the gradle build file. Gradle is not required to run the game, however, 
+the game tests use the Mockito library which requires gradle to include.
 
 We have used the default gradle package layout (`src/main/java/...` and `src/test/java/...`).
 Make sure to change the package source file from `src` to `src/main/java` and set the
 main run configuration to `cascadia.Main`.
+
+### Links
+**This repo:** https://github.com/eoin-cr/COMP20050_Group12
+
+**Sprint 5 kanban board:** https://github.com/users/mynah-bird/projects/2

src/bot/java/cascadia/BotMain.java

@@ -1,3 +1,18 @@
+/*
+	COMP20050 Group 12
+	Eoin Creavin – Student ID: 21390601
+	eoin.creavin@ucdconnect.ie
+	GitHub ID: eoin-cr
+
+	Mynah Bhattacharyya – Student ID: 21201085
+	malhar.bhattacharyya@ucdconnect.ie
+	GitHub ID: mynah-bird
+
+	Ben McDowell – Student ID: 21495144
+	ben.mcdowell@ucdconnect.ie
+	GitHub ID: Benmc1
+ */
+
 package cascadia;
 
 import java.util.Arrays;
@@ -53,13 +68,11 @@ public void makeBestChoiceFromDeck(Player currPlayer) {
 
 		BotTimer.startTimer();
 
-
 		int[] tilePreferences = tileBots[turn % 2].chooseStrategy(currPlayer, nextPlayer);
 		int[] tokenPreferences = tokenBots[turn % 2].chooseStrategy(currPlayer, nextPlayer);
 		System.out.printf("tile: %s\n", Arrays.toString(tilePreferences));
 		System.out.printf("token: %s\n", Arrays.toString(tokenPreferences));
 
-		//TODO: handle nature token spend here
 		int maxScore = tilePreferences[0] + tokenPreferences[0];
 		int maxScoreIdx = 0;
 		for (int i = 0; i < tilePreferences.length; i++) {

src/bot/java/cascadia/BotTimer.java

@@ -1,3 +1,18 @@
+/*
+	COMP20050 Group 12
+	Eoin Creavin – Student ID: 21390601
+	eoin.creavin@ucdconnect.ie
+	GitHub ID: eoin-cr
+
+	Mynah Bhattacharyya – Student ID: 21201085
+	malhar.bhattacharyya@ucdconnect.ie
+	GitHub ID: mynah-bird
+
+	Ben McDowell – Student ID: 21495144
+	ben.mcdowell@ucdconnect.ie
+	GitHub ID: Benmc1
+ */
+
 package cascadia;
 
 public class BotTimer {
@@ -11,10 +26,9 @@ public static void startTimer() {
     /**
      * True if there is time left.
      * Otherwise, its False
-     * @return Boolean
      */
     public static boolean isTimeLeft() {
-        double milliSeconds = (System.nanoTime() - startTime)*.000001;
+        double milliSeconds = (System.nanoTime() - startTime) * .000001;
         return !(milliSeconds > TIME_ALLOWED);
     }
 }

src/bot/java/cascadia/TileBot.java

@@ -1,3 +1,18 @@
+/*
+	COMP20050 Group 12
+	Eoin Creavin – Student ID: 21390601
+	eoin.creavin@ucdconnect.ie
+	GitHub ID: eoin-cr
+
+	Mynah Bhattacharyya – Student ID: 21201085
+	malhar.bhattacharyya@ucdconnect.ie
+	GitHub ID: mynah-bird
+
+	Ben McDowell – Student ID: 21495144
+	ben.mcdowell@ucdconnect.ie
+	GitHub ID: Benmc1
+ */
+
 package cascadia;
 import java.util.ArrayList;
 import java.util.Arrays;

src/bot/java/cascadia/TokenBot.java

@@ -1,7 +1,21 @@
+/*
+	COMP20050 Group 12
+	Eoin Creavin – Student ID: 21390601
+	eoin.creavin@ucdconnect.ie
+	GitHub ID: eoin-cr
+
+	Mynah Bhattacharyya – Student ID: 21201085
+	malhar.bhattacharyya@ucdconnect.ie
+	GitHub ID: mynah-bird
+
+	Ben McDowell – Student ID: 21495144
+	ben.mcdowell@ucdconnect.ie
+	GitHub ID: Benmc1
+ */
+
 package cascadia;
 
 import cascadia.scoring.ScoreToken;
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Random;
@@ -14,15 +28,10 @@ public class TokenBot {
 	public static final int NUM_TOKEN_STRATS = 2;
 	// we don't need the token score map atm, but I'm keeping it in case we need it in the
 	// future
-	private final List<ValueSortedMap<Integer, Integer>> deckScoreMap = new ArrayList<>();
 	private final int[] bestPlacementIds = new int[Constants.MAX_DECK_SIZE];
 	private final int[] rankedTokens = new int[Constants.MAX_DECK_SIZE];
 
 	public TokenBot() {
-		for (int j = 0; j < Constants.NUM_TOKEN_TYPES; j++) {
-			deckScoreMap.add(new ValueSortedMap<>());
-		}
-
 		// initialise it to -1, so we know when we aren't able to place a token
 		Arrays.fill(bestPlacementIds, -1);
 	}
@@ -45,7 +54,6 @@ public int[] chooseStrategy(Player player, Player nextPlayer) {
 
 		if (!BotTimer.isTimeLeft()) {
 			System.out.println("No time left!");
-			System.out.println(Arrays.toString(rankedTokens));
 			return rankedTokens;
 		}
 
@@ -77,7 +85,6 @@ private void destructiveTokenStrat(List<WildlifeToken> deckTokens, Player nextPl
 	private void rankDeckTokens(Player player, boolean isConst, List<WildlifeToken> deckTokens) {
 		int[] scores = new int[Constants.MAX_DECK_SIZE];
 		for (int i = 0; i < Constants.MAX_DECK_SIZE; i++) {
-			deckScoreMap.get(i).clear(); // clear the scores in the map before calculating
 			// checks whether it is possible to place a certain token on the map.  If it
 			// is not, the score for that token is largely decreased
 			if (player.getMap().numPossibleTokenPlacements(deckTokens.get(i)) == 0) {
@@ -94,7 +101,7 @@ private void rankDeckTokens(Player player, boolean isConst, List<WildlifeToken>
 	}
 
 	/*
-        Tries place the token in all possible positions and returns the greatest increase
+        Tries to place the token in all possible positions and returns the greatest increase
         in score
     */
 	private int calculatePlacementScoresAndReturnMax(WildlifeToken token, Player player,
@@ -109,7 +116,6 @@ private int calculatePlacementScoresAndReturnMax(WildlifeToken token, Player pla
 
 		int prevScore = ScoreToken.calculateScore(player.getMap(), token);
 
-		// oh boy the time complexity of this is. not good.
 		for (HabitatTile tile : possibleTiles) {
 			Player tmp = new Player("temp");
 			tmp.getMap().setTileBoard(PlayerMap.deepCopy(player.getMap().getTileBoardPosition()));
@@ -120,7 +126,6 @@ private int calculatePlacementScoresAndReturnMax(WildlifeToken token, Player pla
 				// we get an extra point for getting a nature token from placing on a keystone tile
 				scoreDiff++;
 			}
-			deckScoreMap.get(idx).put(tile.getTileID(), scoreDiff);
 
 			// set it to scores that are equal to as well, as for example if the
 			// diff is 0 when we place a token, it's still better to place a token
@@ -148,24 +153,17 @@ private int calculatePlacementScoresAndReturnMax(WildlifeToken token, Player pla
 	// converts an arraylist of scores (e.g. [1,10,5,6]) to their relative
 	// ranking (e.g. [0,3,1,2])
 	private void convertToRank(int[] scores, List<WildlifeToken> deckTokens) {
-		System.out.println("-----");
-		System.out.println(Arrays.toString(scores));
 
 		List<Integer> sorted = Arrays.stream(scores).sorted().boxed().toList();
-		System.out.println("Sorted: " + sorted);
 
 		for (int i = 0; i < sorted.size(); i++) {
 			scores[i] = sorted.indexOf(scores[i]);
 		}
-		System.out.println(Arrays.toString(scores));
 
 //		for (int i = 0; i < scores.length; i++) {
 //			rankedTokens[i] = 4 - scores[i];
 //		}
 		System.arraycopy(scores, 0, rankedTokens, 0, rankedTokens.length);
-
-		System.out.println(Arrays.toString(rankedTokens));
-		System.out.println("-----");
 	}
 
 	/**
@@ -179,14 +177,14 @@ private void convertToRank(int[] scores, List<WildlifeToken> deckTokens) {
 	 */
 	public int getBestPlacement(WildlifeToken token, int deckIdx, Player player) {
 		int id = bestPlacementIds[deckIdx];
-		System.out.println(Arrays.toString(bestPlacementIds));
+//		System.out.println(Arrays.toString(bestPlacementIds));
 
 		// if we were doing the destructive method (finding the best token for the opponent
 		// and taking it) we want to find where we can place that token on our map
 		if (id == -2) {
 			calculatePlacementScoresAndReturnMax(token, player, true, deckIdx);
 			id = bestPlacementIds[deckIdx];
-			System.out.println(Arrays.toString(bestPlacementIds));
+//			System.out.println(Arrays.toString(bestPlacementIds));
 		}
 		return id;
 	}