package games.strategy.triplea.ai.proAI.util;
import java.util.Collection;
import java.util.List;
import games.strategy.engine.data.GameData;
import games.strategy.engine.data.PlayerID;
import games.strategy.engine.data.Territory;
import games.strategy.engine.data.Unit;
import games.strategy.engine.data.UnitType;
import games.strategy.triplea.Properties;
import games.strategy.triplea.attachments.UnitAttachment;
import games.strategy.triplea.delegate.AbstractMoveDelegate;
import games.strategy.triplea.delegate.Matches;
import games.strategy.triplea.delegate.TerritoryEffectHelper;
import games.strategy.util.CompositeMatch;
import games.strategy.util.CompositeMatchAnd;
import games.strategy.util.CompositeMatchOr;
import games.strategy.util.Match;
/**
* Pro AI matches.
*/
public class ProMatches {
public static Match<Territory> territoryCanLandAirUnits(final PlayerID player, final GameData data,
final boolean isCombatMove, final List<Territory> enemyTerritories, final List<Territory> alliedTerritories) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> match = new CompositeMatchOr<>(Matches.territoryIsInList(alliedTerritories),
new CompositeMatchAnd<>(Matches.airCanLandOnThisAlliedNonConqueredLandTerritory(player, data),
Matches.TerritoryIsPassableAndNotRestrictedAndOkByRelationships(player, data, isCombatMove, false,
false, true, true),
Matches.territoryIsInList(enemyTerritories).invert()));
return match.match(t);
}
};
}
public static Match<Territory> territoryCanMoveAirUnits(final PlayerID player, final GameData data,
final boolean isCombatMove) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> match = new CompositeMatchAnd<>(Matches.territoryDoesNotCostMoneyToEnter(data),
Matches.TerritoryIsPassableAndNotRestrictedAndOkByRelationships(player, data, isCombatMove, false, false,
true, false));
return match.match(t);
}
};
}
public static Match<Territory> territoryCanPotentiallyMoveAirUnits(final PlayerID player, final GameData data,
final boolean isCombatMove) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> match = new CompositeMatchAnd<>(Matches.territoryDoesNotCostMoneyToEnter(data),
Matches.TerritoryIsPassableAndNotRestricted(player, data));
return match.match(t);
}
};
}
public static Match<Territory> territoryCanMoveAirUnitsAndNoAA(final PlayerID player, final GameData data,
final boolean isCombatMove) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> match =
new CompositeMatchAnd<>(ProMatches.territoryCanMoveAirUnits(player, data, isCombatMove),
Matches.territoryHasEnemyAAforAnything(player, data).invert());
return match.match(t);
}
};
}
public static Match<Territory> territoryCanMoveSpecificLandUnit(final PlayerID player, final GameData data,
final boolean isCombatMove, final Unit u) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> territoryMatch = new CompositeMatchAnd<>(Matches.territoryDoesNotCostMoneyToEnter(data),
Matches.TerritoryIsPassableAndNotRestrictedAndOkByRelationships(player, data, isCombatMove, true, false,
false, false));
final Match<Unit> unitMatch =
Matches.unitIsOfTypes(TerritoryEffectHelper.getUnitTypesForUnitsNotAllowedIntoTerritory(t)).invert();
return territoryMatch.match(t) && unitMatch.match(u);
}
};
}
public static Match<Territory> territoryCanPotentiallyMoveSpecificLandUnit(final PlayerID player, final GameData data,
final boolean isCombatMove, final Unit u) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> territoryMatch = new CompositeMatchAnd<>(Matches.territoryDoesNotCostMoneyToEnter(data),
Matches.TerritoryIsPassableAndNotRestricted(player, data));
final Match<Unit> unitMatch =
Matches.unitIsOfTypes(TerritoryEffectHelper.getUnitTypesForUnitsNotAllowedIntoTerritory(t)).invert();
return territoryMatch.match(t) && unitMatch.match(u);
}
};
}
public static Match<Territory> territoryCanMoveLandUnits(final PlayerID player, final GameData data,
final boolean isCombatMove) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> match = new CompositeMatchAnd<>(Matches.territoryDoesNotCostMoneyToEnter(data),
Matches.TerritoryIsPassableAndNotRestrictedAndOkByRelationships(player, data, isCombatMove, true, false,
false, false));
return match.match(t);
}
};
}
public static Match<Territory> territoryCanPotentiallyMoveLandUnits(final PlayerID player, final GameData data,
final boolean isCombatMove) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> match = new CompositeMatchAnd<>(Matches.TerritoryIsLand,
Matches.territoryDoesNotCostMoneyToEnter(data), Matches.TerritoryIsPassableAndNotRestricted(player, data));
return match.match(t);
}
};
}
public static Match<Territory> territoryCanMoveLandUnitsAndIsAllied(final PlayerID player, final GameData data) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> match = new CompositeMatchAnd<>(Matches.isTerritoryAllied(player, data),
territoryCanMoveLandUnits(player, data, false));
return match.match(t);
}
};
}
public static Match<Territory> territoryCanMoveLandUnitsThrough(final PlayerID player, final GameData data,
final Unit u, final Territory startTerritory, final boolean isCombatMove,
final List<Territory> enemyTerritories) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
Match<Territory> match =
new CompositeMatchAnd<>(ProMatches.territoryCanMoveSpecificLandUnit(player, data, isCombatMove, u),
Matches.isTerritoryAllied(player, data), Matches.territoryHasNoEnemyUnits(player, data),
Matches.territoryIsInList(enemyTerritories).invert());
if (isCombatMove && Matches.UnitCanBlitz.match(u) && TerritoryEffectHelper.unitKeepsBlitz(u, startTerritory)) {
final Match<Territory> alliedWithNoEnemiesMatch = new CompositeMatchAnd<>(
Matches.isTerritoryAllied(player, data), Matches.territoryHasNoEnemyUnits(player, data));
final Match<Territory> alliedOrBlitzableMatch =
new CompositeMatchOr<>(alliedWithNoEnemiesMatch, territoryIsBlitzable(player, data, u));
match = new CompositeMatchAnd<>(ProMatches.territoryCanMoveSpecificLandUnit(player, data, isCombatMove, u),
alliedOrBlitzableMatch, Matches.territoryIsInList(enemyTerritories).invert());
}
return match.match(t);
}
};
}
public static Match<Territory> territoryCanMoveLandUnitsThroughIgnoreEnemyUnits(final PlayerID player,
final GameData data, final Unit u, final Territory startTerritory, final boolean isCombatMove,
final List<Territory> blockedTerritories, final List<Territory> clearedTerritories) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
Match<Territory> alliedMatch = new CompositeMatchOr<>(Matches.isTerritoryAllied(player, data),
Matches.territoryIsInList(clearedTerritories));
if (isCombatMove && Matches.UnitCanBlitz.match(u) && TerritoryEffectHelper.unitKeepsBlitz(u, startTerritory)) {
alliedMatch = new CompositeMatchOr<>(Matches.isTerritoryAllied(player, data),
Matches.territoryIsInList(clearedTerritories), territoryIsBlitzable(player, data, u));
}
final Match<Territory> match =
new CompositeMatchAnd<>(ProMatches.territoryCanMoveSpecificLandUnit(player, data, isCombatMove, u),
alliedMatch, Matches.territoryIsInList(blockedTerritories).invert());
return match.match(t);
}
};
}
private static Match<Territory> territoryIsBlitzable(final PlayerID player, final GameData data, final Unit u) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
return Matches.TerritoryIsBlitzable(player, data).match(t) && TerritoryEffectHelper.unitKeepsBlitz(u, t);
}
};
}
public static Match<Territory> territoryCanMoveSeaUnits(final PlayerID player, final GameData data,
final boolean isCombatMove) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final boolean navalMayNotNonComIntoControlled =
Properties.getWW2V2(data) || Properties.getNavalUnitsMayNotNonCombatMoveIntoControlledSeaZones(data);
if (!isCombatMove && navalMayNotNonComIntoControlled
&& Matches.isTerritoryEnemyAndNotUnownedWater(player, data).match(t)) {
return false;
}
final Match<Territory> match = new CompositeMatchAnd<>(Matches.territoryDoesNotCostMoneyToEnter(data),
Matches.TerritoryIsPassableAndNotRestrictedAndOkByRelationships(player, data, isCombatMove, false, true,
false, false));
return match.match(t);
}
};
}
public static Match<Territory> territoryCanMoveSeaUnitsThrough(final PlayerID player, final GameData data,
final boolean isCombatMove) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> match = new CompositeMatchAnd<>(territoryCanMoveSeaUnits(player, data, isCombatMove),
territoryHasOnlyIgnoredUnits(player, data));
return match.match(t);
}
};
}
public static Match<Territory> territoryCanMoveSeaUnitsAndNotInList(final PlayerID player, final GameData data,
final boolean isCombatMove, final List<Territory> notTerritories) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> match = new CompositeMatchAnd<>(territoryCanMoveSeaUnits(player, data, isCombatMove),
Matches.territoryIsNotInList(notTerritories));
return match.match(t);
}
};
}
public static Match<Territory> territoryCanMoveSeaUnitsThroughOrClearedAndNotInList(final PlayerID player,
final GameData data, final boolean isCombatMove, final List<Territory> clearedTerritories,
final List<Territory> notTerritories) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> onlyIgnoredOrClearedMatch = new CompositeMatchOr<>(
territoryHasOnlyIgnoredUnits(player, data), Matches.territoryIsInList(clearedTerritories));
final Match<Territory> match = new CompositeMatchAnd<>(territoryCanMoveSeaUnits(player, data, isCombatMove),
onlyIgnoredOrClearedMatch, Matches.territoryIsNotInList(notTerritories));
return match.match(t);
}
};
}
private static Match<Territory> territoryHasOnlyIgnoredUnits(final PlayerID player, final GameData data) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final CompositeMatch<Unit> subOnly = new CompositeMatchOr<>(Matches.UnitIsInfrastructure, Matches.UnitIsSub,
Matches.enemyUnit(player, data).invert());
return (Properties.getIgnoreSubInMovement(data) && t.getUnits().allMatch(subOnly))
|| Matches.territoryHasNoEnemyUnits(player, data).match(t);
}
};
}
public static Match<Territory> territoryHasEnemyUnitsOrCantBeHeld(final PlayerID player, final GameData data,
final List<Territory> territoriesThatCantBeHeld) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> match = new CompositeMatchOr<>(Matches.territoryHasEnemyUnits(player, data),
Matches.territoryIsInList(territoriesThatCantBeHeld));
return match.match(t);
}
};
}
public static Match<Territory> territoryHasPotentialEnemyUnits(final PlayerID player, final GameData data,
final List<PlayerID> players) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> match = new CompositeMatchOr<>(Matches.territoryHasEnemyUnits(player, data),
Matches.territoryHasUnitsThatMatch(Matches.unitOwnedBy(players)));
return match.match(t);
}
};
}
public static Match<Territory> territoryHasNoEnemyUnitsOrCleared(final PlayerID player, final GameData data,
final List<Territory> clearedTerritories) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> match = new CompositeMatchOr<>(Matches.territoryHasNoEnemyUnits(player, data),
Matches.territoryIsInList(clearedTerritories));
return match.match(t);
}
};
}
public static Match<Territory> territoryIsEnemyOrHasEnemyUnitsOrCantBeHeld(final PlayerID player, final GameData data,
final List<Territory> territoriesThatCantBeHeld) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> match = new CompositeMatchOr<>(Matches.isTerritoryEnemyAndNotUnownedWater(player, data),
Matches.territoryHasEnemyUnits(player, data), Matches.territoryIsInList(territoriesThatCantBeHeld));
return match.match(t);
}
};
}
public static Match<Territory> territoryHasInfraFactoryAndIsLand(final PlayerID player) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Unit> infraFactoryMatch =
new CompositeMatchAnd<>(Matches.UnitCanProduceUnits, Matches.UnitIsInfrastructure);
final Match<Territory> match =
new CompositeMatchAnd<>(Matches.TerritoryIsLand, Matches.territoryHasUnitsThatMatch(infraFactoryMatch));
return match.match(t);
}
};
}
public static Match<Territory> territoryHasInfraFactoryAndIsEnemyLand(final PlayerID player, final GameData data) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> match =
new CompositeMatchAnd<>(territoryHasInfraFactoryAndIsLand(player), Matches.isTerritoryEnemy(player, data));
return match.match(t);
}
};
}
public static Match<Territory> territoryHasInfraFactoryAndIsOwnedByPlayersOrCantBeHeld(final PlayerID player,
final GameData data, final List<PlayerID> players, final List<Territory> territoriesThatCantBeHeld) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> ownedAndCantBeHeld = new CompositeMatchAnd<>(Matches.isTerritoryOwnedBy(player),
Matches.territoryIsInList(territoriesThatCantBeHeld));
final Match<Territory> enemyOrOwnedCantBeHeld =
new CompositeMatchOr<>(Matches.isTerritoryOwnedBy(players), ownedAndCantBeHeld);
final Match<Territory> match =
new CompositeMatchAnd<>(territoryHasInfraFactoryAndIsLand(player), enemyOrOwnedCantBeHeld);
return match.match(t);
}
};
}
public static Match<Territory> territoryHasInfraFactoryAndIsNotConqueredOwnedLand(final PlayerID player,
final GameData data) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> match = new CompositeMatchAnd<>(territoryIsNotConqueredOwnedLand(player, data),
territoryHasInfraFactoryAndIsOwnedLand(player));
return match.match(t);
}
};
}
public static Match<Territory> territoryHasNonMobileInfraFactoryAndIsNotConqueredOwnedLand(final PlayerID player,
final GameData data) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> match = new CompositeMatchAnd<>(territoryHasNonMobileInfraFactory(),
territoryHasInfraFactoryAndIsNotConqueredOwnedLand(player, data));
return match.match(t);
}
};
}
private static Match<Territory> territoryHasNonMobileInfraFactory() {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Unit> nonMobileInfraFactoryMatch = new CompositeMatchAnd<>(Matches.UnitCanProduceUnits,
Matches.UnitIsInfrastructure, Matches.unitHasMovementLeft.invert());
final Match<Territory> match = Matches.territoryHasUnitsThatMatch(nonMobileInfraFactoryMatch);
return match.match(t);
}
};
}
public static Match<Territory> territoryHasInfraFactoryAndIsOwnedLand(final PlayerID player) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Unit> infraFactoryMatch = new CompositeMatchAnd<>(Matches.unitIsOwnedBy(player),
Matches.UnitCanProduceUnits, Matches.UnitIsInfrastructure);
final Match<Territory> match = new CompositeMatchAnd<>(Matches.isTerritoryOwnedBy(player),
Matches.TerritoryIsLand, Matches.territoryHasUnitsThatMatch(infraFactoryMatch));
return match.match(t);
}
};
}
public static Match<Territory> territoryHasInfraFactoryAndIsAlliedLand(final PlayerID player, final GameData data) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Unit> infraFactoryMatch =
new CompositeMatchAnd<>(Matches.UnitCanProduceUnits, Matches.UnitIsInfrastructure);
final Match<Territory> match = new CompositeMatchAnd<>(Matches.isTerritoryAllied(player, data),
Matches.TerritoryIsLand, Matches.territoryHasUnitsThatMatch(infraFactoryMatch));
return match.match(t);
}
};
}
public static Match<Territory> territoryHasInfraFactoryAndIsOwnedLandAdjacentToSea(final PlayerID player,
final GameData data) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> match = new CompositeMatchAnd<>(territoryHasInfraFactoryAndIsOwnedLand(player),
Matches.territoryHasNeighborMatching(data, Matches.TerritoryIsWater));
return match.match(t);
}
};
}
public static Match<Territory> territoryHasNoInfraFactoryAndIsNotConqueredOwnedLand(final PlayerID player,
final GameData data) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> match = new CompositeMatchAnd<>(territoryIsNotConqueredOwnedLand(player, data),
territoryHasInfraFactoryAndIsOwnedLand(player).invert());
return match.match(t);
}
};
}
public static Match<Territory> territoryHasNeighborOwnedByAndHasLandUnit(final GameData data, final PlayerID player,
final List<PlayerID> players) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> territoryMatch = new CompositeMatchAnd<>(Matches.isTerritoryOwnedBy(players),
Matches.territoryHasUnitsThatMatch(Matches.UnitIsLand));
final Match<Territory> match = Matches.territoryHasNeighborMatching(data, territoryMatch);
return match.match(t);
}
};
}
public static Match<Territory> territoryIsAlliedLandAndHasNoEnemyNeighbors(final PlayerID player,
final GameData data) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> alliedLand = new CompositeMatchAnd<>(territoryCanMoveLandUnits(player, data, false),
Matches.isTerritoryAllied(player, data));
final Match<Territory> hasNoEnemyNeighbors = Matches
.territoryHasNeighborMatching(data, ProMatches.territoryIsEnemyNotNeutralLand(player, data)).invert();
final Match<Territory> match = new CompositeMatchAnd<>(alliedLand, hasNoEnemyNeighbors);
return match.match(t);
}
};
}
public static Match<Territory> territoryIsEnemyLand(final PlayerID player, final GameData data) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> match = new CompositeMatchAnd<>(territoryCanMoveLandUnits(player, data, false),
Matches.isTerritoryEnemy(player, data));
return match.match(t);
}
};
}
public static Match<Territory> territoryIsEnemyNotNeutralLand(final PlayerID player, final GameData data) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> match =
new CompositeMatchAnd<>(territoryIsEnemyLand(player, data), Matches.TerritoryIsNeutralButNotWater.invert());
return match.match(t);
}
};
}
public static Match<Territory> territoryIsOrAdjacentToEnemyNotNeutralLand(final PlayerID player,
final GameData data) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> isMatch =
new CompositeMatchAnd<>(territoryIsEnemyLand(player, data), Matches.TerritoryIsNeutralButNotWater.invert());
final Match<Territory> adjacentMatch = new CompositeMatchAnd<>(territoryCanMoveLandUnits(player, data, false),
Matches.territoryHasNeighborMatching(data, isMatch));
final Match<Territory> match = new CompositeMatchOr<>(isMatch, adjacentMatch);
return match.match(t);
}
};
}
public static Match<Territory> territoryIsEnemyNotNeutralOrAllied(final PlayerID player, final GameData data) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> alliedLand =
new CompositeMatchAnd<>(Matches.TerritoryIsLand, Matches.isTerritoryAllied(player, data));
final Match<Territory> match = new CompositeMatchOr<>(territoryIsEnemyNotNeutralLand(player, data), alliedLand);
return match.match(t);
}
};
}
public static Match<Territory> territoryIsEnemyOrCantBeHeld(final PlayerID player, final GameData data,
final List<Territory> territoriesThatCantBeHeld) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> match = new CompositeMatchOr<>(Matches.isTerritoryEnemyAndNotUnownedWater(player, data),
Matches.territoryIsInList(territoriesThatCantBeHeld));
return match.match(t);
}
};
}
public static Match<Territory> territoryIsPotentialEnemy(final PlayerID player, final GameData data,
final List<PlayerID> players) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> match = new CompositeMatchOr<>(Matches.isTerritoryEnemyAndNotUnownedWater(player, data),
Matches.isTerritoryOwnedBy(players));
return match.match(t);
}
};
}
public static Match<Territory> territoryIsPotentialEnemyOrHasPotentialEnemyUnits(final PlayerID player,
final GameData data, final List<PlayerID> players) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> match = new CompositeMatchOr<>(territoryIsPotentialEnemy(player, data, players),
territoryHasPotentialEnemyUnits(player, data, players));
return match.match(t);
}
};
}
public static Match<Territory> territoryIsEnemyOrCantBeHeldAndIsAdjacentToMyLandUnits(final PlayerID player,
final GameData data, final List<Territory> territoriesThatCantBeHeld) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Unit> myUnitIsLand = new CompositeMatchAnd<>(Matches.unitIsOwnedBy(player), Matches.UnitIsLand);
final Match<Territory> territoryIsLandAndAdjacentToMyLandUnits =
new CompositeMatchAnd<>(Matches.TerritoryIsLand,
Matches.territoryHasNeighborMatching(data, Matches.territoryHasUnitsThatMatch(myUnitIsLand)));
final Match<Territory> match = new CompositeMatchAnd<>(territoryIsLandAndAdjacentToMyLandUnits,
territoryIsEnemyOrCantBeHeld(player, data, territoriesThatCantBeHeld));
return match.match(t);
}
};
}
public static Match<Territory> territoryIsNotConqueredAlliedLand(final PlayerID player, final GameData data) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
if (AbstractMoveDelegate.getBattleTracker(data).wasConquered(t)) {
return false;
}
final Match<Territory> match =
new CompositeMatchAnd<>(Matches.isTerritoryAllied(player, data), Matches.TerritoryIsLand);
return match.match(t);
}
};
}
public static Match<Territory> territoryIsNotConqueredOwnedLand(final PlayerID player, final GameData data) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
if (AbstractMoveDelegate.getBattleTracker(data).wasConquered(t)) {
return false;
}
final Match<Territory> match =
new CompositeMatchAnd<>(Matches.isTerritoryOwnedBy(player), Matches.TerritoryIsLand);
return match.match(t);
}
};
}
public static Match<Territory> territoryIsWaterAndAdjacentToOwnedFactory(final PlayerID player, final GameData data) {
return new Match<Territory>() {
@Override
public boolean match(final Territory t) {
final Match<Territory> hasOwnedFactoryNeighbor =
Matches.territoryHasNeighborMatching(data, ProMatches.territoryHasInfraFactoryAndIsOwnedLand(player));
final Match<Territory> match =
new CompositeMatchAnd<>(hasOwnedFactoryNeighbor, ProMatches.territoryCanMoveSeaUnits(player, data, true));
return match.match(t);
}
};
}
public static Match<Unit> unitCanBeMovedAndIsOwned(final PlayerID player) {
return new Match<Unit>() {
@Override
public boolean match(final Unit u) {
final Match<Unit> match = new CompositeMatchAnd<>(Matches.unitIsOwnedBy(player), Matches.unitHasMovementLeft);
return match.match(u);
}
};
}
public static Match<Unit> unitCanBeMovedAndIsOwnedAir(final PlayerID player, final boolean isCombatMove) {
return new Match<Unit>() {
@Override
public boolean match(final Unit u) {
if (isCombatMove && Matches.UnitCanNotMoveDuringCombatMove.match(u)) {
return false;
}
final Match<Unit> match = new CompositeMatchAnd<>(unitCanBeMovedAndIsOwned(player), Matches.UnitIsAir);
return match.match(u);
}
};
}
public static Match<Unit> unitCanBeMovedAndIsOwnedLand(final PlayerID player, final boolean isCombatMove) {
return new Match<Unit>() {
@Override
public boolean match(final Unit u) {
if (isCombatMove && Matches.UnitCanNotMoveDuringCombatMove.match(u)) {
return false;
}
final Match<Unit> match = new CompositeMatchAnd<>(unitCanBeMovedAndIsOwned(player), Matches.UnitIsLand,
Matches.unitIsBeingTransported().invert());
return match.match(u);
}
};
}
public static Match<Unit> unitCanBeMovedAndIsOwnedSea(final PlayerID player, final boolean isCombatMove) {
return new Match<Unit>() {
@Override
public boolean match(final Unit u) {
if (isCombatMove && Matches.UnitCanNotMoveDuringCombatMove.match(u)) {
return false;
}
final Match<Unit> match = new CompositeMatchAnd<>(unitCanBeMovedAndIsOwned(player), Matches.UnitIsSea);
return match.match(u);
}
};
}
public static Match<Unit> unitCanBeMovedAndIsOwnedTransport(final PlayerID player, final boolean isCombatMove) {
return new Match<Unit>() {
@Override
public boolean match(final Unit u) {
if (isCombatMove && Matches.UnitCanNotMoveDuringCombatMove.match(u)) {
return false;
}
final Match<Unit> match = new CompositeMatchAnd<>(unitCanBeMovedAndIsOwned(player), Matches.UnitIsTransport);
return match.match(u);
}
};
}
public static Match<Unit> unitCanBeMovedAndIsOwnedBombard(final PlayerID player) {
return new Match<Unit>() {
@Override
public boolean match(final Unit u) {
if (Matches.UnitCanNotMoveDuringCombatMove.match(u)) {
return false;
}
final Match<Unit> match =
new CompositeMatchAnd<>(unitCanBeMovedAndIsOwned(player), Matches.unitCanBombard(player));
return match.match(u);
}
};
}
public static Match<Unit> unitCanBeMovedAndIsOwnedNonCombatInfra(final PlayerID player) {
return new Match<Unit>() {
@Override
public boolean match(final Unit u) {
final Match<Unit> match = new CompositeMatchAnd<>(unitCanBeMovedAndIsOwned(player),
Matches.UnitCanNotMoveDuringCombatMove, Matches.UnitIsInfrastructure);
return match.match(u);
}
};
}
public static Match<Unit> unitCantBeMovedAndIsAlliedDefender(final PlayerID player, final GameData data,
final Territory t) {
return new Match<Unit>() {
@Override
public boolean match(final Unit u) {
final Match<Unit> myUnitHasNoMovementMatch =
new CompositeMatchAnd<>(Matches.unitIsOwnedBy(player), Matches.unitHasMovementLeft.invert());
final Match<Unit> alliedUnitMatch =
new CompositeMatchAnd<>(Matches.unitIsOwnedBy(player).invert(), Matches.isUnitAllied(player, data),
Matches.unitIsBeingTransportedByOrIsDependentOfSomeUnitInThisList(t.getUnits().getUnits(), null, player,
data, false).invert());
final Match<Unit> match = new CompositeMatchOr<>(myUnitHasNoMovementMatch, alliedUnitMatch);
return match.match(u);
}
};
}
public static Match<Unit> unitCantBeMovedAndIsAlliedDefenderAndNotInfra(final PlayerID player, final GameData data,
final Territory t) {
return new Match<Unit>() {
@Override
public boolean match(final Unit u) {
final Match<Unit> match = new CompositeMatchAnd<>(unitCantBeMovedAndIsAlliedDefender(player, data, t),
Matches.UnitIsNotInfrastructure);
return match.match(u);
}
};
}
public static Match<Unit> unitIsAlliedLandAndNotInfra(final PlayerID player, final GameData data) {
return new Match<Unit>() {
@Override
public boolean match(final Unit u) {
final Match<Unit> match = new CompositeMatchAnd<>(Matches.UnitIsLand, Matches.isUnitAllied(player, data),
Matches.UnitIsNotInfrastructure);
return match.match(u);
}
};
}
public static Match<Unit> unitIsAlliedNotOwned(final PlayerID player, final GameData data) {
return new Match<Unit>() {
@Override
public boolean match(final Unit u) {
final Match<Unit> match =
new CompositeMatchAnd<>(Matches.unitIsOwnedBy(player).invert(), Matches.isUnitAllied(player, data));
return match.match(u);
}
};
}
public static Match<Unit> unitIsAlliedNotOwnedAir(final PlayerID player, final GameData data) {
return new Match<Unit>() {
@Override
public boolean match(final Unit u) {
final Match<Unit> match = new CompositeMatchAnd<>(unitIsAlliedNotOwned(player, data), Matches.UnitIsAir);
return match.match(u);
}
};
}
public static Match<Unit> unitIsAlliedAir(final PlayerID player, final GameData data) {
return new Match<Unit>() {
@Override
public boolean match(final Unit u) {
final Match<Unit> match = new CompositeMatchAnd<>(Matches.isUnitAllied(player, data), Matches.UnitIsAir);
return match.match(u);
}
};
}
public static Match<Unit> unitIsEnemyAir(final PlayerID player, final GameData data) {
return new Match<Unit>() {
@Override
public boolean match(final Unit u) {
final Match<Unit> match = new CompositeMatchAnd<>(Matches.enemyUnit(player, data), Matches.UnitIsAir);
return match.match(u);
}
};
}
public static Match<Unit> unitIsEnemyAndNotAA(final PlayerID player, final GameData data) {
return new Match<Unit>() {
@Override
public boolean match(final Unit u) {
final Match<Unit> match =
new CompositeMatchAnd<>(Matches.enemyUnit(player, data), Matches.UnitIsAAforAnything.invert());
return match.match(u);
}
};
}
public static Match<Unit> unitIsEnemyAndNotInfa(final PlayerID player, final GameData data) {
return new Match<Unit>() {
@Override
public boolean match(final Unit u) {
final Match<Unit> match =
new CompositeMatchAnd<>(Matches.enemyUnit(player, data), Matches.UnitIsNotInfrastructure);
return match.match(u);
}
};
}
public static Match<Unit> unitIsEnemyNotLand(final PlayerID player, final GameData data) {
return new Match<Unit>() {
@Override
public boolean match(final Unit u) {
final Match<Unit> match = new CompositeMatchAnd<>(Matches.enemyUnit(player, data), Matches.UnitIsNotLand);
return match.match(u);
}
};
}
public static Match<Unit> unitIsEnemyNotNeutral(final PlayerID player, final GameData data) {
return new Match<Unit>() {
@Override
public boolean match(final Unit u) {
final Match<Unit> match = new CompositeMatchAnd<>(Matches.enemyUnit(player, data), unitIsNeutral().invert());
return match.match(u);
}
};
}
private static Match<Unit> unitIsNeutral() {
return new Match<Unit>() {
@Override
public boolean match(final Unit u) {
if (u.getOwner().isNull()) {
return true;
}
return false;
}
};
}
public static Match<Unit> unitIsOwnedAir(final PlayerID player) {
return new Match<Unit>() {
@Override
public boolean match(final Unit u) {
final Match<Unit> match = new CompositeMatchAnd<>(Matches.unitOwnedBy(player), Matches.UnitIsAir);
return match.match(u);
}
};
}
public static Match<Unit> unitIsOwnedAndMatchesTypeAndIsTransporting(final PlayerID player, final UnitType unitType) {
return new Match<Unit>() {
@Override
public boolean match(final Unit u) {
final Match<Unit> match = new CompositeMatchAnd<>(Matches.unitIsOwnedBy(player), Matches.unitIsOfType(unitType),
Matches.unitIsTransporting());
return match.match(u);
}
};
}
public static Match<Unit> unitIsOwnedAndMatchesTypeAndNotTransporting(final PlayerID player,
final UnitType unitType) {
return new Match<Unit>() {
@Override
public boolean match(final Unit u) {
final Match<Unit> match = new CompositeMatchAnd<>(Matches.unitIsOwnedBy(player), Matches.unitIsOfType(unitType),
Matches.unitIsTransporting().invert());
return match.match(u);
}
};
}
public static Match<Unit> UnitIsOwnedCarrier(final PlayerID player) {
return new Match<Unit>() {
@Override
public boolean match(final Unit u) {
final UnitAttachment ua = UnitAttachment.get(u.getType());
return ua.getCarrierCapacity() != -1 && Matches.unitIsOwnedBy(player).match(u);
}
};
}
public static Match<Unit> unitIsOwnedNotLand(final PlayerID player, final GameData data) {
return new Match<Unit>() {
@Override
public boolean match(final Unit u) {
final Match<Unit> match = new CompositeMatchAnd<>(Matches.UnitIsNotLand, Matches.unitIsOwnedBy(player));
return match.match(u);
}
};
}
public static Match<Unit> unitIsOwnedTransport(final PlayerID player) {
return new Match<Unit>() {
@Override
public boolean match(final Unit u) {
final Match<Unit> match = new CompositeMatchAnd<>(Matches.unitIsOwnedBy(player), Matches.UnitIsTransport);
return match.match(u);
}
};
}
public static Match<Unit> unitIsOwnedTransportableUnit(final PlayerID player) {
return new Match<Unit>() {
@Override
public boolean match(final Unit u) {
final Match<Unit> match =
new CompositeMatchAnd<>(Matches.unitIsOwnedBy(player), Matches.UnitCanBeTransported, Matches.UnitCanMove);
return match.match(u);
}
};
}
public static Match<Unit> unitIsOwnedCombatTransportableUnit(final PlayerID player) {
return new Match<Unit>() {
@Override
public boolean match(final Unit u) {
final Match<Unit> match = new CompositeMatchAnd<>(Matches.unitIsOwnedBy(player), Matches.UnitCanBeTransported,
Matches.UnitCanNotMoveDuringCombatMove.invert(), Matches.UnitCanMove);
return match.match(u);
}
};
}
public static Match<Unit> unitIsOwnedTransportableUnitAndCanBeLoaded(final PlayerID player,
final boolean isCombatMove) {
return new Match<Unit>() {
@Override
public boolean match(final Unit u) {
if (isCombatMove && Matches.UnitCanNotMoveDuringCombatMove.match(u)) {
return false;
}
final Match<Unit> match = new CompositeMatchAnd<>(unitIsOwnedTransportableUnit(player), Matches.unitHasNotMoved,
Matches.unitHasMovementLeft, Matches.unitIsBeingTransported().invert());
return match.match(u);
}
};
}
/**
* Check what units a territory can produce.
*
* @param t
* territory we are testing for required units
* @return whether the territory contains one of the required combos of units
*/
public static Match<Unit> unitWhichRequiresUnitsHasRequiredUnits(final PlayerID player, final Territory t) {
return new Match<Unit>() {
@Override
public boolean match(final Unit unitWhichRequiresUnits) {
if (!Matches.UnitRequiresUnitsOnCreation.match(unitWhichRequiresUnits)) {
return true;
}
final Collection<Unit> unitsAtStartOfTurnInProducer = t.getUnits().getUnits();
if (Matches.UnitWhichRequiresUnitsHasRequiredUnitsInList(unitsAtStartOfTurnInProducer)
.match(unitWhichRequiresUnits)) {
return true;
}
if (t.isWater() && Matches.UnitIsSea.match(unitWhichRequiresUnits)) {
for (final Territory neighbor : t.getData().getMap().getNeighbors(t, Matches.TerritoryIsLand)) {
final Collection<Unit> unitsAtStartOfTurnInCurrent = neighbor.getUnits().getUnits();
if (Matches.UnitWhichRequiresUnitsHasRequiredUnitsInList(unitsAtStartOfTurnInCurrent)
.match(unitWhichRequiresUnits)) {
return true;
}
}
}
return false;
}
};
}
}