/** * <code>compareRatings</code> compares all the ratings of <code>PossibleTarget</code>s and retuns the best ones * @param possibleTargets an array of all the PossibleTargets * @return bestOptions, the list of the best PossibleTargets */ private List <PossibleTarget> compareRatings(List <PossibleTarget> possibleTargets) { // create list bestOptions, which will be all the PossibleTargets with the same and highest values List <PossibleTarget> bestOptions = new List <PossibleTarget>(); // set the first possibleTarget as current best target PossibleTarget highestRating = possibleTargets[0]; // Add this target to the list of bestOptions bestOptions.Add(highestRating); // Loop through all the possibleTargets and compare their ratings for (int k = 1; k < possibleTargets.Count; k++) { if (highestRating.rating < possibleTargets[k].rating) // if one with a higher rating is found, empty the list and add this as best { bestOptions.Clear(); highestRating = possibleTargets[k]; bestOptions.Add(possibleTargets[k]); } else if (highestRating.rating == possibleTargets[k].rating) // else (same ratings), add the current rating to bestOptions { bestOptions.Add(possibleTargets[k]); } } return(bestOptions); }
/** * <code>compareFactor</code> compares <code>Factor</code> values between two <code>PossibleSpot</code>s * @param factor the <code>Factor</code> that has to be compared * @param compareOptions the list of PossibleTargets that have to be compared * @return equals , the list of PossibleTargets (in this case the length is either 1 or 0) */ private List <PossibleTarget> compareFactor(Factor factor, List <PossibleTarget> compareOptions) { // Set the first possibleTarget as the current best target PossibleTarget best = compareOptions[0]; // Create new list that will contain all the equals List <PossibleTarget> equals = new List <PossibleTarget>(); // Add the current best to the list of equals equals.Add(compareOptions[0]); // Create a new Boolean[] that will contain the results of comparePossibleTargets Boolean[] compares = new Boolean[2]; // Loop through all the PossibleTargets and compare the values of the factors for (int k = 1; k < compareOptions.Count; k++) { // set the current PossibleTarget as 'current' PossibleTarget current = compareOptions[k]; // Compare the current with the best PossibleTarget, based on a factor compares = comparePossibleTargets(factor, current, best); if (compares[0]) // if current >/< than the best, remove the best from the list and set this as best and add to list { equals.Clear(); best = current; equals.Add(best); } else if (compares[1]) // else (current==best), clear the list and break (as it turns out there are more than one with the same valuees) { equals.Clear(); break; } } return(equals); }
/** * <code>rateFactor</code> will rate the given <code>factor</code> and will give the correct rating for each of the <code>PossibleTargets</code>. * @param possibleTargets an array of all the PossibleTargets on the Playfield * @param factor the name of the factor that will be rated * @return possibleTargets the updated array of all PossibleTargets with updated ratings */ private List <PossibleTarget> rateFactor(List <PossibleTarget> possibleTargets, Factor factor) { // Set the first possibleTarget as the current best target PossibleTarget best = possibleTargets[0]; // Create a new Boolean[] that will contain the results of comparePossibleTargets Boolean[] compares = new Boolean[2]; // Set the rating to the corresponding Factor rating double rating = factor.getRating(); //System.out.println("rating: " + rating); // Create new list that will contain all the equals List <PossibleTarget> equals = new List <PossibleTarget>(); // Add the current best to the list of equals equals.Add(best); double bestRating = best.getRating(); bestRating = (best.getRating() + rating); // Loop through all the PossibleTargets and compare them with the current best for (int k = 1; k < possibleTargets.Count; k++) { // Set the current possibleTarget as 'current' PossibleTarget current = possibleTargets[k]; // Compare the current with the best PossibleTarget, based on a factor //System.out.println("current " + current.toString()); //System.out.println("best" + best.toString()); compares = comparePossibleTargets(factor, current, best); //System.out.println("Compares: [0]=" + compares[0] + ", compares[1]=" + compares[1]); if (compares[0] == true) // if current >/< than the best, remove the best from the list and set this as best and add to list { for (int j = 0; j < equals.Count; j++) { double equalsRating = equals[j].getRating(); equalsRating = equals[j].getRating() - rating; } equals.Clear(); best = current; best.rating = best.rating + rating; equals.Add(best); } else if (compares[1]) // else (current==best), name this one as best and add this one also to the list { best = current; best.rating = best.rating + rating; equals.Add(best); } } /*for(PossibleTarget pt : possibleTargets) { * System.out.println("Rating: " + pt.rating); * }*/ return(possibleTargets); }
/** * <code>comparePossibleTargets</code> is used in <code>rateFactor</code> to compare two <code>PossibleTargets</code>'s factor values. * @param factor the factor of which the value has to be compared * @param possible the first PossibleSpot (the one that will be placed before the evaluation symbol) * @param best the second PossibleSpot (the one that will be placed behind the evaluation symbol) * @return result an Boolean[2] array. Index 0 will contain true/false for the >/< evaluator and Index 1 will contain the true/false for the == evaluator. */ private Boolean[] comparePossibleTargets(Factor factor, PossibleTarget possible, PossibleTarget best) { // Create a new Boolean[] that will contain the results of comparePossibleTargets Boolean[] result = new Boolean[2]; //System.out.println("Spots: " + possible.toGoalSpot().toString() + ", " + best.toGoalSpot().toString()); // Look at which factor has to be compared and compare them between two PossibleTargets if (factor == Factor.TPD) { result [0] = (possible.getTPD() > best.getTPD()); result [1] = possible.getTPD() == best.getTPD(); //System.out.println("result 0: " + result[0]); //System.out.println("result 1: " + result[1]); } else if (factor == Factor.ST) { result [0] = possible.getSurThreat() < best.getSurThreat(); result [1] = possible.getSurThreat() == best.getSurThreat(); } else if (factor == Factor.SD) { result [0] = possible.getSD() < best.getSD(); result [1] = possible.getSD() == best.getSD(); } else if (factor == Factor.FDC) { result [0] = possible.getCalcCost() < best.getCalcCost(); result [1] = possible.getCalcCost() == best.getCalcCost(); } else if (factor == Factor.HD) { result[0] = possible.getHighestDanger() < best.getHighestDanger(); result[1] = possible.getHighestDanger() == best.getHighestDanger(); } return(result); }
/** * <code>pickTarget</code> picks the best <code>GoalSpot</code> based on:<br> * <ul> * <li> TPD (Total Player Distance): How far are all players away from the <code>GoalSpot</code>?</li> * <li> SD (Spot Distance): How far away is the MovingSpot away from the <code>GoalSpot</code>?</li> * <li> FDC (Fastest Danger Cost): How dangerous is the fastest path to the <code>GoalSpot</code>?</li> * <li> ST (Surround Threat): How dangerous is the area around the <code>GoalSpot</code>?</li> * <li> HD (Highest Danger): What is the highest danger level while moving over the FDC-path to the <code>GoalSpot</code>?</li> * </ul> * @param allGoals the array of all the GoalSpots on the Playfield * @return target the GoalSpot that is the best choice to move to */ public GoalSpot pickTarget(List <GoalSpot> allGoals) { // Create the empty array that will contain all the PossibleTargets. List <PossibleTarget> possibleTargets = new List <PossibleTarget>(); // Create all the PossibleTargets (out of GoalSpots) and set the correct values for HD, TPD, SD, FDC and ST. for (int i = 0; i < allGoals.Count; i++) { //System.out.println("\nGOAL " + i); GoalSpot current = allGoals[i]; possibleTargets[i] = new PossibleTarget(current); PossibleTarget possible = possibleTargets[i]; int calculatedCost = 0; double penalty = 1; // Calculate the Fastest Danger Cost to this spot calculatedCost = current.calculateDangerCost(x, y, possible); //TODO: Move to the calculateSurround() in GoalSpot // Check if the GoalSpot is located against the wall and add a penalty if (current.getX() == 0 || current.getX() == playfield.width - 1 || current.getY() == playfield.height || current.getY() == 0) { penalty = 1.6; } // Set all the values for the variables in PossibleTarget possible.setTPD(current.getTPD()); possible.setSD(current.getSD()); possible.setPenalty(penalty); possible.setCalcCost(calculatedCost); int weightedSurThreat = (int)(current.calculateSurround() * penalty); possible.setSurThreat(weightedSurThreat); //System.out.println("HD: " + possible.getHighestDanger()); //System.out.println("TPD: " + current.getTPD()); //System.out.println("SD: " + current.getSD()); //System.out.println("ST: " + weightedSurThreat); //System.out.println("FDC: " + calculatedCost); } // Loop through all factors and rate them for each of the PossibleTargets foreach (Factor factor in factors) { possibleTargets = rateFactor(possibleTargets, factor); } // Create a new list BestOptions to compare the ratings List <PossibleTarget> bestOptions = new List <PossibleTarget>(); // Compare ratings between all the PossibleTargets bestOptions = compareRatings(possibleTargets); // Check if bestOptions.size() is 1, as that means there is only one best Spot -> return this spot if (bestOptions.Count == 1) { //System.out.println("Found directly!"); return(bestOptions[0].toGoalSpot()); } // Else: Continue with all the best options left // Make new list to be rated on independent factors (bestOptions = backup) //List<PossibleTarget> compareOptions = bestOptions; // Loop through all the factors and compare them for all the remaining best options //System.out.println("Compare again: "); foreach (Factor current in factors) { //System.out.println(bestOptions.get(0).toString()); //System.out.println(bestOptions.get(1).toString()); List <PossibleTarget> compareOptions = compareFactor(current, bestOptions); // If the list has a size of 1 then, a result has been found and return this GoalSpot if (compareOptions.Count == 1) { return(compareOptions[0].toGoalSpot()); // Else reset compareOptions with bestOptions and then try again for the next factor /*} else { * compareOptions = bestOptions; */ } } //System.out.println("Random: "); //If all else fails, pick a random target from the original PossibleTargets return(pickRandomGoal(bestOptions)); }