Vet.java

import processing.core.PImage;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.function.BiPredicate;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class Vet extends ActivityEntity implements Move, PathingStrategy {
    public Vet(String id, Point position, double animationPeriod, double actionPeriod, List<PImage> images) {
        super(id, position, animationPeriod, actionPeriod, images);
    }

    @Override
    public boolean moveTo(WorldModel world, Entity target, EventScheduler scheduler) {
        if (this.getPosition().adjacent(target.getPosition())) {
            world.removeEntity(scheduler, target);
            return true;
        } else {
            Point nextPos = this.nextPosition(world, target.getPosition());

            if (!this.getPosition().equals(nextPos)) {
                world.moveEntity(scheduler, this, nextPos);
            }
            return false;
        }
    }

    @Override
    public Point nextPosition(WorldModel world, Point destPos) {

        Predicate<Point> canPassThrough = p -> world.withinBounds(p)
                && (world.getOccupant(p).isEmpty() || world.getOccupant(getPosition()).get().getClass().equals(House.class));

        BiPredicate<Point, Point> withinReach = Point::adjacent;

        PathingStrategy strategy = new AStarPathingStrategy();
        List<Point> path = strategy.computePath(
                getPosition(),
                destPos,
                canPassThrough,
                withinReach,
                PathingStrategy.CARDINAL_NEIGHBORS
        );

        if (path == null || path.isEmpty()) {
            return getPosition();
        }

        return path.getFirst();
    }

    @Override
    public void executeActivity(WorldModel world, ImageStore imageStore, EventScheduler scheduler) {
        Optional<Entity> vetTarget = world.findNearest(getPosition(), new ArrayList<>(List.of(Steak.class, Bacon.class)));

        if (vetTarget.isPresent()) {
            Point tgtPos = vetTarget.get().getPosition();

            if (this.moveTo(world, vetTarget.get(), scheduler)) {
                if (vetTarget.get() instanceof Steak) {
                    BabyCow babyCow = Factory.createBabyCow(WorldLoader.BABY_COW_KEY + "_" + vetTarget.get().getId(), tgtPos, imageStore.getImageList(WorldLoader.BABY_COW_KEY));
                    world.tryAddEntity(babyCow);
                    babyCow.scheduleActions(scheduler, world, imageStore);
                } else {
                    BabyPig babyPig = Factory.createBabyPig(WorldLoader.BABY_PIG_KEY + "_" + vetTarget.get().getId(), tgtPos, imageStore.getImageList(WorldLoader.BABY_PIG_KEY));
                    world.tryAddEntity(babyPig);
                    babyPig.scheduleActions(scheduler, world, imageStore);
                }
            }
        }

        scheduler.scheduleEvent(this, Factory.createActivityAction(this, world, imageStore), getActionPeriod());
    }

    @Override
    public List<Point> computePath(Point start, Point end, Predicate<Point> canPassThrough, BiPredicate<Point, Point> withinReach, Function<Point, Stream<Point>> potentialNeighbors) {
        return null;
    }
}