Simplification/Unification of StaticAbility variants

[Hanmac]

Example:

forge/forge-game/src/main/java/forge/game/staticability/StaticAbilityCantAttach.java

Lines 9 to 21 in 5972acb

	public static StaticAbility cantAttach(final GameEntity target, final Card card, boolean checkSBA) {
	// CantTarget static abilities
	for (final Card ca : target.getGame().getCardsIn(ZoneType.STATIC_ABILITIES_SOURCE_ZONES)) {
	for (final StaticAbility stAb : ca.getStaticAbilities()) {
	if (!stAb.checkConditions(StaticAbilityMode.CantAttach)) {
	continue;
	}
	if (applyCantAttachAbility(stAb, card, target, checkSBA)) {
	return stAb;
	}
	}
	}

most of the uses in these Static classes return a boolean if some static ability gets triggered by it
(in some cases, like this one, it returns the first one that does trigger it)

So shouldn't it be possible to make a helper version that uses stream of it?

Like this part is nearly identical in most versions (+some use extra LKI, but these can be added)
target.getGame().getCardsIn(ZoneType.STATIC_ABILITIES_SOURCE_ZONES).stream().flatMap(c -> c.getStaticAbilities().stream())

And then use anyMatch/filter with a Predicate like this?
stAb -> stAb.checkConditions(StaticAbilityMode.CantAttach) && applyCantAttachAbility(stAb, card, target, checkSBA)

Maybe do the Mode check in a filter first?

[kojotak]

I was tempted (in #10219 , #10187 ) to try something like this in StaticAbilityMode:

    Stream<StaticAbility> streamStaticAbilities(final GameEntity entity) {
        return entity.getGame()
                .getCardsIn(ZoneType.STATIC_ABILITIES_SOURCE_ZONES)
                .stream()
                .flatMap(card -> card.getStaticAbilities().stream())
                .filter(stAb -> stAb.checkConditions(this));
    }

and introduce StaticAbilityPredicate with:

    static Predicate<StaticAbility> validPlayer(Player player) {
        return stAb -> stAb.matchesValidParam("ValidPlayer", player);
    }

    static Predicate<StaticAbility> validCard(Card card) {
        return stAb -> stAb.matchesValidParam("ValidCard", card);
    }

    static Predicate<StaticAbility> target(GameEntity target) {
        return stAb -> stAb.matchesValidParam("Target", target);
    }

then the example StaticAbilityCantAttach from the description would look like this:

    public static StaticAbility cantAttach(final GameEntity target, final Card card, boolean checkSBA) {
        return StaticAbilityMode.CantAttach.streamStaticAbilities(target)
                .filter(StaticAbilityPredicate.validCard(card))
                .filter(StaticAbilityPredicate.target(target))
                .filter(stAb -> applyCantAttachAbility(stAb, card, target, checkSBA)) 
                .findAny()
                .orElse(null);
    }

where applyCantAttachAbility contains only the mode specific logic.