private static void getNeutralOutOfWarWithAllies(
final PoliticalActionAttachment paa, final PlayerID player, final IDelegateBridge aBridge) {
final GameData data = aBridge.getData();
if (!games.strategy.triplea.Properties.getAlliancesCanChainTogether(data)) {
return;
}
final Collection<PlayerID> players = data.getPlayerList().getPlayers();
final Collection<PlayerID> p1AlliedWith =
Match.getMatches(players, Matches.isAlliedAndAlliancesCanChainTogether(player, data));
final CompositeChange change = new CompositeChange();
for (final String relationshipChangeString : paa.getRelationshipChange()) {
final String[] relationshipChange = relationshipChangeString.split(":");
final PlayerID p1 = data.getPlayerList().getPlayerID(relationshipChange[0]);
final PlayerID p2 = data.getPlayerList().getPlayerID(relationshipChange[1]);
if (!(p1.equals(player) || p2.equals(player))) {
continue;
}
final PlayerID pOther = (p1.equals(player) ? p2 : p1);
final RelationshipType currentType =
data.getRelationshipTracker().getRelationshipType(p1, p2);
final RelationshipType newType =
data.getRelationshipTypeList().getRelationshipType(relationshipChange[2]);
if (Matches.RelationshipTypeIsAtWar.match(currentType)
&& Matches.RelationshipTypeIsAtWar.invert().match(newType)) {
final Collection<PlayerID> pOtherAlliedWith =
Match.getMatches(players, Matches.isAlliedAndAlliancesCanChainTogether(pOther, data));
if (!pOtherAlliedWith.contains(pOther)) {
pOtherAlliedWith.add(pOther);
}
if (!p1AlliedWith.contains(player)) {
p1AlliedWith.add(player);
}
for (final PlayerID p3 : p1AlliedWith) {
for (final PlayerID p4 : pOtherAlliedWith) {
final RelationshipType currentOther =
data.getRelationshipTracker().getRelationshipType(p3, p4);
if (!currentOther.equals(newType)
&& Matches.RelationshipTypeIsAtWar.match(currentOther)) {
change.add(ChangeFactory.relationshipChange(p3, p4, currentOther, newType));
aBridge
.getHistoryWriter()
.addChildToEvent(
p3.getName()
+ " and "
+ p4.getName()
+ " sign a "
+ newType.getName()
+ " treaty");
MoveDelegate.getBattleTracker(data)
.addRelationshipChangesThisTurn(p3, p4, currentOther, newType);
}
}
}
}
}
if (!change.isEmpty()) {
aBridge.addChange(change);
}
}
public static void givesBackOriginalTerritories(final IDelegateBridge aBridge) {
final GameData data = aBridge.getData();
final CompositeChange change = new CompositeChange();
final Collection<PlayerID> players = data.getPlayerList().getPlayers();
for (final PlayerID p1 : players) {
for (final PlayerID p2 : players) {
if (!data.getRelationshipTracker().givesBackOriginalTerritories(p1, p2)) {
continue;
}
for (final Territory t : data.getMap().getTerritoriesOwnedBy(p1)) {
final PlayerID original = OriginalOwnerTracker.getOriginalOwner(t);
if (original == null) {
continue;
}
if (original.equals(p2)) {
change.add(ChangeFactory.changeOwner(t, original));
}
}
}
}
if (!change.isEmpty()) {
aBridge.getHistoryWriter().startEvent("Giving back territories to original owners");
aBridge.addChange(change);
}
}
public static Change loadTransportChange(final TripleAUnit transport, final Unit unit) {
assertTransport(transport);
final CompositeChange change = new CompositeChange();
// clear the loaded by
change.add(ChangeFactory.unitPropertyChange(unit, transport, TripleAUnit.TRANSPORTED_BY));
final Collection<Unit> newCarrying = new ArrayList<Unit>(transport.getTransporting());
if (newCarrying.contains(unit)) {
throw new IllegalStateException("Already carrying, transport:" + transport + " unt:" + unit);
}
newCarrying.add(unit);
change.add(ChangeFactory.unitPropertyChange(unit, Boolean.TRUE, TripleAUnit.LOADED_THIS_TURN));
change.add(ChangeFactory.unitPropertyChange(transport, true, TripleAUnit.LOADED_THIS_TURN));
// If the transport was in combat, flag it as being loaded AFTER combat
if (transport.getWasInCombat()) {
change.add(
ChangeFactory.unitPropertyChange(transport, true, TripleAUnit.LOADED_AFTER_COMBAT));
}
return change;
}
public static Change unloadAirTransportChange(
final TripleAUnit unit,
final Territory territory,
final PlayerID id,
final boolean dependentBattle) {
final CompositeChange change = new CompositeChange();
final TripleAUnit transport = (TripleAUnit) transportedBy(unit);
if (transport == null) {
return change;
}
assertTransport(transport);
if (!transport.getTransporting().contains(unit)) {
throw new IllegalStateException(
"Not being carried, unit:" + unit + " transport:" + transport);
}
final ArrayList<Unit> newUnloaded = new ArrayList<Unit>(transport.getUnloaded());
newUnloaded.add(unit);
change.add(ChangeFactory.unitPropertyChange(unit, territory, TripleAUnit.UNLOADED_TO));
if (!GameStepPropertiesHelper.isNonCombatMove(unit.getData(), true)) {
change.add(
ChangeFactory.unitPropertyChange(unit, true, TripleAUnit.UNLOADED_IN_COMBAT_PHASE));
// change.add(ChangeFactory.unitPropertyChange(unit, true, TripleAUnit.UNLOADED_AMPHIBIOUS));
change.add(
ChangeFactory.unitPropertyChange(transport, true, TripleAUnit.UNLOADED_IN_COMBAT_PHASE));
// change.add(ChangeFactory.unitPropertyChange(transport, true,
// TripleAUnit.UNLOADED_AMPHIBIOUS));
}
if (!dependentBattle) {
// TODO: this is causing issues with Scrambling. if the units were unloaded, then scrambling
// creates a battle, there is no longer any
// way to have the units removed if those transports die.
change.add(ChangeFactory.unitPropertyChange(unit, null, TripleAUnit.TRANSPORTED_BY));
}
// dependencies for battle calc and casualty selection include unloaded. therefore even if we
// have unloaded this unit, it will die if
// air transport dies IF we have the unloaded flat set. so don't set it.
// TODO: fix this bullshit by re-writing entire transportation engine
// change.add(ChangeFactory.unitPropertyChange(transport, newUnloaded, TripleAUnit.UNLOADED));
return change;
}
/**
* Changes all relationships
*
* @param paa the political action to change the relationships for
*/
private void changeRelationships(final PoliticalActionAttachment paa) {
getMyselfOutOfAlliance(paa, m_player, m_bridge);
getNeutralOutOfWarWithAllies(paa, m_player, m_bridge);
final CompositeChange change = new CompositeChange();
for (final String relationshipChange : paa.getRelationshipChange()) {
final String[] s = relationshipChange.split(":");
final PlayerID player1 = getData().getPlayerList().getPlayerID(s[0]);
final PlayerID player2 = getData().getPlayerList().getPlayerID(s[1]);
final RelationshipType oldRelation =
getData().getRelationshipTracker().getRelationshipType(player1, player2);
final RelationshipType newRelation =
getData().getRelationshipTypeList().getRelationshipType(s[2]);
if (oldRelation.equals(newRelation)) {
continue;
}
change.add(ChangeFactory.relationshipChange(player1, player2, oldRelation, newRelation));
m_bridge
.getHistoryWriter()
.addChildToEvent(
m_bridge.getPlayerID().getName()
+ " succeeds on action: "
+ MyFormatter.attachmentNameToText(paa.getName())
+ ": Changing Relationship for "
+ player1.getName()
+ " and "
+ player2.getName()
+ " from "
+ oldRelation.getName()
+ " to "
+ newRelation.getName());
MoveDelegate.getBattleTracker(getData())
.addRelationshipChangesThisTurn(player1, player2, oldRelation, newRelation);
/*
* creation of new battles is handled at the beginning of the battle delegate, in
* "setupUnitsInSameTerritoryBattles", not here.
* if (Matches.RelationshipTypeIsAtWar.match(newRelation))
* TriggerAttachment.triggerMustFightBattle(player1, player2, m_bridge);
*/
}
if (!change.isEmpty()) {
m_bridge.addChange(change);
}
chainAlliancesTogether(m_bridge);
}
/**
* Subtract money from the players wallet
*
* @param paa the politicalactionattachment this the money is charged for.
*/
private void chargeForAction(final PoliticalActionAttachment paa) {
final Resource PUs = getData().getResourceList().getResource(Constants.PUS);
final int cost = paa.getCostPU();
if (cost > 0) {
// don't notify user of spending money anymore
// notifyMoney(paa, true);
final String transcriptText =
m_bridge.getPlayerID().getName()
+ " spend "
+ cost
+ " PU on Political Action: "
+ MyFormatter.attachmentNameToText(paa.getName());
m_bridge.getHistoryWriter().startEvent(transcriptText);
final Change charge = ChangeFactory.changeResourcesChange(m_bridge.getPlayerID(), PUs, -cost);
m_bridge.addChange(charge);
} else {
final String transcriptText =
m_bridge.getPlayerID().getName()
+ " takes Political Action: "
+ MyFormatter.attachmentNameToText(paa.getName());
// we must start an event anyway
m_bridge.getHistoryWriter().startEvent(transcriptText);
}
}
public static Change unloadTransportChange(
final TripleAUnit unit,
final Territory territory,
final PlayerID id,
final boolean dependentBattle) {
final CompositeChange change = new CompositeChange();
final TripleAUnit transport = (TripleAUnit) transportedBy(unit);
if (transport == null) {
return change;
}
assertTransport(transport);
if (!transport.getTransporting().contains(unit)) {
throw new IllegalStateException(
"Not being carried, unit:" + unit + " transport:" + transport);
}
final ArrayList<Unit> newUnloaded = new ArrayList<Unit>(transport.getUnloaded());
newUnloaded.add(unit);
change.add(ChangeFactory.unitPropertyChange(unit, territory, TripleAUnit.UNLOADED_TO));
if (!GameStepPropertiesHelper.isNonCombatMove(unit.getData(), true)) {
change.add(
ChangeFactory.unitPropertyChange(unit, true, TripleAUnit.UNLOADED_IN_COMBAT_PHASE));
change.add(ChangeFactory.unitPropertyChange(unit, true, TripleAUnit.UNLOADED_AMPHIBIOUS));
change.add(
ChangeFactory.unitPropertyChange(transport, true, TripleAUnit.UNLOADED_IN_COMBAT_PHASE));
change.add(
ChangeFactory.unitPropertyChange(transport, true, TripleAUnit.UNLOADED_AMPHIBIOUS));
}
if (!dependentBattle) {
// TODO: this is causing issues with Scrambling. if the units were unloaded, then scrambling
// creates a battle, there is no longer any
// way to have the units removed if those transports die.
change.add(ChangeFactory.unitPropertyChange(unit, null, TripleAUnit.TRANSPORTED_BY));
}
change.add(ChangeFactory.unitPropertyChange(transport, newUnloaded, TripleAUnit.UNLOADED));
return change;
}
public static void chainAlliancesTogether(final IDelegateBridge aBridge) {
final GameData data = aBridge.getData();
if (!games.strategy.triplea.Properties.getAlliancesCanChainTogether(data)) {
return;
}
final Collection<RelationshipType> allTypes =
data.getRelationshipTypeList().getAllRelationshipTypes();
RelationshipType alliedType = null;
RelationshipType warType = null;
for (final RelationshipType type : allTypes) {
if (type.getRelationshipTypeAttachment().getIsDefaultWarPosition()) {
warType = type;
} else if (type.getRelationshipTypeAttachment().getAlliancesCanChainTogether()) {
alliedType = type;
}
}
if (alliedType == null) {
return;
}
// first do alliances. then, do war (since we don't want to declare war on a potential ally).
final Collection<PlayerID> players = data.getPlayerList().getPlayers();
for (final PlayerID p1 : players) {
final HashSet<PlayerID> p1NewAllies = new HashSet<PlayerID>();
final Collection<PlayerID> p1AlliedWith =
Match.getMatches(players, Matches.isAlliedAndAlliancesCanChainTogether(p1, data));
for (final PlayerID p2 : p1AlliedWith) {
p1NewAllies.addAll(
Match.getMatches(players, Matches.isAlliedAndAlliancesCanChainTogether(p2, data)));
}
p1NewAllies.removeAll(p1AlliedWith);
p1NewAllies.remove(p1);
for (final PlayerID p3 : p1NewAllies) {
if (!data.getRelationshipTracker().getRelationshipType(p1, p3).equals(alliedType)) {
final RelationshipType current =
data.getRelationshipTracker().getRelationshipType(p1, p3);
aBridge.addChange(ChangeFactory.relationshipChange(p1, p3, current, alliedType));
aBridge
.getHistoryWriter()
.addChildToEvent(
p1.getName()
+ " and "
+ p3.getName()
+ " are joined together in an "
+ alliedType.getName()
+ " treaty");
MoveDelegate.getBattleTracker(data)
.addRelationshipChangesThisTurn(p1, p3, current, alliedType);
}
}
}
// now war
if (warType == null) {
return;
}
for (final PlayerID p1 : players) {
final HashSet<PlayerID> p1NewWar = new HashSet<PlayerID>();
final Collection<PlayerID> p1WarWith = Match.getMatches(players, Matches.isAtWar(p1, data));
final Collection<PlayerID> p1AlliedWith =
Match.getMatches(players, Matches.isAlliedAndAlliancesCanChainTogether(p1, data));
for (final PlayerID p2 : p1AlliedWith) {
p1NewWar.addAll(Match.getMatches(players, Matches.isAtWar(p2, data)));
}
p1NewWar.removeAll(p1WarWith);
p1NewWar.remove(p1);
for (final PlayerID p3 : p1NewWar) {
if (!data.getRelationshipTracker().getRelationshipType(p1, p3).equals(warType)) {
final RelationshipType current =
data.getRelationshipTracker().getRelationshipType(p1, p3);
aBridge.addChange(ChangeFactory.relationshipChange(p1, p3, current, warType));
aBridge
.getHistoryWriter()
.addChildToEvent(
p1.getName()
+ " and "
+ p3.getName()
+ " declare "
+ warType.getName()
+ " on each other");
MoveDelegate.getBattleTracker(data)
.addRelationshipChangesThisTurn(p1, p3, current, warType);
}
}
}
}
public static void addTo(final PlayerID t, final Collection<Unit> units, final GameData data) {
new ChangePerformer(data).perform(ChangeFactory.addUnits(t, units));
}
public static void addTo(final Territory t, final Collection<Unit> units) {
new ChangePerformer(t.getData()).perform(ChangeFactory.addUnits(t, units));
}
public static void removeFrom(final Territory t, final Collection<Unit> units) {
new ChangePerformer(t.getData()).perform(ChangeFactory.removeUnits(t, units));
}
public static Change combatTransportChange(final TripleAUnit transport, final PlayerID id) {
assertTransport(transport);
final CompositeChange change = new CompositeChange();
change.add(ChangeFactory.unitPropertyChange(transport, true, TripleAUnit.WAS_IN_COMBAT));
return change;
}
private void fireRocket(
final PlayerID player,
final Territory attackedTerritory,
final IDelegateBridge bridge,
final Territory attackFrom) {
final GameData data = bridge.getData();
final PlayerID attacked = attackedTerritory.getOwner();
final Resource PUs = data.getResourceList().getResource(Constants.PUS);
final boolean DamageFromBombingDoneToUnits =
isDamageFromBombingDoneToUnitsInsteadOfTerritories(data);
// unit damage vs territory damage
final Collection<Unit> enemyUnits =
attackedTerritory
.getUnits()
.getMatches(
new CompositeMatchAnd<Unit>(
Matches.enemyUnit(player, data), Matches.unitIsBeingTransported().invert()));
final Collection<Unit> enemyTargetsTotal =
Match.getMatches(
enemyUnits, Matches.UnitIsAtMaxDamageOrNotCanBeDamaged(attackedTerritory).invert());
final Collection<Unit> targets = new ArrayList<Unit>();
final Collection<Unit> rockets;
// attackFrom could be null if WW2V1
if (attackFrom == null) rockets = null;
else
rockets =
new ArrayList<Unit>(
Match.getMatches(attackFrom.getUnits().getUnits(), rocketMatch(player, data)));
final int numberOfAttacks =
(rockets == null
? 1
: Math.min(
TechAbilityAttachment.getRocketNumberPerTerritory(player, data),
TechAbilityAttachment.getRocketDiceNumber(rockets, data)));
if (numberOfAttacks <= 0) return;
final String transcript;
if (DamageFromBombingDoneToUnits) {
// TODO: rockets needs to be completely redone to allow for multiple rockets to fire at
// different targets, etc etc.
final HashSet<UnitType> legalTargetsForTheseRockets = new HashSet<UnitType>();
if (rockets == null)
legalTargetsForTheseRockets.addAll(data.getUnitTypeList().getAllUnitTypes());
else {
// a hack for now, we let the rockets fire at anyone who could be targetted by any rocket
for (final Unit r : rockets) {
legalTargetsForTheseRockets.addAll(
UnitAttachment.get(r.getType()).getBombingTargets(data));
}
}
final Collection<Unit> enemyTargets =
Match.getMatches(enemyTargetsTotal, Matches.unitIsOfTypes(legalTargetsForTheseRockets));
if (enemyTargets.isEmpty()) return; // TODO: this sucks
Unit target = null;
if (enemyTargets.size() == 1) target = enemyTargets.iterator().next();
else {
while (target == null) {
final ITripleaPlayer iplayer = (ITripleaPlayer) bridge.getRemotePlayer(player);
target = iplayer.whatShouldBomberBomb(attackedTerritory, enemyTargets, rockets);
}
}
if (target == null)
throw new IllegalStateException("No Targets in " + attackedTerritory.getName());
targets.add(target);
}
final boolean doNotUseBombingBonus =
!games.strategy.triplea.Properties.getUseBombingMaxDiceSidesAndBonus(data)
|| rockets == null;
int cost = 0;
if (!games.strategy.triplea.Properties.getLL_DAMAGE_ONLY(data)) {
if (doNotUseBombingBonus || rockets == null) {
// no low luck, and no bonus, so just roll based on the map's dice sides
final int[] rolls =
bridge.getRandom(
data.getDiceSides(),
numberOfAttacks,
player,
DiceType.BOMBING,
"Rocket fired by " + player.getName() + " at " + attacked.getName());
for (final int r : rolls) {
cost += r + 1; // we are zero based
}
transcript =
"Rockets "
+ (attackFrom == null ? "" : "in " + attackFrom.getName())
+ " roll: "
+ MyFormatter.asDice(rolls);
} else {
// we must use bombing bonus
int highestMaxDice = 0;
int highestBonus = 0;
final int diceSides = data.getDiceSides();
for (final Unit u : rockets) {
final UnitAttachment ua = UnitAttachment.get(u.getType());
int maxDice = ua.getBombingMaxDieSides();
int bonus = ua.getBombingBonus();
// both could be -1, meaning they were not set. if they were not set, then we use default
// dice sides for the map, and zero for the bonus.
if (maxDice < 0) maxDice = diceSides;
if (bonus < 0) bonus = 0;
// we only roll once for rockets, so if there are other rockets here we just roll for the
// best rocket
if ((bonus + ((maxDice + 1) / 2)) > (highestBonus + ((highestMaxDice + 1) / 2))) {
highestMaxDice = maxDice;
highestBonus = bonus;
}
}
// now we roll, or don't if there is nothing to roll.
if (highestMaxDice > 0) {
final int[] rolls =
bridge.getRandom(
highestMaxDice,
numberOfAttacks,
player,
DiceType.BOMBING,
"Rocket fired by " + player.getName() + " at " + attacked.getName());
for (int i = 0; i < rolls.length; i++) {
final int r = rolls[i] + highestBonus;
rolls[i] = r;
cost += r + 1; // we are zero based
}
transcript =
"Rockets "
+ (attackFrom == null ? "" : "in " + attackFrom.getName())
+ " roll: "
+ MyFormatter.asDice(rolls);
} else {
cost = highestBonus * numberOfAttacks;
transcript =
"Rockets "
+ (attackFrom == null ? "" : "in " + attackFrom.getName())
+ " do "
+ highestBonus
+ " damage for each rocket";
}
}
} else {
if (doNotUseBombingBonus || rockets == null) {
// no bonus, so just roll based on the map's dice sides, but modify for LL
final int maxDice = (data.getDiceSides() + 1) / 3;
final int bonus = (data.getDiceSides() + 1) / 3;
final int[] rolls =
bridge.getRandom(
maxDice,
numberOfAttacks,
player,
DiceType.BOMBING,
"Rocket fired by " + player.getName() + " at " + attacked.getName());
for (int i = 0; i < rolls.length; i++) {
final int r = rolls[i] + bonus;
rolls[i] = r;
cost += r + 1; // we are zero based
}
transcript =
"Rockets "
+ (attackFrom == null ? "" : "in " + attackFrom.getName())
+ " roll: "
+ MyFormatter.asDice(rolls);
} else {
int highestMaxDice = 0;
int highestBonus = 0;
final int diceSides = data.getDiceSides();
for (final Unit u : rockets) {
final UnitAttachment ua = UnitAttachment.get(u.getType());
int maxDice = ua.getBombingMaxDieSides();
int bonus = ua.getBombingBonus();
// both could be -1, meaning they were not set. if they were not set, then we use default
// dice sides for the map, and zero for the bonus.
if (maxDice < 0 || doNotUseBombingBonus) maxDice = diceSides;
if (bonus < 0 || doNotUseBombingBonus) bonus = 0;
// now, regardless of whether they were set or not, we have to apply "low luck" to them,
// meaning in this case that we reduce the luck by 2/3.
if (maxDice >= 5) {
bonus += (maxDice + 1) / 3;
maxDice = (maxDice + 1) / 3;
}
// we only roll once for rockets, so if there are other rockets here we just roll for the
// best rocket
if ((bonus + ((maxDice + 1) / 2)) > (highestBonus + ((highestMaxDice + 1) / 2))) {
highestMaxDice = maxDice;
highestBonus = bonus;
}
}
// now we roll, or don't if there is nothing to roll.
if (highestMaxDice > 0) {
final int[] rolls =
bridge.getRandom(
highestMaxDice,
numberOfAttacks,
player,
DiceType.BOMBING,
"Rocket fired by " + player.getName() + " at " + attacked.getName());
for (int i = 0; i < rolls.length; i++) {
final int r = rolls[i] + highestBonus;
rolls[i] = r;
cost += r + 1; // we are zero based
}
transcript =
"Rockets "
+ (attackFrom == null ? "" : "in " + attackFrom.getName())
+ " roll: "
+ MyFormatter.asDice(rolls);
} else {
cost = highestBonus * numberOfAttacks;
transcript =
"Rockets "
+ (attackFrom == null ? "" : "in " + attackFrom.getName())
+ " do "
+ highestBonus
+ " damage for each rocket";
}
}
}
int territoryProduction = TerritoryAttachment.getProduction(attackedTerritory);
if (DamageFromBombingDoneToUnits && !targets.isEmpty()) {
// we are doing damage to 'target', not to the territory
final Unit target = targets.iterator().next();
// UnitAttachment ua = UnitAttachment.get(target.getType());
final TripleAUnit taUnit = (TripleAUnit) target;
final int damageLimit = taUnit.getHowMuchMoreDamageCanThisUnitTake(target, attackedTerritory);
cost = Math.max(0, Math.min(cost, damageLimit));
final int totalDamage = taUnit.getUnitDamage() + cost;
// Record production lost
// DelegateFinder.moveDelegate(data).PUsLost(attackedTerritory, cost);
// apply the hits to the targets
final IntegerMap<Unit> damageMap = new IntegerMap<Unit>();
damageMap.put(target, totalDamage);
bridge.addChange(ChangeFactory.bombingUnitDamage(damageMap));
// attackedTerritory.notifyChanged();
}
// in WW2V2, limit rocket attack cost to production value of factory.
else if (isWW2V2(data) || isLimitRocketDamageToProduction(data)) {
// If we are limiting total PUs lost then take that into account
if (isPUCap(data) || isLimitRocketDamagePerTurn(data)) {
final int alreadyLost = DelegateFinder.moveDelegate(data).PUsAlreadyLost(attackedTerritory);
territoryProduction -= alreadyLost;
territoryProduction = Math.max(0, territoryProduction);
}
if (cost > territoryProduction) {
cost = territoryProduction;
}
}
// Record the PUs lost
DelegateFinder.moveDelegate(data).PUsLost(attackedTerritory, cost);
if (DamageFromBombingDoneToUnits && !targets.isEmpty()) {
getRemote(bridge)
.reportMessage(
"Rocket attack in "
+ attackedTerritory.getName()
+ " does "
+ cost
+ " damage to "
+ targets.iterator().next(),
"Rocket attack in "
+ attackedTerritory.getName()
+ " does "
+ cost
+ " damage to "
+ targets.iterator().next());
bridge
.getHistoryWriter()
.startEvent(
"Rocket attack in "
+ attackedTerritory.getName()
+ " does "
+ cost
+ " damage to "
+ targets.iterator().next());
} else {
cost *= Properties.getPU_Multiplier(data);
getRemote(bridge)
.reportMessage(
"Rocket attack in " + attackedTerritory.getName() + " costs:" + cost,
"Rocket attack in " + attackedTerritory.getName() + " costs:" + cost);
// Trying to remove more PUs than the victim has is A Bad Thing[tm]
final int availForRemoval = attacked.getResources().getQuantity(PUs);
if (cost > availForRemoval) cost = availForRemoval;
final String transcriptText =
attacked.getName() + " lost " + cost + " PUs to rocket attack by " + player.getName();
bridge.getHistoryWriter().startEvent(transcriptText);
final Change rocketCharge = ChangeFactory.changeResourcesChange(attacked, PUs, -cost);
bridge.addChange(rocketCharge);
}
bridge
.getHistoryWriter()
.addChildToEvent(transcript, rockets == null ? null : new ArrayList<Unit>(rockets));
// this is null in WW2V1
if (attackFrom != null) {
if (rockets != null && !rockets.isEmpty()) {
// TODO: only a certain number fired...
final Change change =
ChangeFactory.markNoMovementChange(Collections.singleton(rockets.iterator().next()));
bridge.addChange(change);
} else {
throw new IllegalStateException("No rockets?" + attackFrom.getUnits().getUnits());
}
}
// kill any units that can die if they have reached max damage (veqryn)
if (Match.someMatch(targets, Matches.UnitCanDieFromReachingMaxDamage)) {
final List<Unit> unitsCanDie =
Match.getMatches(targets, Matches.UnitCanDieFromReachingMaxDamage);
unitsCanDie.retainAll(
Match.getMatches(
unitsCanDie, Matches.UnitIsAtMaxDamageOrNotCanBeDamaged(attackedTerritory)));
if (!unitsCanDie.isEmpty()) {
// targets.removeAll(unitsCanDie);
final Change removeDead = ChangeFactory.removeUnits(attackedTerritory, unitsCanDie);
final String transcriptText =
MyFormatter.unitsToText(unitsCanDie) + " lost in " + attackedTerritory.getName();
bridge.getHistoryWriter().addChildToEvent(transcriptText, unitsCanDie);
bridge.addChange(removeDead);
}
}
// play a sound
if (cost > 0)
bridge
.getSoundChannelBroadcaster()
.playSoundForAll(SoundPath.CLIP_BOMBING_ROCKET, player.getName());
}