Arakne / Araknemu

public final class TeleportNearEnemy<F extends ActiveFighter> implements ActionGenerator<F> {

    private List<Spell> teleportSpells = Collections.emptyList();

    @Override

    public void initialize(AI<F> ai) {

        final SpellsHelper helper = ai.helper().spells();

        teleportSpells = helper

            .withEffect(4)

            .sorted(Comparator.comparingInt(Castable::apCost))

            .collect(Collectors.toList())

        ;

    }

    @Override

    public Optional<Action> generate(AI<F> ai, ActionsFactory<F> actions) {

        if (teleportSpells.isEmpty()) {

            return Optional.empty();

        }

        final int actionPoints = ai.turn().points().actionPoints();

        if (actionPoints < 1) {

            return Optional.empty();

        }

        final Optional<? extends PassiveFighter> enemy = ai.enemy();

        if (!enemy.isPresent()) {

            return Optional.empty();

        }

        final SpellCaster caster = ai.helper().spells().caster(actions.cast().validator());

        final Selector selector = new Selector(enemy.get().cell(), ai.fighter().cell());

        // Already at adjacent cell of the enemy

        if (selector.adjacent()) {

            return Optional.empty();

        }

        // Spells are ordered by AP cost : the first spell which can reach an accessible adjacent is necessarily the best spell

        for (Spell spell : teleportSpells) {

            if (spell.apCost() > actionPoints) {

                break; // Following spells have an higher cost

            }

            if (selectBestTeleportTargetForSpell(caster, selector, ai.map(), spell)) {

                return selector.action(ai.fighter(), actions);

            }

        }

        return selector.action(ai.fighter(), actions);

    }

    /**

     * Select the best possible target for the given spell

     * The result will be push()'ed into selector

     *

     * @return true if the spell can reach an adjacent cell

     */

    private boolean selectBestTeleportTargetForSpell(SpellCaster caster, Selector selector, BattlefieldMap map, Spell spell) {

        for (FightCell cell : map) {

            // Target or launch is not valid

            if (!cell.walkable() || !caster.validate(spell, cell)) {

                continue;

            }

            // Adjacent cell found : no need to continue

            if (selector.push(spell, cell)) {

                return true;

            }

        }

        return false;

    }

    /**

     * Select the best spell and cell couple for teleport

     */

    private class Selector {

        private final CoordinateCell<FightCell> enemyCell;

        private int distance;

        private @MonotonicNonNull FightCell cell;

        private @MonotonicNonNull Spell spell;

        public Selector(FightCell enemyCell, FightCell currentCell) {

            this.enemyCell = enemyCell.coordinate();

            this.distance = this.enemyCell.distance(currentCell);

        }

        /**

         * Check if the current cell is adjacent to the enemy cell

         */

        public boolean adjacent() {

            return distance == 1;

        }

        /**

         * Push the teleport parameters and check if there are better than the previous

         *

         * @return true if the new cell is adjacent to the target

         */

        public boolean push(Spell spell, FightCell cell) {

            final int currentDistance = enemyCell.distance(cell);

            if (currentDistance < distance) {

                this.spell = spell;

                this.cell = cell;

                this.distance = currentDistance;

            }

            return adjacent();

        }

        /**

         * Get the best cast action

         * May returns an empty optional if no teleport spell can be found, or if the fighter is already on the best cell

         */

        public Optional<Action> action(F fighter, ActionsFactory<F> actions) {

            if (spell == null || cell == null) {

                return Optional.empty();

            }

            return Optional.of(actions.cast().create(fighter, spell, cell));