Arakne / Araknemu

 * This file is part of Araknemu.

 *

 * Araknemu is free software: you can redistribute it and/or modify

 * it under the terms of the GNU Lesser General Public License as published by

 * the Free Software Foundation, either version 3 of the License, or

 * (at your option) any later version.

 *

 * Araknemu is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with Araknemu.  If not, see <https://www.gnu.org/licenses/>.

 *

 * Copyright (c) 2017-2021 Vincent Quatrevieux

 */

package fr.quatrevieux.araknemu.game.fight.ai.action.util;

import fr.arakne.utils.maps.CoordinateCell;

import fr.arakne.utils.maps.path.Decoder;

import fr.arakne.utils.maps.path.Path;

import fr.arakne.utils.maps.path.PathException;

import fr.arakne.utils.maps.path.Pathfinder;

import fr.quatrevieux.araknemu.game.fight.ai.AI;

import fr.quatrevieux.araknemu.game.fight.ai.action.ActionGenerator;

import fr.quatrevieux.araknemu.game.fight.fighter.ActiveFighter;

import fr.quatrevieux.araknemu.game.fight.map.FightCell;

import fr.quatrevieux.araknemu.game.fight.turn.action.Action;

import fr.quatrevieux.araknemu.game.fight.turn.action.factory.ActionsFactory;

import org.checkerframework.checker.nullness.qual.MonotonicNonNull;

import org.checkerframework.checker.nullness.util.NullnessUtil;

import java.util.ArrayList;

import java.util.List;

import java.util.Optional;

import java.util.function.Predicate;

import java.util.function.ToDoubleFunction;

/**

 * Try to select the best move action

 *

 * - Select reachable (i.e. walkable cells in MP range) cells. Note : pathfinding is not performed, so it's not warranty that cells are really reachable

 * - Sort cell by the score (ascending, lower score cells selected first)

 * - Iterates selected cells

 * - Filter cells (using filter predicate)

 * - Try to find the path

 * - If a path is found, and can be performed by the current number of MPs, return the move action

 */

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

    private final ToDoubleFunction<CoordinateCell<FightCell>> scoreFunction;

    private final Predicate<ScoredCell> filter;

    private @MonotonicNonNull Pathfinder<FightCell> pathfinder;

    /**

     * Creates the Movement action generator

     *

     * @param scoreFunction The score function. The returned score is used for select the best cell. Higher score are selected first.

     * @param filter The selection cell filter

     */

    public Movement(ToDoubleFunction<CoordinateCell<FightCell>> scoreFunction, Predicate<ScoredCell> filter) {

        this.scoreFunction = scoreFunction;

        this.filter = filter;

    }

    @Override

    public void initialize(AI<F> ai) {

        this.pathfinder = new Decoder<>(ai.map()).pathfinder();

    }

    /**

     * Select all reachable cells for movement

     */

    private List<ScoredCell> selectCells(AI<F> ai, int movementPoints) {

        final CoordinateCell<FightCell> currentCell = ai.fighter().cell().coordinate();

        final List<ScoredCell> selectedCells = new ArrayList<>();

        for (FightCell cell : ai.map()) {

            if (!cell.walkable()) {

                continue;

            }

            final CoordinateCell<FightCell> coordinates = cell.coordinate();

            if (coordinates.distance(currentCell) > movementPoints) {

                continue;

            }

            selectedCells.add(new ScoredCell(coordinates, scoreFunction.applyAsDouble(coordinates)));

        }

        return selectedCells;

    }

    public static final class ScoredCell implements Comparable<ScoredCell> {

        private final CoordinateCell<FightCell> coordinates;

        private final double score;

        public ScoredCell(CoordinateCell<FightCell> coordinates, double score) {

            this.coordinates = coordinates;

            this.score = score;

        }

        /**

         * Get the cell coordinates

         */

        public CoordinateCell<FightCell> coordinates() {

            return coordinates;

        }

        /**

         * Get the cell score

         * Higher score are prioritized

         */

        public double score() {

            return score;

        }

        @Override

        public int compareTo(ScoredCell o) {

            return Double.compare(o.score, score);

        }

    }

}