Fixed metrics in AIUtil

git-svn-id: svn://sunsvr01.isp.uni-luebeck.de/swproj13/trunk@361 72836036-5685-4462-b002-a69064685172

src/jrummikub/control/AIUtil.java

@@ -32,7 +32,8 @@ public class AIUtil {
 	public AIUtil(GameSettings settings) {
 		this.settings = settings;
 
-		stoneColors = new ArrayList<StoneColor>(Arrays.asList(StoneColor.values()));
+		stoneColors = new ArrayList<StoneColor>(Arrays.asList(StoneColor
+				.values()));
 		stoneColors.retainAll(settings.getStoneColors());
 	}
 
@@ -42,16 +43,30 @@ public class AIUtil {
 		int jokerCount;
 
 		SearchState(int pointsMissing,
-				TreeMap<Pair<Integer, StoneColor>, Integer> stoneCounts, int jokerCount) {
+				TreeMap<Pair<Integer, StoneColor>, Integer> stoneCounts,
+				int jokerCount) {
 			this.pointsMissing = pointsMissing;
 			this.stoneCounts = stoneCounts;
 			this.jokerCount = jokerCount;
 		}
 	}
 
+	@SuppressWarnings("serial")
+	private static class EnoughPoints extends Throwable {
+		private Pair<List<StoneSet>, Integer> result;
+
+		public EnoughPoints(Pair<List<StoneSet>, Integer> result) {
+			this.result = result;
+		}
+
+		public Pair<List<StoneSet>, Integer> getResult() {
+			return result;
+		}
+	}
+
 	/**
-	 * Tries to find sets with a certain total of points. If only lower totals are
-	 * found, returns the sets with the highest cumulated point total.
+	 * Tries to find sets with a certain total of points. If only lower totals
+	 * are found, returns the sets with the highest cumulated point total.
 	 * 
 	 * @param pointsMissing
 	 *            the desired number of points
@@ -64,139 +79,147 @@ public class AIUtil {
 	@SuppressWarnings("unchecked")
 	public Pair<List<StoneSet>, Integer> findSetsWithTotalPoints(
 			int pointsMissing,
-			TreeMap<Pair<Integer, StoneColor>, Integer> stoneCounts, int jokerCount) {
-
-		if (pointsMissing <= 0) {
-			return new Pair<List<StoneSet>, Integer>(
+			TreeMap<Pair<Integer, StoneColor>, Integer> stoneCounts,
+			int jokerCount) {
+		Pair<List<StoneSet>, Integer> emptyResult = new Pair<List<StoneSet>, Integer>(
 				Collections.<StoneSet> emptyList(), 0);
-		}
+		if (pointsMissing <= 0)
+			return emptyResult;
 
 		stoneCounts = (TreeMap<Pair<Integer, StoneColor>, Integer>) stoneCounts
 				.clone();
 
-		Pair<List<StoneSet>, Integer> result, bestResult;
-		bestResult = new Pair<List<StoneSet>, Integer>(
-				Collections.<StoneSet> emptyList(), 0);
-
+		SearchHelper searchHelper = new SearchHelper(pointsMissing,
+				new Pair<List<StoneSet>, Integer>(
+						Collections.<StoneSet> emptyList(), 0));
+		try {
 			for (int value = settings.getHighestValue(); value >= 1; value--) {
 				for (StoneColor color : stoneColors) {
-				Pair<Integer, StoneColor> stone = new Pair<Integer, StoneColor>(value,
-						color);
+					Pair<Integer, StoneColor> stone = new Pair<Integer, StoneColor>(
+							value, color);
 
 					if (stoneCounts.containsKey(stone)) {
+						SearchState searchState = new SearchState(pointsMissing
+								- value, stoneCounts, jokerCount);
 						decrementStoneCount(stoneCounts, stone);
-					result = findRunsWithTotalPoints(new SearchState(pointsMissing
-							- value, stoneCounts, jokerCount), stone, 1);
-					if (result.getSecond() >= pointsMissing)
-						return result;
-					if (result.getSecond() > bestResult.getSecond())
-						bestResult = result;
+						searchHelper.checkResult(findRunsWithTotalPoints(
+								searchState, stone, 1));
 
-					result = findGroupsWithTotalPoints(new SearchState(pointsMissing
-							- value, stoneCounts, jokerCount), value,
-							Collections.singletonList(color), color);
-					if (result.getSecond() >= pointsMissing)
-						return result;
-					if (result.getSecond() > bestResult.getSecond())
-						bestResult = result;
+						searchHelper.checkResult(findGroupsWithTotalPoints(
+								searchState, value,
+								Collections.singletonList(color), color));
 					}
 
 					if (jokerCount > 0) {
-					result = findRunsWithTotalPoints(new SearchState(pointsMissing
-							- value, stoneCounts, jokerCount - 1), stone, 1);
-					if (result.getSecond() >= pointsMissing)
-						return result;
-					if (result.getSecond() > bestResult.getSecond())
-						bestResult = result;
+						SearchState searchState = new SearchState(pointsMissing
+								- value, stoneCounts, jokerCount - 1);
+						searchHelper.checkResult(findRunsWithTotalPoints(
+								searchState, stone, 1));
 
-					result = findGroupsWithTotalPoints(new SearchState(pointsMissing
-							- value, stoneCounts, jokerCount - 1), value,
-							Collections.singletonList(color), color);
+						searchHelper.checkResult(findGroupsWithTotalPoints(
+								searchState, value,
+								Collections.singletonList(color), color));
+					}
+				}
+			}
+		} catch (EnoughPoints enoughPoints) {
+			return enoughPoints.getResult();
+		}
+		return searchHelper.getBestResult();
+	}
+
+	private static class SearchHelper {
+		Pair<List<StoneSet>, Integer> bestResult;
+		int pointsMissing;
+
+		public SearchHelper(int pointsMissing,
+				Pair<List<StoneSet>, Integer> bestResult) {
+			this.pointsMissing = pointsMissing;
+			this.bestResult = bestResult;
+		}
+
+		public void checkResult(Pair<List<StoneSet>, Integer> result)
+				throws EnoughPoints {
 			if (result.getSecond() >= pointsMissing)
-						return result;
+				throw new EnoughPoints(result);
 			if (result.getSecond() > bestResult.getSecond())
 				bestResult = result;
 		}
-			}
-		}
 
+		public Pair<List<StoneSet>, Integer> getBestResult() {
 			return bestResult;
 		}
+	}
 
 	private Pair<List<StoneSet>, Integer> findGroupsWithTotalPoints(
 			SearchState searchState, int value, List<StoneColor> chosenColors,
 			StoneColor testedColor) {
 
 		StoneColor nextColor = getNextColor(testedColor);
-		Pair<Integer, StoneColor> nextStone = new Pair<Integer, StoneColor>(value,
-				nextColor);
-
-		Pair<List<StoneSet>, Integer> result, bestResult;
-		bestResult = new Pair<List<StoneSet>, Integer>(
-				Collections.<StoneSet> emptyList(), 0);
+		Pair<Integer, StoneColor> nextStone = new Pair<Integer, StoneColor>(
+				value, nextColor);
 
+		SearchHelper searchHelper = new SearchHelper(searchState.pointsMissing,
+				new Pair<List<StoneSet>, Integer>(
+						Collections.<StoneSet> emptyList(), 0));
+		try {
 			if (nextColor != null) {
+				List<StoneColor> newColors = new ArrayList<StoneColor>(
+						chosenColors);
+				newColors.add(nextColor);
 				if (searchState.stoneCounts.containsKey(nextStone)) {
 					decrementStoneCount(searchState.stoneCounts, nextStone);
-				List<StoneColor> newColors = new ArrayList<StoneColor>(chosenColors);
-				newColors.add(nextColor);
-				result = findGroupsWithTotalPoints(new SearchState(
-						searchState.pointsMissing, searchState.stoneCounts,
-						searchState.jokerCount), value, newColors, nextColor);
-				if (result.getSecond() >= searchState.pointsMissing)
-					return result;
-				if (result.getSecond() > bestResult.getSecond())
-					bestResult = result;
+					searchHelper.checkResult(findGroupsWithTotalPoints(
+							searchState, value, newColors, nextColor));
 					incrementStoneCount(searchState.stoneCounts, nextStone);
 				}
 				if (searchState.jokerCount > 0) {
-				List<StoneColor> newColors = new ArrayList<StoneColor>(chosenColors);
-				newColors.add(nextColor);
-				result = findGroupsWithTotalPoints(new SearchState(
-						searchState.pointsMissing, searchState.stoneCounts,
-						searchState.jokerCount - 1), value, newColors, nextColor);
-				if (result.getSecond() >= searchState.pointsMissing)
-					return result;
-				if (result.getSecond() > bestResult.getSecond())
-					bestResult = result;
+					searchHelper.checkResult(findGroupsWithTotalPoints(
+							new SearchState(searchState.pointsMissing,
+									searchState.stoneCounts,
+									searchState.jokerCount - 1), value,
+							newColors, nextColor));
 				}
-			result = findGroupsWithTotalPoints(new SearchState(
-					searchState.pointsMissing, searchState.stoneCounts,
-					searchState.jokerCount), value, chosenColors, nextColor);
-			if (result.getSecond() >= searchState.pointsMissing)
-				return result;
-			if (result.getSecond() > bestResult.getSecond())
-				bestResult = result;
+				searchHelper.checkResult(findGroupsWithTotalPoints(searchState,
+						value, chosenColors, nextColor));
 			}
 
 			if (chosenColors.size() >= 3) {
+				searchHelper.checkResult(handleFoundGroup(searchState, value,
+						chosenColors));
+			}
+		} catch (EnoughPoints enoughPoints) {
+			return enoughPoints.getResult();
+		}
+		return searchHelper.getBestResult();
+	}
+
+	private Pair<List<StoneSet>, Integer> handleFoundGroup(
+			SearchState searchState, int value, List<StoneColor> chosenColors) {
 		int groupPoints = chosenColors.size() * value;
-			result = findSetsWithTotalPoints(searchState.pointsMissing - groupPoints,
+		Pair<List<StoneSet>, Integer> result = findSetsWithTotalPoints(
+				searchState.pointsMissing - groupPoints,
 				searchState.stoneCounts, searchState.jokerCount);
 		List<Stone> newStones = new ArrayList<Stone>();
 		for (StoneColor color : chosenColors) {
 			newStones.add(new Stone(value, color));
 		}
-			List<StoneSet> newResultList = new ArrayList<StoneSet>(result.getFirst());
+		List<StoneSet> newResultList = new ArrayList<StoneSet>(
+				result.getFirst());
 		newResultList.add(new StoneSet(newStones));
 		result = new Pair<List<StoneSet>, Integer>(newResultList,
 				result.getSecond() + groupPoints);
-			if (result.getSecond() >= searchState.pointsMissing)
 		return result;
-			if (result.getSecond() > bestResult.getSecond())
-				bestResult = result;
-		}
-		return bestResult;
 	}
 
 	private Pair<List<StoneSet>, Integer> findRunsWithTotalPoints(
 			SearchState searchState, Pair<Integer, StoneColor> testedStone,
 			int runLength) {
 
-		Pair<List<StoneSet>, Integer> result, bestResult;
-		bestResult = new Pair<List<StoneSet>, Integer>(
-				Collections.<StoneSet> emptyList(), 0);
-
+		SearchHelper searchHelper = new SearchHelper(searchState.pointsMissing,
+				new Pair<List<StoneSet>, Integer>(
+						Collections.<StoneSet> emptyList(), 0));
+		try {
 			Pair<Integer, StoneColor> nextStone = null;
 			if (testedStone.getFirst() > 1) {
 				int nextValue = testedStone.getFirst() - 1;
@@ -205,52 +228,53 @@ public class AIUtil {
 
 				if (searchState.stoneCounts.containsKey(nextStone)) {
 					decrementStoneCount(searchState.stoneCounts, nextStone);
-				result = findRunsWithTotalPoints(new SearchState(
-						searchState.pointsMissing, searchState.stoneCounts,
-						searchState.jokerCount), nextStone, runLength + 1);
-				if (result.getSecond() >= searchState.pointsMissing)
-					return result;
-				if (result.getSecond() > bestResult.getSecond())
-					bestResult = result;
+					searchHelper.checkResult(findRunsWithTotalPoints(
+							searchState, nextStone, runLength + 1));
 					incrementStoneCount(searchState.stoneCounts, nextStone);
 
 				}
 				if (searchState.jokerCount > 0) {
-				result = findRunsWithTotalPoints(new SearchState(
-						searchState.pointsMissing, searchState.stoneCounts,
-						searchState.jokerCount - 1), nextStone, runLength + 1);
-				if (result.getSecond() >= searchState.pointsMissing)
-					return result;
-				if (result.getSecond() > bestResult.getSecond())
-					bestResult = result;
+					searchHelper.checkResult(findRunsWithTotalPoints(
+							new SearchState(searchState.pointsMissing,
+									searchState.stoneCounts,
+									searchState.jokerCount - 1), nextStone,
+							runLength + 1));
+
 				}
 			}
 
 			if (runLength >= 3) {
+				searchHelper.checkResult(handleFoundRun(searchState,
+						testedStone, runLength));
+			}
+		} catch (EnoughPoints enoughPoints) {
+			return enoughPoints.getResult();
+		}
+		return searchHelper.getBestResult();
+	}
 
+	private Pair<List<StoneSet>, Integer> handleFoundRun(
+			SearchState searchState, Pair<Integer, StoneColor> testedStone,
+			int runLength) {
 		int below = testedStone.getFirst() - 1;
 		int high = below + runLength;
 		int runPoints = (high * (high + 1)) / 2 - (below * (below + 1)) / 2;
 
-			result = findSetsWithTotalPoints(searchState.pointsMissing - runPoints,
-					searchState.stoneCounts, searchState.jokerCount);
+		Pair<List<StoneSet>, Integer> result = findSetsWithTotalPoints(
+				searchState.pointsMissing - runPoints, searchState.stoneCounts,
+				searchState.jokerCount);
 
 		List<Stone> newStones = new ArrayList<Stone>();
 		for (int i = 0; i < runLength; i++) {
 			newStones.add(new Stone(i + testedStone.getFirst(), testedStone
 					.getSecond()));
 		}
-			List<StoneSet> newResultList = new ArrayList<StoneSet>(result.getFirst());
+		List<StoneSet> newResultList = new ArrayList<StoneSet>(
+				result.getFirst());
 		newResultList.add(new StoneSet(newStones));
 		result = new Pair<List<StoneSet>, Integer>(newResultList,
 				result.getSecond() + runPoints);
-
-			if (result.getSecond() >= searchState.pointsMissing)
 		return result;
-			if (result.getSecond() > bestResult.getSecond())
-				bestResult = result;
-		}
-		return bestResult;
 	}
 
 	static void incrementStoneCount(