FireFighterBehavior.java

package model.firefighter.behaviors;

import model.*;
import model.elementTokens.ChargeTarget;
import model.firefighter.FFBehavior;
import model.firefighter.ModelElement;
import model.firefighter.elements.Fire;
import model.firefighter.elements.FireFighter;
import model.genericBehavior.ChargerBehavior;
import model.genericBehavior.RemoverBehavior;
import model.genericBehavior.TangibleBehavior;
import util.Position;
import util.TargetStrategy;
import java.util.*;

public class FireFighterBehavior extends FFBehavior implements TangibleBehavior<ModelElement>, RemoverBehavior<ModelElement>, ChargerBehavior<ModelElement> {
    private List<ModelElement> obstacles=List.of(ModelElement.MOUNTAIN);
    private TargetStrategy ts=new TargetStrategy();
    private List chargeTarget=List.of(ModelElement.ROCK);

    List<Position> initializeTargets(BoardData boardData){
        List<Position> targets=new ArrayList<>();
        for (ModelElement me:ModelElement.values()) {
            if (me.isInstanceOf(Fire.class)){
                for (Element e:boardData.getElements().get(me.ordinal())) {
                    targets.add(e.getPosition());
                }}
        }
        return targets;
    }
    @Override
    public List<Position> update(BoardData boardData,Element element) {
        Position position=element.getPosition();
        List<Position> targets=initializeTargets(boardData);
        for (int i = 0; i<((FireFighter)element).speed; i++) {
            position=ts.neighborClosestToFire(position,targets,allLegalNeighbors(boardData));
            extinguish(boardData,position);
            targets.remove(position);
            targets.removeAll(boardData.getNeighbor(position));
        }
        return List.of(position);
    }

    @Override
    public List<ModelElement> getObstacles() {
        return obstacles;
    }

    @Override
    public Boolean isLegal(BoardData boardData, Position position) {
        for (Element e:boardData.getCell(position).Content) {
            for(ModelElement o:getObstacles())
                if (e.getType()==o) return false;
        }
        return  true;
    }

    public void extinguish(BoardData boardData, Position position){
        List<Position> l=new ArrayList<>(legalNeighbors(boardData,position));
        l.add(position);
        for (Position p:l) {
            List<Element> c=new ArrayList<>(boardData.getCell(p).Content);
            for (Element e:c) {
                if (e instanceof Fire){
                    boardData.removeElement(e);}
                if (chargeTarget.contains(e.getType()))
                    ((ChargeTarget)e).resetCounter();
            }
        }
    }
    @Override
    public List<Position> legalNeighbors(BoardData boardData,Position position) {
        List<Position> neighbors=new ArrayList<>(boardData.getNeighbor(position));
        for (Position p:boardData.getNeighbor(position)) {
            if (!isLegal(boardData,p)) neighbors.remove(p);
            }
        return neighbors;
    }
    @Override
    public Map<Position, List<Position>> allLegalNeighbors(BoardData boardData) {
        Map<Position, List<Position>> neighbors= new HashMap<>(Map.copyOf(boardData.getNeighbors()));
        for (Position pkey: boardData.getNeighbors().keySet()) {
            neighbors.replace(pkey,legalNeighbors(boardData,pkey));
        }
        return neighbors;
    }

    @Override
    public List getChargeTarget() {
        return chargeTarget;
    }

    @Override
    public Boolean isCharged(ChargeTarget chargeTarget) {
        return chargeTarget.isCharged();
    }
}