use of games.strategy.util.Tuple in project triplea by triplea-game.
the class MustFightBattle method damagedChangeInto.
private void damagedChangeInto(final List<Unit> units, final IDelegateBridge bridge) {
final List<Unit> damagedUnits = CollectionUtils.getMatches(units, Matches.unitWhenHitPointsDamagedChangesInto().and(Matches.unitHasTakenSomeDamage()));
final CompositeChange changes = new CompositeChange();
final List<Unit> unitsToRemove = new ArrayList<>();
final List<Unit> unitsToAdd = new ArrayList<>();
for (final Unit unit : damagedUnits) {
final Map<Integer, Tuple<Boolean, UnitType>> map = UnitAttachment.get(unit.getType()).getWhenHitPointsDamagedChangesInto();
if (map.containsKey(unit.getHits())) {
final boolean translateAttributes = map.get(unit.getHits()).getFirst();
final UnitType unitType = map.get(unit.getHits()).getSecond();
final List<Unit> toAdd = unitType.create(1, unit.getOwner());
if (translateAttributes) {
final Change translate = TripleAUnit.translateAttributesToOtherUnits(unit, toAdd, m_battleSite);
changes.add(translate);
}
unitsToRemove.add(unit);
unitsToAdd.addAll(toAdd);
}
}
if (!unitsToRemove.isEmpty()) {
bridge.addChange(changes);
remove(unitsToRemove, bridge, m_battleSite, null);
final String transcriptText = MyFormatter.unitsToText(unitsToAdd) + " added in " + m_battleSite.getName();
bridge.getHistoryWriter().addChildToEvent(transcriptText, new ArrayList<>(unitsToAdd));
bridge.addChange(ChangeFactory.addUnits(m_battleSite, unitsToAdd));
bridge.addChange(ChangeFactory.markNoMovementChange(unitsToAdd));
units.addAll(unitsToAdd);
getDisplay(bridge).changedUnitsNotification(m_battleID, unitsToRemove.get(0).getOwner(), unitsToRemove, unitsToAdd, null);
}
}
use of games.strategy.util.Tuple in project triplea by triplea-game.
the class RandomStartDelegate method setupBoard.
private void setupBoard() {
final GameData data = getData();
final boolean randomTerritories = Properties.getTerritoriesAreAssignedRandomly(data);
final Predicate<Territory> pickableTerritoryMatch = getTerritoryPickableMatch();
final Predicate<PlayerID> playerCanPickMatch = getPlayerCanPickMatch();
final List<Territory> allPickableTerritories = CollectionUtils.getMatches(data.getMap().getTerritories(), pickableTerritoryMatch);
final List<PlayerID> playersCanPick = new ArrayList<>(CollectionUtils.getMatches(data.getPlayerList().getPlayers(), playerCanPickMatch));
// we need a main event
if (!playersCanPick.isEmpty()) {
bridge.getHistoryWriter().startEvent("Assigning Territories");
}
// for random:
final int[] hitRandom = (!randomTerritories ? new int[0] : bridge.getRandom(allPickableTerritories.size(), allPickableTerritories.size(), null, DiceType.ENGINE, "Picking random territories"));
int i = 0;
int pos = 0;
// divvy up territories
while (!allPickableTerritories.isEmpty() && !playersCanPick.isEmpty()) {
if (currentPickingPlayer == null || !playersCanPick.contains(currentPickingPlayer)) {
currentPickingPlayer = playersCanPick.get(0);
}
if (!Interruptibles.sleep(250)) {
return;
}
Territory picked;
if (randomTerritories) {
pos += hitRandom[i];
i++;
final IntegerMap<UnitType> costs = TuvUtils.getCostsForTuv(currentPickingPlayer, data);
final List<Unit> units = new ArrayList<>(currentPickingPlayer.getUnits().getUnits());
units.sort(Comparator.comparingInt(unit -> costs.getInt(unit.getType())));
final Set<Unit> unitsToPlace = new HashSet<>();
unitsToPlace.add(units.get(0));
picked = allPickableTerritories.get(pos % allPickableTerritories.size());
final CompositeChange change = new CompositeChange();
change.add(ChangeFactory.changeOwner(picked, currentPickingPlayer));
final Collection<Unit> factoryAndInfrastructure = CollectionUtils.getMatches(unitsToPlace, Matches.unitIsInfrastructure());
if (!factoryAndInfrastructure.isEmpty()) {
change.add(OriginalOwnerTracker.addOriginalOwnerChange(factoryAndInfrastructure, currentPickingPlayer));
}
change.add(ChangeFactory.removeUnits(currentPickingPlayer, unitsToPlace));
change.add(ChangeFactory.addUnits(picked, unitsToPlace));
bridge.getHistoryWriter().addChildToEvent(currentPickingPlayer.getName() + " receives territory " + picked.getName() + " with units " + MyFormatter.unitsToTextNoOwner(unitsToPlace), picked);
bridge.addChange(change);
} else {
Set<Unit> unitsToPlace;
while (true) {
final Tuple<Territory, Set<Unit>> pick = getRemotePlayer(currentPickingPlayer).pickTerritoryAndUnits(new ArrayList<>(allPickableTerritories), new ArrayList<>(currentPickingPlayer.getUnits().getUnits()), UNITS_PER_PICK);
picked = pick.getFirst();
unitsToPlace = pick.getSecond();
if (!allPickableTerritories.contains(picked) || !currentPickingPlayer.getUnits().getUnits().containsAll(unitsToPlace) || unitsToPlace.size() > UNITS_PER_PICK || (unitsToPlace.size() < UNITS_PER_PICK && unitsToPlace.size() < currentPickingPlayer.getUnits().getUnits().size())) {
getRemotePlayer(currentPickingPlayer).reportMessage("Chosen territory or units invalid!", "Chosen territory or units invalid!");
} else {
break;
}
}
final CompositeChange change = new CompositeChange();
change.add(ChangeFactory.changeOwner(picked, currentPickingPlayer));
final Collection<Unit> factoryAndInfrastructure = CollectionUtils.getMatches(unitsToPlace, Matches.unitIsInfrastructure());
if (!factoryAndInfrastructure.isEmpty()) {
change.add(OriginalOwnerTracker.addOriginalOwnerChange(factoryAndInfrastructure, currentPickingPlayer));
}
change.add(ChangeFactory.removeUnits(currentPickingPlayer, unitsToPlace));
change.add(ChangeFactory.addUnits(picked, unitsToPlace));
bridge.getHistoryWriter().addChildToEvent(currentPickingPlayer.getName() + " picks territory " + picked.getName() + " and places in it " + MyFormatter.unitsToTextNoOwner(unitsToPlace), unitsToPlace);
bridge.addChange(change);
}
allPickableTerritories.remove(picked);
final PlayerID lastPlayer = currentPickingPlayer;
currentPickingPlayer = getNextPlayer(playersCanPick, currentPickingPlayer);
if (!playerCanPickMatch.test(lastPlayer)) {
playersCanPick.remove(lastPlayer);
}
if (playersCanPick.isEmpty()) {
currentPickingPlayer = null;
}
}
// place any remaining units
while (!playersCanPick.isEmpty()) {
if (currentPickingPlayer == null || !playersCanPick.contains(currentPickingPlayer)) {
currentPickingPlayer = playersCanPick.get(0);
}
final List<Territory> territoriesToPickFrom = data.getMap().getTerritoriesOwnedBy(currentPickingPlayer);
Territory picked;
Set<Unit> unitsToPlace;
while (true) {
final Tuple<Territory, Set<Unit>> pick = getRemotePlayer(currentPickingPlayer).pickTerritoryAndUnits(new ArrayList<>(territoriesToPickFrom), new ArrayList<>(currentPickingPlayer.getUnits().getUnits()), UNITS_PER_PICK);
picked = pick.getFirst();
unitsToPlace = pick.getSecond();
if (!territoriesToPickFrom.contains(picked) || !currentPickingPlayer.getUnits().getUnits().containsAll(unitsToPlace) || unitsToPlace.size() > UNITS_PER_PICK || (unitsToPlace.size() < UNITS_PER_PICK && unitsToPlace.size() < currentPickingPlayer.getUnits().getUnits().size())) {
getRemotePlayer(currentPickingPlayer).reportMessage("Chosen territory or units invalid!", "Chosen territory or units invalid!");
} else {
break;
}
}
final CompositeChange change = new CompositeChange();
final Collection<Unit> factoryAndInfrastructure = CollectionUtils.getMatches(unitsToPlace, Matches.unitIsInfrastructure());
if (!factoryAndInfrastructure.isEmpty()) {
change.add(OriginalOwnerTracker.addOriginalOwnerChange(factoryAndInfrastructure, currentPickingPlayer));
}
change.add(ChangeFactory.removeUnits(currentPickingPlayer, unitsToPlace));
change.add(ChangeFactory.addUnits(picked, unitsToPlace));
bridge.getHistoryWriter().addChildToEvent(currentPickingPlayer.getName() + " places " + MyFormatter.unitsToTextNoOwner(unitsToPlace) + " in territory " + picked.getName(), unitsToPlace);
bridge.addChange(change);
final PlayerID lastPlayer = currentPickingPlayer;
currentPickingPlayer = getNextPlayer(playersCanPick, currentPickingPlayer);
if (!playerCanPickMatch.test(lastPlayer)) {
playersCanPick.remove(lastPlayer);
}
if (playersCanPick.isEmpty()) {
currentPickingPlayer = null;
}
}
}
use of games.strategy.util.Tuple in project triplea by triplea-game.
the class OrderOfLossesInputPanel method getUnitListByOrderOfLoss.
/**
* Returns units in the same ordering as the 'order of loss' string passed in.
*/
public static List<Unit> getUnitListByOrderOfLoss(final String ool, final Collection<Unit> units, final GameData data) {
if (ool == null || ool.trim().length() == 0) {
return null;
}
final String[] sections;
if (ool.contains(OOL_SEPARATOR)) {
sections = ool.trim().split(OOL_SEPARATOR_REGEX);
} else {
sections = new String[1];
sections[0] = ool.trim();
}
final List<Tuple<Integer, UnitType>> map = new ArrayList<>();
for (final String section : sections) {
if (section.length() == 0) {
continue;
}
final String[] amountThenType = section.split(OOL_AMOUNT_DESCRIPTOR_REGEX);
final int amount = amountThenType[0].equals(OOL_ALL) ? Integer.MAX_VALUE : Integer.parseInt(amountThenType[0]);
final UnitType type = data.getUnitTypeList().getUnitType(amountThenType[1]);
map.add(Tuple.of(amount, type));
}
Collections.reverse(map);
final Set<Unit> unitsLeft = new HashSet<>(units);
final List<Unit> order = new ArrayList<>();
for (final Tuple<Integer, UnitType> section : map) {
final List<Unit> unitsOfType = CollectionUtils.getNMatches(unitsLeft, section.getFirst(), Matches.unitIsOfType(section.getSecond()));
order.addAll(unitsOfType);
unitsLeft.removeAll(unitsOfType);
}
Collections.reverse(order);
return order;
}
use of games.strategy.util.Tuple in project triplea by triplea-game.
the class BattleDelegate method doScrambling.
private void doScrambling() {
// first, figure out all the territories where scrambling units could scramble to
// then ask the defending player if they wish to scramble units there, and actually move the units there
final GameData data = getData();
if (!Properties.getScrambleRulesInEffect(data)) {
return;
}
final boolean fromIslandOnly = Properties.getScrambleFromIslandOnly(data);
final boolean toSeaOnly = Properties.getScrambleToSeaOnly(data);
final boolean toAnyAmphibious = Properties.getScrambleToAnyAmphibiousAssault(data);
final boolean toSbr = Properties.getCanScrambleIntoAirBattles(data);
int maxScrambleDistance = 0;
for (final UnitType unitType : data.getUnitTypeList()) {
final UnitAttachment ua = UnitAttachment.get(unitType);
if (ua.getCanScramble() && maxScrambleDistance < ua.getMaxScrambleDistance()) {
maxScrambleDistance = ua.getMaxScrambleDistance();
}
}
final Predicate<Unit> airbasesCanScramble = Matches.unitIsEnemyOf(data, player).and(Matches.unitIsAirBase()).and(Matches.unitIsNotDisabled()).and(Matches.unitIsBeingTransported().negate());
final Predicate<Territory> canScramble = PredicateBuilder.of(Matches.territoryIsWater().or(Matches.isTerritoryEnemy(player, data))).and(Matches.territoryHasUnitsThatMatch(Matches.unitCanScramble().and(Matches.unitIsEnemyOf(data, player)).and(Matches.unitIsNotDisabled()))).and(Matches.territoryHasUnitsThatMatch(airbasesCanScramble)).andIf(fromIslandOnly, Matches.territoryIsIsland()).build();
final Set<Territory> territoriesWithBattles = battleTracker.getPendingBattleSites().getNormalBattlesIncludingAirBattles();
if (toSbr) {
territoriesWithBattles.addAll(battleTracker.getPendingBattleSites().getStrategicBombingRaidsIncludingAirBattles());
}
final Set<Territory> territoriesWithBattlesWater = new HashSet<>(CollectionUtils.getMatches(territoriesWithBattles, Matches.territoryIsWater()));
final Set<Territory> territoriesWithBattlesLand = new HashSet<>(CollectionUtils.getMatches(territoriesWithBattles, Matches.territoryIsLand()));
final Map<Territory, Set<Territory>> scrambleTerrs = new HashMap<>();
for (final Territory battleTerr : territoriesWithBattlesWater) {
final Set<Territory> canScrambleFrom = new HashSet<>(CollectionUtils.getMatches(data.getMap().getNeighbors(battleTerr, maxScrambleDistance), canScramble));
if (!canScrambleFrom.isEmpty()) {
scrambleTerrs.put(battleTerr, canScrambleFrom);
}
}
for (final Territory battleTerr : territoriesWithBattlesLand) {
if (!toSeaOnly) {
final Set<Territory> canScrambleFrom = new HashSet<>(CollectionUtils.getMatches(data.getMap().getNeighbors(battleTerr, maxScrambleDistance), canScramble));
if (!canScrambleFrom.isEmpty()) {
scrambleTerrs.put(battleTerr, canScrambleFrom);
}
}
final IBattle battle = battleTracker.getPendingBattle(battleTerr, false, BattleType.NORMAL);
// it.
if (battle != null && battle.isAmphibious() && battle instanceof DependentBattle) {
final Collection<Territory> amphibFromTerrs = ((DependentBattle) battle).getAmphibiousAttackTerritories();
amphibFromTerrs.removeAll(territoriesWithBattlesWater);
for (final Territory amphibFrom : amphibFromTerrs) {
final Set<Territory> canScrambleFrom = scrambleTerrs.getOrDefault(amphibFrom, new HashSet<>());
if (toAnyAmphibious) {
canScrambleFrom.addAll(CollectionUtils.getMatches(data.getMap().getNeighbors(amphibFrom, maxScrambleDistance), canScramble));
} else if (canScramble.test(battleTerr)) {
canScrambleFrom.add(battleTerr);
}
if (!canScrambleFrom.isEmpty()) {
scrambleTerrs.put(amphibFrom, canScrambleFrom);
}
}
}
}
// now scrambleTerrs is a list of places we can scramble from
if (scrambleTerrs.isEmpty()) {
return;
}
final Map<Tuple<Territory, PlayerID>, Collection<Map<Territory, Tuple<Collection<Unit>, Collection<Unit>>>>> scramblersByTerritoryPlayer = new HashMap<>();
for (final Territory to : scrambleTerrs.keySet()) {
// find who we should ask
PlayerID defender = null;
if (battleTracker.hasPendingBattle(to, false)) {
defender = AbstractBattle.findDefender(to, player, data);
}
final Map<Territory, Tuple<Collection<Unit>, Collection<Unit>>> scramblers = new HashMap<>();
for (final Territory from : scrambleTerrs.get(to)) {
if (defender == null) {
defender = AbstractBattle.findDefender(from, player, data);
}
// find how many is the max this territory can scramble
final Collection<Unit> airbases = from.getUnits().getMatches(airbasesCanScramble);
final int maxCanScramble = getMaxScrambleCount(airbases);
final Route toBattleRoute = data.getMap().getRoute_IgnoreEnd(from, to, Matches.territoryIsNotImpassable());
final Collection<Unit> canScrambleAir = from.getUnits().getMatches(Matches.unitIsEnemyOf(data, player).and(Matches.unitCanScramble()).and(Matches.unitIsNotDisabled()).and(Matches.unitWasScrambled().negate()).and(Matches.unitCanScrambleOnRouteDistance(toBattleRoute)));
if (maxCanScramble > 0 && !canScrambleAir.isEmpty()) {
scramblers.put(from, Tuple.of(airbases, canScrambleAir));
}
}
if (defender == null || scramblers.isEmpty()) {
continue;
}
final Tuple<Territory, PlayerID> terrPlayer = Tuple.of(to, defender);
final Collection<Map<Territory, Tuple<Collection<Unit>, Collection<Unit>>>> tempScrambleList = scramblersByTerritoryPlayer.getOrDefault(terrPlayer, new ArrayList<>());
tempScrambleList.add(scramblers);
scramblersByTerritoryPlayer.put(terrPlayer, tempScrambleList);
}
// now scramble them
for (final Tuple<Territory, PlayerID> terrPlayer : scramblersByTerritoryPlayer.keySet()) {
final Territory to = terrPlayer.getFirst();
final PlayerID defender = terrPlayer.getSecond();
if (defender == null || defender.isNull()) {
continue;
}
boolean scrambledHere = false;
for (final Map<Territory, Tuple<Collection<Unit>, Collection<Unit>>> scramblers : scramblersByTerritoryPlayer.get(terrPlayer)) {
// verify that we didn't already scramble any of these units
final Iterator<Territory> territoryIter = scramblers.keySet().iterator();
while (territoryIter.hasNext()) {
final Territory t = territoryIter.next();
scramblers.get(t).getSecond().retainAll(t.getUnits());
if (scramblers.get(t).getSecond().isEmpty()) {
territoryIter.remove();
}
}
if (scramblers.isEmpty()) {
continue;
}
final Map<Territory, Collection<Unit>> toScramble = getRemotePlayer(defender).scrambleUnitsQuery(to, scramblers);
if (toScramble == null) {
continue;
}
// verify max allowed
if (!scramblers.keySet().containsAll(toScramble.keySet())) {
throw new IllegalStateException("Trying to scramble from illegal territory");
}
for (final Territory t : scramblers.keySet()) {
if (toScramble.get(t) == null) {
continue;
}
if (toScramble.get(t).size() > getMaxScrambleCount(scramblers.get(t).getFirst())) {
throw new IllegalStateException("Trying to scramble " + toScramble.get(t).size() + " out of " + t.getName() + ", but max allowed is " + scramblers.get(t).getFirst());
}
}
// Validate players have enough fuel to move there and back
final Map<PlayerID, ResourceCollection> playerFuelCost = new HashMap<>();
for (final Entry<Territory, Collection<Unit>> entry : toScramble.entrySet()) {
final Map<PlayerID, ResourceCollection> map = Route.getScrambleFuelCostCharge(entry.getValue(), entry.getKey(), to, data);
for (final Entry<PlayerID, ResourceCollection> playerAndCost : map.entrySet()) {
if (playerFuelCost.containsKey(playerAndCost.getKey())) {
playerFuelCost.get(playerAndCost.getKey()).add(playerAndCost.getValue());
} else {
playerFuelCost.put(playerAndCost.getKey(), playerAndCost.getValue());
}
}
}
for (final Entry<PlayerID, ResourceCollection> playerAndCost : playerFuelCost.entrySet()) {
if (!playerAndCost.getKey().getResources().has(playerAndCost.getValue().getResourcesCopy())) {
throw new IllegalStateException("Not enough fuel to scramble, player: " + playerAndCost.getKey() + ", needs: " + playerAndCost.getValue());
}
}
final CompositeChange change = new CompositeChange();
for (final Territory t : toScramble.keySet()) {
final Collection<Unit> scrambling = toScramble.get(t);
if (scrambling == null || scrambling.isEmpty()) {
continue;
}
int numberScrambled = scrambling.size();
final Collection<Unit> airbases = t.getUnits().getMatches(airbasesCanScramble);
final int maxCanScramble = getMaxScrambleCount(airbases);
if (maxCanScramble != Integer.MAX_VALUE) {
// TODO: maybe sort from biggest to smallest first?
for (final Unit airbase : airbases) {
final int allowedScramble = ((TripleAUnit) airbase).getMaxScrambleCount();
if (allowedScramble > 0) {
final int newAllowed;
if (allowedScramble >= numberScrambled) {
newAllowed = allowedScramble - numberScrambled;
numberScrambled = 0;
} else {
newAllowed = 0;
numberScrambled -= allowedScramble;
}
change.add(ChangeFactory.unitPropertyChange(airbase, newAllowed, TripleAUnit.MAX_SCRAMBLE_COUNT));
}
if (numberScrambled <= 0) {
break;
}
}
}
for (final Unit u : scrambling) {
change.add(ChangeFactory.unitPropertyChange(u, t, TripleAUnit.ORIGINATED_FROM));
change.add(ChangeFactory.unitPropertyChange(u, true, TripleAUnit.WAS_SCRAMBLED));
change.add(Route.getFuelChanges(Collections.singleton(u), new Route(t, to), u.getOwner(), data));
}
// should we mark combat, or call setupUnitsInSameTerritoryBattles again?
change.add(ChangeFactory.moveUnits(t, to, scrambling));
bridge.getHistoryWriter().startEvent(defender.getName() + " scrambles " + scrambling.size() + " units out of " + t.getName() + " to defend against the attack in " + to.getName(), scrambling);
scrambledHere = true;
}
if (!change.isEmpty()) {
bridge.addChange(change);
}
}
if (!scrambledHere) {
continue;
}
// make sure the units join the battle, or create a new battle.
final IBattle bombing = battleTracker.getPendingBattle(to, true, null);
IBattle battle = battleTracker.getPendingBattle(to, false, BattleType.NORMAL);
if (battle == null) {
final List<Unit> attackingUnits = to.getUnits().getMatches(Matches.unitIsOwnedBy(player));
if (bombing != null) {
attackingUnits.removeAll(bombing.getAttackingUnits());
}
// into an air battle / air raid
if (attackingUnits.isEmpty()) {
continue;
}
bridge.getHistoryWriter().startEvent(defender.getName() + " scrambles to create a battle in territory " + to.getName());
// TODO: the attacking sea units do not remember where they came from, so they cannot retreat anywhere. Need to
// fix.
battleTracker.addBattle(new RouteScripted(to), attackingUnits, player, bridge, null, null);
battle = battleTracker.getPendingBattle(to, false, BattleType.NORMAL);
if (battle instanceof MustFightBattle) {
// this is an ugly mess of hacks, but will have to stay here till all transport related code is gutted and
// refactored.
final MustFightBattle mfb = (MustFightBattle) battle;
final Collection<Territory> neighborsLand = data.getMap().getNeighbors(to, Matches.territoryIsLand());
if (attackingUnits.stream().anyMatch(Matches.unitIsTransport())) {
// first, we have to reset the "transportedBy" setting for all the land units that were offloaded
final CompositeChange change1 = new CompositeChange();
mfb.reLoadTransports(attackingUnits, change1);
if (!change1.isEmpty()) {
bridge.addChange(change1);
}
// after that is applied, we have to make a map of all dependencies
final Map<Unit, Collection<Unit>> dependenciesForMfb = TransportTracker.transporting(attackingUnits, attackingUnits);
for (final Unit transport : CollectionUtils.getMatches(attackingUnits, Matches.unitIsTransport())) {
// BUT it must still hold all transports
if (!dependenciesForMfb.containsKey(transport)) {
dependenciesForMfb.put(transport, new ArrayList<>());
}
}
final Map<Territory, Map<Unit, Collection<Unit>>> dependencies = new HashMap<>();
dependencies.put(to, dependenciesForMfb);
for (final Territory t : neighborsLand) {
// All other maps, must hold only the transported units that in their territory
final Collection<Unit> allNeighborUnits = new ArrayList<>(CollectionUtils.getMatches(attackingUnits, Matches.unitIsTransport()));
allNeighborUnits.addAll(t.getUnits().getMatches(Matches.unitIsLandAndOwnedBy(player)));
final Map<Unit, Collection<Unit>> dependenciesForNeighbors = TransportTracker.transporting(CollectionUtils.getMatches(allNeighborUnits, Matches.unitIsTransport()), CollectionUtils.getMatches(allNeighborUnits, Matches.unitIsTransport().negate()));
dependencies.put(t, dependenciesForNeighbors);
}
mfb.addDependentUnits(dependencies.get(to));
for (final Territory territoryNeighborToNewBattle : neighborsLand) {
final IBattle battleInTerritoryNeighborToNewBattle = battleTracker.getPendingBattle(territoryNeighborToNewBattle, false, BattleType.NORMAL);
if (battleInTerritoryNeighborToNewBattle instanceof MustFightBattle) {
final MustFightBattle mfbattleInTerritoryNeighborToNewBattle = (MustFightBattle) battleInTerritoryNeighborToNewBattle;
mfbattleInTerritoryNeighborToNewBattle.addDependentUnits(dependencies.get(territoryNeighborToNewBattle));
} else if (battleInTerritoryNeighborToNewBattle instanceof NonFightingBattle) {
final NonFightingBattle nfbattleInTerritoryNeighborToNewBattle = (NonFightingBattle) battleInTerritoryNeighborToNewBattle;
nfbattleInTerritoryNeighborToNewBattle.addDependentUnits(dependencies.get(territoryNeighborToNewBattle));
}
}
}
if (attackingUnits.stream().anyMatch(Matches.unitIsAir().negate())) {
// TODO: for now, we will hack and say that the attackers came from Everywhere, and hope the user will
// choose the correct place
// to retreat to! (TODO: Fix this)
final Map<Territory, Collection<Unit>> attackingFromMap = new HashMap<>();
final Collection<Territory> neighbors = data.getMap().getNeighbors(to, (Matches.territoryIsLand().test(to) ? Matches.territoryIsLand() : Matches.territoryIsWater()));
// neighbors.removeAll(Matches.getMatches(neighbors, Matches.territoryHasEnemyUnits(player, data)));
for (final Territory t : neighbors) {
attackingFromMap.put(t, attackingUnits);
}
mfb.setAttackingFromAndMap(attackingFromMap);
}
}
} else if (battle instanceof MustFightBattle) {
((MustFightBattle) battle).resetDefendingUnits(player, data);
}
// now make sure any amphibious battles that are dependent on this 'new' sea battle have their dependencies set.
if (to.isWater()) {
for (final Territory t : data.getMap().getNeighbors(to, Matches.territoryIsLand())) {
final IBattle battleAmphib = battleTracker.getPendingBattle(t, false, BattleType.NORMAL);
if (battleAmphib != null) {
if (!battleTracker.getDependentOn(battle).contains(battleAmphib)) {
battleTracker.addDependency(battleAmphib, battle);
}
if (battleAmphib instanceof MustFightBattle) {
// and we want to reset the defenders if the scrambling air has left that battle
((MustFightBattle) battleAmphib).resetDefendingUnits(player, data);
}
}
}
}
}
}
use of games.strategy.util.Tuple in project triplea by triplea-game.
the class UnitAttachment method getReceivesAbilityWhenWithMap.
private static IntegerMap<Tuple<String, String>> getReceivesAbilityWhenWithMap(final Collection<Unit> units, final String filterForAbility, final GameData data) {
final IntegerMap<Tuple<String, String>> map = new IntegerMap<>();
final Collection<UnitType> canReceive = getUnitTypesFromUnitList(CollectionUtils.getMatches(units, Matches.unitCanReceiveAbilityWhenWith()));
for (final UnitType ut : canReceive) {
final Collection<String> receives = UnitAttachment.get(ut).getReceivesAbilityWhenWith();
for (final String receive : receives) {
final String[] s = receive.split(":");
if (filterForAbility != null && !filterForAbility.equals(s[0])) {
continue;
}
map.put(Tuple.of(s[0], s[1]), CollectionUtils.countMatches(units, Matches.unitIsOfType(data.getUnitTypeList().getUnitType(s[1]))));
}
}
return map;
}
Aggregations