/**
* Return a Comparator that will order the specified units in preferred unload order. If needed it
* may also inspect the transport holding the units.
*/
public static Comparator<Unit> getUnloadableUnitsComparator(
final List<Unit> units, final Route route, final PlayerID player) {
// compare transports
final Comparator<Unit> unloadableTransportsComparator =
getUnloadableTransportsComparator(units, route, player, false);
// if noTies is set, sort by hashcode so that result is deterministic
final Comparator<Unit> movableUnitsComparator = getMovableUnitsComparator(units, route);
return (u1, u2) -> {
final Unit t1 = TripleAUnit.get(u1).getTransportedBy();
final Unit t2 = TripleAUnit.get(u2).getTransportedBy();
// check if unloadable units are in a transport
if (t1 != null && t2 == null) {
return -1;
}
if (t1 == null && t2 != null) {
return 1;
}
if (t1 != null && t2 != null) {
final int compareTransports = unloadableTransportsComparator.compare(t1, t2);
if (compareTransports != 0) {
return compareTransports;
}
}
// we are sorting air units, or no difference found yet
// if noTies is set, sort by hashcode so that result is deterministic
return movableUnitsComparator.compare(u1, u2);
};
}
public static Comparator<Unit> getHighestToLowestMovementComparator() {
return (u1, u2) -> {
final int left1 = TripleAUnit.get(u1).getMovementLeft();
final int left2 = TripleAUnit.get(u2).getMovementLeft();
if (left1 == left2) {
return 0;
}
if (left1 < left2) {
return 1;
}
return -1;
};
}
/** Return a Comparator that will order the specified transports in preferred unload order. */
public static Comparator<Unit> getUnloadableTransportsComparator(
final List<Unit> transports, final Route route, final PlayerID player, final boolean noTies) {
final Comparator<Unit> decreasingCapacityComparator =
getDecreasingCapacityComparator(transports);
final Match<Unit> incapableTransportMatch = Matches.transportCannotUnload(route.getEnd());
return (t1, t2) -> {
// Check if transport is incapable due to game state
final boolean isIncapable1 = incapableTransportMatch.match(t1);
final boolean isIncapable2 = incapableTransportMatch.match(t2);
if (!isIncapable1 && isIncapable2) {
return -1;
}
if (isIncapable1 && !isIncapable2) {
return 1;
}
// Prioritize allied transports
final boolean isAlliedTrn1 = !t1.getOwner().equals(player);
final boolean isAlliedTrn2 = !t2.getOwner().equals(player);
if (isAlliedTrn1 && !isAlliedTrn2) {
return -1;
}
if (!isAlliedTrn1 && isAlliedTrn2) {
return 1;
}
// Sort by decreasing transport capacity
final int compareCapacity = decreasingCapacityComparator.compare(t1, t2);
if (compareCapacity != 0) {
return compareCapacity;
}
// Sort by increasing movement
final int left1 = TripleAUnit.get(t1).getMovementLeft();
final int left2 = TripleAUnit.get(t2).getMovementLeft();
if (left1 != left2) {
return left1 - left2;
}
// If noTies is set, sort by hashcode so that result is deterministic
if (noTies) {
return Integer.compare(t1.hashCode(), t2.hashCode());
} else {
return 0;
}
};
}
/** Return a Comparator that will order the specified transports in preferred load order. */
public static Comparator<Unit> getLoadableTransportsComparator(
final List<Unit> transports, final Route route, final PlayerID player) {
final Comparator<Unit> decreasingCapacityComparator =
getDecreasingCapacityComparator(transports);
final Match<Unit> incapableTransportMatch = Matches.transportCannotUnload(route.getEnd());
return (u1, u2) -> {
final TripleAUnit t1 = TripleAUnit.get(u1);
final TripleAUnit t2 = TripleAUnit.get(u2);
// Check if transport is incapable due to game state
final boolean isIncapable1 = incapableTransportMatch.match(t1);
final boolean isIncapable2 = incapableTransportMatch.match(t2);
if (!isIncapable1 && isIncapable2) {
return -1;
}
if (isIncapable1 && !isIncapable2) {
return 1;
}
// Use allied transports as a last resort
final boolean isAlliedTrn1 = !t1.getOwner().equals(player);
final boolean isAlliedTrn2 = !t2.getOwner().equals(player);
if (!isAlliedTrn1 && isAlliedTrn2) {
return -1;
}
if (isAlliedTrn1 && !isAlliedTrn2) {
return 1;
}
// Sort by decreasing transport capacity
final int compareCapacity = decreasingCapacityComparator.compare(t1, t2);
if (compareCapacity != 0) {
return compareCapacity;
}
// Sort by decreasing movement
final int left1 = t1.getMovementLeft();
final int left2 = t1.getMovementLeft();
if (left1 != left2) {
return left2 - left1;
}
return Integer.compare(t1.hashCode(), t2.hashCode());
};
}
/** Return a Comparator that will order the specified units in preferred move order. */
public static Comparator<Unit> getMovableUnitsComparator(
final List<Unit> units, final Route route) {
final Comparator<Unit> decreasingCapacityComparator = getDecreasingCapacityComparator(units);
return (u1, u2) -> {
// Ensure units have enough movement
final int left1 = TripleAUnit.get(u1).getMovementLeft();
final int left2 = TripleAUnit.get(u2).getMovementLeft();
if (route != null) {
if (left1 >= route.getMovementCost(u1) && left2 < route.getMovementCost(u2)) {
return -1;
}
if (left1 < route.getMovementCost(u1) && left2 >= route.getMovementCost(u2)) {
return 1;
}
}
// Prefer transports for which dependents are also selected
final Collection<Unit> transporting1 = TripleAUnit.get(u1).getTransporting();
final Collection<Unit> transporting2 = TripleAUnit.get(u2).getTransporting();
final int hasDepends1 = units.containsAll(transporting1) ? 1 : 0;
final int hasDepends2 = units.containsAll(transporting2) ? 1 : 0;
if (hasDepends1 != hasDepends2) {
return hasDepends1 - hasDepends2;
}
// Sort by decreasing transport capacity (only valid for transports)
final int compareCapacity = decreasingCapacityComparator.compare(u1, u2);
if (compareCapacity != 0) {
return compareCapacity;
}
// Sort by increasing movement normally, but by decreasing movement during loading
if (left1 != left2) {
if (route != null && route.isLoad()) {
return left2 - left1;
} else {
return left1 - left2;
}
}
return Integer.compare(u1.hashCode(), u2.hashCode());
};
}
private static Comparator<Unit> getCapacityComparator(
final List<Unit> transports, final boolean increasing) {
// this makes it more efficient
final IntegerMap<Unit> capacityMap = new IntegerMap<>(transports.size() + 1, 1);
for (final Unit transport : transports) {
final Collection<Unit> transporting = TripleAUnit.get(transport).getTransporting();
capacityMap.add(transport, TransportUtils.getTransportCost(transporting));
}
return (t1, t2) -> {
final int cost1 = capacityMap.getInt(t1);
final int cost2 = capacityMap.getInt(t2);
if (increasing) {
return cost1 - cost2;
} else {
return cost2 - cost1;
}
};
}