Class Combat

forge-game/src/main/java/forge/game/combat/Combat.java:59–1028

Combat class. @author Forge @version $Id$

 * @version $Id$
 */
public class Combat {
    private final Player playerWhoAttacks;
    private boolean legacyOrderCombatants;
    private AttackConstraints attackConstraints;
    // Defenders, as they are attacked by hostile forces
    private final Supplier<FCollection<GameEntity>> attackableEntries = Suppliers.memoize(FCollection::new);
    // Keyed by attackable defender (player or planeswalker or battle)
    private final Supplier<Multimap<GameEntity, AttackingBand>> attackedByBands = Suppliers.memoize(() -> Multimaps.synchronizedMultimap(ArrayListMultimap.create()));
    private final Supplier<Multimap<AttackingBand, Card>> blockedBands = Suppliers.memoize(() -> Multimaps.synchronizedMultimap(ArrayListMultimap.create()));
    private final Supplier<Map<Card, CardCollection>> attackersOrderedForDamageAssignment = Suppliers.memoize(Maps::newHashMap);
    private final Supplier<Map<Card, CardCollection>> blockersOrderedForDamageAssignment = Suppliers.memoize(Maps::newHashMap);
    private final Supplier<CardCollection> lkiCache = Suppliers.memoize(CardCollection::new);
    private final Supplier<CardDamageTable> damageMap = Suppliers.memoize(CardDamageTable::new);

    // List holds creatures who have dealt 1st strike damage to disallow them deal damage on regular basis (unless they have double-strike KW)
    private final Supplier<CardCollection> combatantsThatDealtFirstStrikeDamage = Suppliers.memoize(CardCollection::new);

    public Combat(final Player attacker) {
        playerWhoAttacks = attacker;
        legacyOrderCombatants = playerWhoAttacks.getGame().getRules().hasOrderCombatants();
        initConstraints();
    }

    public Combat(Combat combat, IEntityMap map) {
        playerWhoAttacks = map.map(combat.playerWhoAttacks);
        for (GameEntity entry : combat.attackableEntries.get()) {
            attackableEntries.get().add(map.map(entry));
        }

        HashMap<AttackingBand, AttackingBand> bandsMap = new HashMap<>();
        for (Entry<GameEntity, AttackingBand> entry : combat.attackedByBands.get().entries()) {
            AttackingBand origBand = entry.getValue();
            ArrayList<Card> attackers = new ArrayList<>();
            for (Card c : origBand.getAttackers()) {
                attackers.add(map.map(c));
            }
            AttackingBand newBand = new AttackingBand(attackers);
            Boolean blocked = entry.getValue().isBlocked();
            if (blocked != null) {
                newBand.setBlocked(blocked);
            }
            bandsMap.put(origBand, newBand);
            attackedByBands.get().put(map.map(entry.getKey()), newBand);
        }
        for (Entry<AttackingBand, Card> entry : combat.blockedBands.get().entries()) {
            blockedBands.get().put(bandsMap.get(entry.getKey()), map.map(entry.getValue()));
        }

        for (Entry<Card, CardCollection> entry : combat.attackersOrderedForDamageAssignment.get().entrySet()) {
            attackersOrderedForDamageAssignment.get().put(map.map(entry.getKey()), map.mapCollection(entry.getValue()));
        }
        for (Entry<Card, CardCollection> entry : combat.blockersOrderedForDamageAssignment.get().entrySet()) {
            blockersOrderedForDamageAssignment.get().put(map.map(entry.getKey()), map.mapCollection(entry.getValue()));
        }
        // Note: Doesn't currently set up lkiCache, since it's just a cache and not strictly needed...
        for (Table.Cell<Card, GameEntity, Integer> entry : combat.damageMap.get().cellSet()) {
            damageMap.get().put(map.map(entry.getRowKey()), map.map(entry.getColumnKey()), entry.getValue());
        }