Examples with PermanentInListPredicate mage.filter.predicate.permanent.PermanentInListPredicate used on opensource projects

Example 6 with PermanentInListPredicate

use of mage.filter.predicate.permanent.PermanentInListPredicate in project mage by magefree.

the class CamouflageEffect method applies.

@Override
public boolean applies(GameEvent event, Ability source, Game game) {
    Player controller = game.getPlayer(source.getControllerId());
    if (controller != null) {
        Map<UUID, List<List<Permanent>>> masterMap = new HashMap<>();
        // and divides them into a number of piles equal to the number of attacking creatures for whom that player is the defending player (piles can be empty)
        for (UUID defenderId : game.getCombat().getPlayerDefenders(game)) {
            Player defender = game.getPlayer(defenderId);
            if (defender != null) {
                List<List<Permanent>> masterList = new ArrayList<>();
                int attackerCount = 0;
                for (CombatGroup combatGroup : game.getCombat().getGroups()) {
                    if (combatGroup.getDefendingPlayerId().equals(defenderId)) {
                        attackerCount += combatGroup.getAttackers().size();
                    }
                }
                // This shouldn't be necessary, but just in case
                for (Permanent permanent : game.getBattlefield().getAllActivePermanents(new FilterCreaturePermanent(), defenderId, game)) {
                    permanent.setBlocking(0);
                }
                boolean declinedChoice = false;
                while (masterList.size() < attackerCount) {
                    List<Permanent> newPile = new ArrayList<>();
                    if (!declinedChoice) {
                        FilterControlledCreaturePermanent filter = new FilterControlledCreaturePermanent("creatures you control not yet assigned to a pile");
                        for (List<Permanent> list : masterList) {
                            // Creatures they control that can block additional creatures may likewise be put into additional piles.
                            // (This temporarily manipulates Blocking values to "test" how many blockers the creature has still left to assign)
                            List<Permanent> spentBlockers = new ArrayList<>();
                            for (Permanent possibleBlocker : list) {
                                if (possibleBlocker.getMaxBlocks() != 0 && possibleBlocker.getBlocking() >= possibleBlocker.getMaxBlocks()) {
                                    spentBlockers.add(possibleBlocker);
                                }
                            }
                            filter.add(Predicates.not(new PermanentInListPredicate(spentBlockers)));
                        }
                        if (defender.chooseUse(Outcome.Neutral, "Make a new blocker pile? If not, all remaining piles stay empty. (remaining piles: " + (attackerCount - masterList.size()) + ')', source, game)) {
                            Target target = new TargetControlledCreaturePermanent(0, Integer.MAX_VALUE, filter, true);
                            if (target.canChoose(source.getSourceId(), defenderId, game)) {
                                if (defender.chooseTarget(Outcome.Neutral, target, source, game)) {
                                    for (UUID creatureId : target.getTargets()) {
                                        Permanent creature = game.getPermanent(creatureId);
                                        if (creature != null) {
                                            creature.setBlocking(creature.getBlocking() + 1);
                                            newPile.add(creature);
                                        }
                                    }
                                }
                            }
                        } else {
                            declinedChoice = true;
                        }
                    }
                    masterList.add(newPile);
                    StringBuilder sb = new StringBuilder("Blocker pile of ").append(defender.getLogName()).append(" (no. " + masterList.size() + "): ");
                    int i = 0;
                    for (Permanent permanent : newPile) {
                        i++;
                        sb.append(permanent.getLogName());
                        if (i < newPile.size()) {
                            sb.append(", ");
                        }
                    }
                    game.informPlayers(sb.toString());
                }
                // Clear all test Blocking values before assigning piles
                for (Permanent permanent : game.getBattlefield().getAllActivePermanents(new FilterCreaturePermanent(), defenderId, game)) {
                    permanent.setBlocking(0);
                }
                masterMap.put(defenderId, masterList);
            }
        }
        // Assign each pile to a different one of those attacking creatures at random. Each creature in a pile that can block the creature that pile is assigned to does so
        if (!masterMap.isEmpty()) {
            for (UUID playerId : masterMap.keySet()) {
                List<Permanent> available = new ArrayList<>();
                for (CombatGroup combatGroup : game.getCombat().getGroups()) {
                    if (combatGroup.getDefendingPlayerId().equals(playerId)) {
                        for (UUID attackerId : combatGroup.getAttackers()) {
                            Permanent permanent = game.getPermanent(attackerId);
                            if (permanent != null && permanent.isCreature(game)) {
                                available.add(permanent);
                            }
                        }
                    }
                }
                List<List<Permanent>> allPiles = masterMap.get(playerId);
                for (List<Permanent> pile : allPiles) {
                    if (available.isEmpty()) {
                        break;
                    }
                    int randomAttacker = RandomUtil.nextInt(available.size());
                    Permanent attacker = available.get(randomAttacker);
                    if (attacker != null) {
                        available.remove(randomAttacker);
                        for (Permanent blocker : pile) {
                            CombatGroup group = game.getCombat().findGroup(attacker.getId());
                            if (group != null) {
                                if (blocker.canBlock(attacker.getId(), game) && (blocker.getMaxBlocks() == 0 || group.getAttackers().size() <= blocker.getMaxBlocks())) {
                                    boolean notYetBlocked = group.getBlockers().isEmpty();
                                    group.addBlockerToGroup(blocker.getId(), blocker.getControllerId(), game);
                                    game.getCombat().addBlockingGroup(blocker.getId(), attacker.getId(), blocker.getControllerId(), game);
                                    if (notYetBlocked) {
                                        game.fireEvent(GameEvent.getEvent(GameEvent.EventType.CREATURE_BLOCKED, attacker.getId(), source, null));
                                    }
                                    // TODO: find an alternate event solution for multi-blockers (as per issue #4285), this will work fine for single blocker creatures though
                                    game.fireEvent(new BlockerDeclaredEvent(attacker.getId(), blocker.getId(), blocker.getControllerId()));
                                }
                            }
                        }
                    }
                }
            }
        }
        return true;
    }
    return false;
}