Example 11 with ResourceCollection
use of games.strategy.engine.data.ResourceCollection in project triplea by triplea-game.
the class ProductionRepairPanel method setLeft.
protected void setLeft(final ResourceCollection left) {
final ResourceCollection total = getResources();
this.left.setText("<html>You have " + left + " left.<br>Out of " + total + "</html>");
}
Also used :
ResourceCollection(games.strategy.engine.data.ResourceCollection)
Example 12 with ResourceCollection
use of games.strategy.engine.data.ResourceCollection in project triplea by triplea-game.
the class TuvUtils method getResourceCostsForTuvForAllPlayersMergedAndAveraged.
/**
* Return a map where key are unit types and values are the AVERAGED for all players.
* Any production rule that produces multiple units
* (like artillery in NWO, costs 7 but makes 2 artillery, meaning effective price is 3.5 each)
* will have their costs rounded up on a per unit basis.
* Therefore, this map should NOT be used for Purchasing information!
*/
private static Map<UnitType, ResourceCollection> getResourceCostsForTuvForAllPlayersMergedAndAveraged(final GameData data) {
final Map<UnitType, ResourceCollection> average = new HashMap<>();
final Resource pus;
data.acquireReadLock();
try {
pus = data.getResourceList().getResource(Constants.PUS);
} finally {
data.releaseReadLock();
}
final IntegerMap<Resource> defaultMap = new IntegerMap<>();
defaultMap.put(pus, 1);
final ResourceCollection defaultResources = new ResourceCollection(data, defaultMap);
final Map<UnitType, List<ResourceCollection>> backups = new HashMap<>();
final Map<UnitType, ResourceCollection> backupAveraged = new HashMap<>();
for (final ProductionRule rule : data.getProductionRuleList().getProductionRules()) {
if (rule == null || rule.getResults() == null || rule.getResults().isEmpty() || rule.getCosts() == null || rule.getCosts().isEmpty()) {
continue;
}
final IntegerMap<NamedAttachable> unitMap = rule.getResults();
final ResourceCollection costPerGroup = new ResourceCollection(data, rule.getCosts());
final Set<UnitType> units = new HashSet<>();
for (final NamedAttachable resourceOrUnit : unitMap.keySet()) {
if (!(resourceOrUnit instanceof UnitType)) {
continue;
}
units.add((UnitType) resourceOrUnit);
}
if (units.isEmpty()) {
continue;
}
final int totalProduced = unitMap.totalValues();
if (totalProduced == 1) {
final UnitType ut = units.iterator().next();
final List<ResourceCollection> current = backups.computeIfAbsent(ut, k -> new ArrayList<>());
current.add(costPerGroup);
} else if (totalProduced > 1) {
costPerGroup.discount((double) 1 / (double) totalProduced);
for (final UnitType ut : units) {
final List<ResourceCollection> current = backups.computeIfAbsent(ut, k -> new ArrayList<>());
current.add(costPerGroup);
}
}
}
for (final Entry<UnitType, List<ResourceCollection>> entry : backups.entrySet()) {
final ResourceCollection avgCost = new ResourceCollection(entry.getValue().toArray(new ResourceCollection[0]), data);
if (entry.getValue().size() > 1) {
avgCost.discount((double) 1 / (double) entry.getValue().size());
}
backupAveraged.put(entry.getKey(), avgCost);
}
final Map<PlayerID, Map<UnitType, ResourceCollection>> allPlayersCurrent = getResourceCostsForTuv(data, false);
allPlayersCurrent.remove(null);
for (final UnitType ut : data.getUnitTypeList().getAllUnitTypes()) {
final List<ResourceCollection> costs = new ArrayList<>();
for (final Map<UnitType, ResourceCollection> entry : allPlayersCurrent.values()) {
if (entry.get(ut) != null) {
costs.add(entry.get(ut));
}
}
if (costs.isEmpty()) {
final ResourceCollection backup = backupAveraged.get(ut);
if (backup != null) {
costs.add(backup);
} else {
costs.add(defaultResources);
}
}
final ResourceCollection avgCost = new ResourceCollection(costs.toArray(new ResourceCollection[0]), data);
if (costs.size() > 1) {
avgCost.discount((double) 1 / (double) costs.size());
}
average.put(ut, avgCost);
}
return average;
}
Also used :
IntegerMap(games.strategy.util.IntegerMap)
Unit(games.strategy.engine.data.Unit)
Collection(java.util.Collection)
Constants(games.strategy.triplea.Constants)
Set(java.util.Set)
UnitAttachment(games.strategy.triplea.attachments.UnitAttachment)
HashMap(java.util.HashMap)
NamedAttachable(games.strategy.engine.data.NamedAttachable)
Resource(games.strategy.engine.data.Resource)
ArrayList(java.util.ArrayList)
HashSet(java.util.HashSet)
LinkedHashMap(java.util.LinkedHashMap)
GameData(games.strategy.engine.data.GameData)
List(java.util.List)
PlayerID(games.strategy.engine.data.PlayerID)
ResourceCollection(games.strategy.engine.data.ResourceCollection)
ProductionFrontier(games.strategy.engine.data.ProductionFrontier)
Matches(games.strategy.triplea.delegate.Matches)
Map(java.util.Map)
Entry(java.util.Map.Entry)
UnitType(games.strategy.engine.data.UnitType)
ProductionRule(games.strategy.engine.data.ProductionRule)
CollectionUtils(games.strategy.util.CollectionUtils)
IntegerMap(games.strategy.util.IntegerMap)
PlayerID(games.strategy.engine.data.PlayerID)
HashMap(java.util.HashMap)
LinkedHashMap(java.util.LinkedHashMap)
NamedAttachable(games.strategy.engine.data.NamedAttachable)
Resource(games.strategy.engine.data.Resource)
ArrayList(java.util.ArrayList)
ProductionRule(games.strategy.engine.data.ProductionRule)
UnitType(games.strategy.engine.data.UnitType)
ArrayList(java.util.ArrayList)
List(java.util.List)
HashMap(java.util.HashMap)
LinkedHashMap(java.util.LinkedHashMap)
Map(java.util.Map)
IntegerMap(games.strategy.util.IntegerMap)
ResourceCollection(games.strategy.engine.data.ResourceCollection)
HashSet(java.util.HashSet)
Example 13 with ResourceCollection
use of games.strategy.engine.data.ResourceCollection in project triplea by triplea-game.
the class TuvUtils method getResourceCostsForTuv.
/**
* Return map where keys are unit types and values are resource costs of that unit type, based on a player.
* Any production rule that produces multiple units
* (like artillery in NWO, costs 7 but makes 2 artillery, meaning effective price is 3.5 each)
* will have their costs rounded up on a per unit basis.
* Therefore, this map should NOT be used for Purchasing information!
*/
public static Map<PlayerID, Map<UnitType, ResourceCollection>> getResourceCostsForTuv(final GameData data, final boolean includeAverageForMissingUnits) {
final HashMap<PlayerID, Map<UnitType, ResourceCollection>> result = new LinkedHashMap<>();
final Map<UnitType, ResourceCollection> average = includeAverageForMissingUnits ? TuvUtils.getResourceCostsForTuvForAllPlayersMergedAndAveraged(data) : new HashMap<>();
final List<PlayerID> players = data.getPlayerList().getPlayers();
players.add(PlayerID.NULL_PLAYERID);
for (final PlayerID p : players) {
final ProductionFrontier frontier = p.getProductionFrontier();
// any one will do then
if (frontier == null) {
result.put(p, average);
continue;
}
final Map<UnitType, ResourceCollection> current = result.computeIfAbsent(p, k -> new LinkedHashMap<>());
for (final ProductionRule rule : frontier.getRules()) {
if (rule == null || rule.getResults() == null || rule.getResults().isEmpty() || rule.getCosts() == null || rule.getCosts().isEmpty()) {
continue;
}
final IntegerMap<NamedAttachable> unitMap = rule.getResults();
final ResourceCollection costPerGroup = new ResourceCollection(data, rule.getCosts());
final Set<UnitType> units = new HashSet<>();
for (final NamedAttachable resourceOrUnit : unitMap.keySet()) {
if (!(resourceOrUnit instanceof UnitType)) {
continue;
}
units.add((UnitType) resourceOrUnit);
}
if (units.isEmpty()) {
continue;
}
final int totalProduced = unitMap.totalValues();
if (totalProduced == 1) {
current.put(units.iterator().next(), costPerGroup);
} else if (totalProduced > 1) {
costPerGroup.discount((double) 1 / (double) totalProduced);
for (final UnitType ut : units) {
current.put(ut, costPerGroup);
}
}
}
// we will add any unit types not in our list, based on the list for everyone
for (final UnitType ut : average.keySet()) {
if (!current.keySet().contains(ut)) {
current.put(ut, average.get(ut));
}
}
}
result.put(null, average);
return result;
}
Also used :
PlayerID(games.strategy.engine.data.PlayerID)
NamedAttachable(games.strategy.engine.data.NamedAttachable)
ProductionFrontier(games.strategy.engine.data.ProductionFrontier)
LinkedHashMap(java.util.LinkedHashMap)
ProductionRule(games.strategy.engine.data.ProductionRule)
UnitType(games.strategy.engine.data.UnitType)
HashMap(java.util.HashMap)
LinkedHashMap(java.util.LinkedHashMap)
Map(java.util.Map)
IntegerMap(games.strategy.util.IntegerMap)
ResourceCollection(games.strategy.engine.data.ResourceCollection)
HashSet(java.util.HashSet)
Example 14 with ResourceCollection
use of games.strategy.engine.data.ResourceCollection in project triplea by triplea-game.
the class ResourceCollectionUtilsTest method testExcludeByResources_ShouldExcludeSpecifiedResources.
@Test
public void testExcludeByResources_ShouldExcludeSpecifiedResources() {
final ResourceCollection unfiltered = createResourceCollection(pus, techTokens, vps);
final ResourceCollection filtered = ResourceCollectionUtils.exclude(unfiltered, pus, vps);
assertThat(filtered.getQuantity(pus), is(0));
assertThat(filtered.getQuantity(techTokens), is(unfiltered.getQuantity(techTokens)));
assertThat(filtered.getQuantity(vps), is(0));
}
Also used :
ResourceCollection(games.strategy.engine.data.ResourceCollection)
Test(org.junit.jupiter.api.Test)
Example 15 with ResourceCollection
use of games.strategy.engine.data.ResourceCollection 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);
}
}
}
}
}
}
Also used :
PlayerID(games.strategy.engine.data.PlayerID)
GameData(games.strategy.engine.data.GameData)
HashSet(java.util.HashSet)
Set(java.util.Set)
HashMap(java.util.HashMap)
ArrayList(java.util.ArrayList)
TripleAUnit(games.strategy.triplea.TripleAUnit)
Unit(games.strategy.engine.data.Unit)
UnitAttachment(games.strategy.triplea.attachments.UnitAttachment)
UnitType(games.strategy.engine.data.UnitType)
CompositeChange(games.strategy.engine.data.CompositeChange)
Route(games.strategy.engine.data.Route)
HashSet(java.util.HashSet)
Territory(games.strategy.engine.data.Territory)
RouteScripted(games.strategy.engine.data.RouteScripted)
TripleAUnit(games.strategy.triplea.TripleAUnit)
Collection(java.util.Collection)
ResourceCollection(games.strategy.engine.data.ResourceCollection)
HashMap(java.util.HashMap)
Map(java.util.Map)
IntegerMap(games.strategy.util.IntegerMap)
Tuple(games.strategy.util.Tuple)
ResourceCollection(games.strategy.engine.data.ResourceCollection)
Aggregations
ResourceCollection (games.strategy.engine.data.ResourceCollection)23
Resource (games.strategy.engine.data.Resource)7
Test (org.junit.jupiter.api.Test)6
PlayerID (games.strategy.engine.data.PlayerID)4
ProductionRule (games.strategy.engine.data.ProductionRule)4
IntegerMap (games.strategy.util.IntegerMap)4
HashMap (java.util.HashMap)4
HashSet (java.util.HashSet)4
Territory (games.strategy.engine.data.Territory)3
Unit (games.strategy.engine.data.Unit)3
UnitType (games.strategy.engine.data.UnitType)3
ArrayList (java.util.ArrayList)3
Collection (java.util.Collection)3
Map (java.util.Map)3
GameData (games.strategy.engine.data.GameData)2
NamedAttachable (games.strategy.engine.data.NamedAttachable)2
ProductionFrontier (games.strategy.engine.data.ProductionFrontier)2
RepairRule (games.strategy.engine.data.RepairRule)2
TripleAUnit (games.strategy.triplea.TripleAUnit)2
UnitAttachment (games.strategy.triplea.attachments.UnitAttachment)2
