From 770fe6c49684bd4a336e87c948e0e17a5b7d891e Mon Sep 17 00:00:00 2001 From: ScarletRedMan Date: Wed, 30 Apr 2025 18:18:59 +0700 Subject: [PATCH] feat: attempt to reimplement entity AI --- .../java/ru/dragonestia/msb3/api/ai/AI.java | 174 ++++++++++++++++++ .../ru/dragonestia/msb3/api/ai/Actor.java | 81 ++++++++ .../msb3/api/ai/action/Action.java | 43 +++++ .../action/LookClosePlayersAction.java} | 51 +++-- .../msb3/api/ai/action/PatrolAction.java | 105 +++++++++++ .../api/ai/navigator/DestinationPoint.java | 7 + .../msb3/api/ai/navigator/Path.java | 60 ++++++ .../msb3/api/ai/navigator/PathGenerator.java | 134 ++++++++++++++ .../msb3/api/ai/navigator/PathNode.java | 125 +++++++++++++ .../msb3/api/ai/navigator/PathState.java | 50 +++++ .../follower/GroundNodeFollower.java | 66 +++++++ .../ai/navigator/follower/NodeFollower.java | 15 ++ .../navigator/node/GroundNodeGenerator.java | 128 +++++++++++++ .../api/ai/navigator/node/NodeGenerator.java | 46 +++++ .../msb3/api/boot/DebugAiBootstrap.java | 50 +++++ .../dragonestia/msb3/api/entity/EntityAI.java | 78 ++++++++ .../ru/dragonestia/msb3/api/entity/Human.java | 3 +- .../player/defaults/DebugParamsContext.java | 10 +- .../script/defaults/SpawnTestActorScript.java | 40 ++++ 19 files changed, 1233 insertions(+), 33 deletions(-) create mode 100644 api/src/main/java/ru/dragonestia/msb3/api/ai/AI.java create mode 100644 api/src/main/java/ru/dragonestia/msb3/api/ai/Actor.java create mode 100644 api/src/main/java/ru/dragonestia/msb3/api/ai/action/Action.java rename api/src/main/java/ru/dragonestia/msb3/api/{entity/goal/LookCloseGoal.java => ai/action/LookClosePlayersAction.java} (55%) create mode 100644 api/src/main/java/ru/dragonestia/msb3/api/ai/action/PatrolAction.java create mode 100644 api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/DestinationPoint.java create mode 100644 api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/Path.java create mode 100644 api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/PathGenerator.java create mode 100644 api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/PathNode.java create mode 100644 api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/PathState.java create mode 100644 api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/follower/GroundNodeFollower.java create mode 100644 api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/follower/NodeFollower.java create mode 100644 api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/node/GroundNodeGenerator.java create mode 100644 api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/node/NodeGenerator.java create mode 100644 api/src/main/java/ru/dragonestia/msb3/api/boot/DebugAiBootstrap.java create mode 100644 api/src/main/java/ru/dragonestia/msb3/api/entity/EntityAI.java create mode 100644 api/src/main/java/ru/dragonestia/msb3/api/script/defaults/SpawnTestActorScript.java diff --git a/api/src/main/java/ru/dragonestia/msb3/api/ai/AI.java b/api/src/main/java/ru/dragonestia/msb3/api/ai/AI.java new file mode 100644 index 0000000..f64927c --- /dev/null +++ b/api/src/main/java/ru/dragonestia/msb3/api/ai/AI.java @@ -0,0 +1,174 @@ +package ru.dragonestia.msb3.api.ai; + +import lombok.Getter; +import lombok.Setter; +import net.minestom.server.coordinate.Point; +import net.minestom.server.coordinate.Pos; +import net.minestom.server.coordinate.Vec; +import ru.dragonestia.msb3.api.ai.navigator.*; +import ru.dragonestia.msb3.api.ai.navigator.follower.GroundNodeFollower; +import ru.dragonestia.msb3.api.ai.navigator.follower.NodeFollower; +import ru.dragonestia.msb3.api.ai.navigator.node.GroundNodeGenerator; +import ru.dragonestia.msb3.api.ai.navigator.node.NodeGenerator; +import ru.dragonestia.msb3.api.entity.EntityAI; +import ru.dragonestia.msb3.api.util.UncheckedRunnable; + +import java.util.Objects; +import java.util.concurrent.CompletableFuture; + +@Getter +public class AI { + + private final EntityAI entity; + private DestinationPoint destinationData; + @Setter private NodeGenerator nodeGenerator = new GroundNodeGenerator(); + @Setter private NodeFollower nodeFollower; + @Getter private final Actor actor; + + public AI(EntityAI entity) { + this.entity = Objects.requireNonNull(entity, "AI is null"); + nodeFollower = new GroundNodeFollower(entity); + actor = new Actor(entity); + } + + public PathState getCurrentPathState() { + synchronized (this) { + if (destinationData == null) return PathState.NONE; + return destinationData.path().getState(); + } + } + + public CompletableFuture setPathTo(Point point) { + var bb = entity.getBoundingBox(); + var centerToCorner = Math.sqrt(bb.width() * bb.width() + bb.depth() * bb.depth()) / 2; + return setPathTo(point, centerToCorner); + } + + public CompletableFuture setPathTo(Point point, double arrivalDistance) { + return setPathTo(point, arrivalDistance, 50, 20); + } + + public CompletableFuture setPathTo(Point point, double arrivalDistance, double maxDistance, double pathVariance) { + Objects.requireNonNull(point, "Point is null"); + var instance = Objects.requireNonNull(entity.getInstance(), "Entity is not spawned"); + if (!instance.getWorldBorder().inBounds(point)) + throw new IllegalStateException("Destination point is not in world bounds"); + if (!instance.isChunkLoaded(point)) + throw new IllegalStateException("Chunk is not loaded for destination point"); + + + synchronized (this) { + // Завершаем активное следование к точке + if (destinationData != null) { + var data = destinationData; + destinationData = null; + + UncheckedRunnable.runIgnoreException(() -> data.future().complete(PathState.TERMINATED)); + } + + // Игрок находится рядом с точкой, куда нужно прийти + if (entity.getDistanceSquared(point) <= arrivalDistance * arrivalDistance) { + return CompletableFuture.completedFuture(PathState.COMPLETED); + } + + // Проверка находится ли точка слишком далеко + if (entity.getDistanceSquared(point) > Math.pow(maxDistance - arrivalDistance / 2, 2)) { + return CompletableFuture.completedFuture(PathState.TOO_FAR); + } + + // Начинаем просчет пути до новой точки + var path = PathGenerator.generate(instance, + entity.getPosition(), + point, + arrivalDistance, + maxDistance, + pathVariance, + entity.getBoundingBox(), + entity.isOnGround(), + nodeGenerator); + + // Если на время просчета пути уже известен результат действия + if (path.getState().isCompleted()) { + return CompletableFuture.completedFuture(path.getState()); + } + + return (destinationData = new DestinationPoint(Vec.fromPoint(point), arrivalDistance, path, new CompletableFuture<>())) + .future().thenApply(result -> { + resetDestinationData(); + return result; + }); + } + } + + public void tick(long delta) { + synchronized (this) { + if (entity.isDead()) return; + + var action = actor.getCurrentAction(); + if (action != null) action.tick(actor, entity, delta); + + if (destinationData != null) tickNavigator(); + } + } + + private void tickNavigator() { + if (entity.getPosition().distance(destinationData.position()) < destinationData.arrivalDistance()) { + var future = destinationData.future(); + UncheckedRunnable.runIgnoreException(() -> future.complete(PathState.COMPLETED)); + return; + } + + var path = destinationData.path(); + var currentTarget = path.getCurrent(); + var nextTarget = path.getNext(); + + if (currentTarget == null || path.getCurrentType() == PathNode.Type.REPATH || path.getCurrentType() == null) { + recalculatePath(path); + return; + } + + if (nextTarget == null) nextTarget = destinationData.position(); + + boolean nextIsRePath = nextTarget.sameBlock(Pos.ZERO); + nodeFollower.moveTowards(currentTarget, nodeFollower.movementSpeed(), nextIsRePath ? currentTarget : nextTarget); + // TODO: исправить баг, в данном месте, когда Entity не движется вообще. Сделать хорошую проверку на застревание + // TODO: присутствует баг, что если как-то помешать Entity следовать до точки, например поставить перед ним блок, то он перестанет идти + // TODO: хождение по неполноценным блокам - огромная проблема. Entity попросту застревает в них + + if (nodeFollower.isAtPoint(currentTarget)) path.next(); + else if (path.getCurrentType() == PathNode.Type.JUMP) nodeFollower.jump(currentTarget, nextTarget); + checkFinishedPath(path, destinationData.future()); + } + + private void recalculatePath(Path originalPath) { + var newPath = PathGenerator.generate(entity.getInstance(), + entity.getPosition(), + destinationData.position(), + destinationData.arrivalDistance(), originalPath.getMaxDistance(), + originalPath.getPathVariance(), entity.getBoundingBox(), entity.isOnGround(), nodeGenerator); + + destinationData = new DestinationPoint(destinationData.position(), destinationData.arrivalDistance(), newPath, destinationData.future()); + checkFinishedPath(newPath, destinationData.future()); + } + + private void checkFinishedPath(Path path, CompletableFuture future) { + var state = path.getState(); + if (state.isCompleted()) { + UncheckedRunnable.runIgnoreException(() -> future.complete(state)); + } + } + + public void resetDestinationData() { + synchronized (this) { + if (destinationData == null) return; + + var future = destinationData.future(); + destinationData = null; + if (!future.isDone()) future.complete(PathState.TERMINATED); + } + } + + public boolean isCompleted() { + return getCurrentPathState().isCompleted(); + } +} diff --git a/api/src/main/java/ru/dragonestia/msb3/api/ai/Actor.java b/api/src/main/java/ru/dragonestia/msb3/api/ai/Actor.java new file mode 100644 index 0000000..db09758 --- /dev/null +++ b/api/src/main/java/ru/dragonestia/msb3/api/ai/Actor.java @@ -0,0 +1,81 @@ +package ru.dragonestia.msb3.api.ai; + +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.Setter; +import ru.dragonestia.msb3.api.ai.action.Action; +import ru.dragonestia.msb3.api.entity.EntityAI; + +import java.util.Collection; +import java.util.LinkedList; + +/** + * Класс для управления планированием расписания действий для сущности + */ +@RequiredArgsConstructor +public class Actor { + + @Getter private final EntityAI entity; + @Getter @Setter private boolean active = false; + @Getter private Action currentAction; + private final LinkedList plannedActions = new LinkedList<>(); + + private void tryStartAction(Action action) { + if (isActive()) action.start(this, entity); + } + + private void tryEndAction(Action action) { + if (isActive()) action.stop(this, entity); + } + + /** + * Принудительно установить действие для исполнения сущностью. Данная установка игнорирует проверки начала действия. + * @param newAction Новое действие + * @apiNote Если передать null, то текущее действие прервется и приостановится выполнение действий из плана + */ + public void setCurrentAction(Action newAction) { + if (currentAction != null) tryEndAction(currentAction); + currentAction = newAction; + if (newAction != null) tryStartAction(newAction); + } + + /** + * Принудительно установить действие для исполнения сущностью и при этом текущее действие помещается в + * план действий в самое начало. Использовать, для того чтобы прервать выполнение текущего действия, + * переключиться на другое и снова вернуться к той задаче, которую он изначально выполнял + * @param newAction Новое действие + */ + public void setCurrentActionAndRememberPrev(Action newAction) { + if (currentAction != null) plannedActions.addFirst(currentAction); + setCurrentAction(newAction); + } + + /** + * Завершить текущее действие и перейти к следующему исходя из плана + */ + public void useNextAction() { + while (true) { + var action = plannedActions.poll(); + if (action == null) break; // TODO: добавлять действия из генератора расписаний + if (!action.canStart(this, entity)) continue; // Действие не может начаться, так как условие не выполняется + setCurrentAction(action); + } + } + + /** + * Добавить действие в план выполнения. Если у сущности нет текущей задачи, то оно приступит к задаче сразу же + * @param action Действие + */ + public void addNextAction(Action action) { + plannedActions.add(action); + if (currentAction == null) useNextAction(); + } + + /** + * Получить план действий для сущности + * @return План действий + */ + public Collection getPlannedActions() { + return plannedActions; + } +} diff --git a/api/src/main/java/ru/dragonestia/msb3/api/ai/action/Action.java b/api/src/main/java/ru/dragonestia/msb3/api/ai/action/Action.java new file mode 100644 index 0000000..eb1a429 --- /dev/null +++ b/api/src/main/java/ru/dragonestia/msb3/api/ai/action/Action.java @@ -0,0 +1,43 @@ +package ru.dragonestia.msb3.api.ai.action; + +import ru.dragonestia.msb3.api.ai.Actor; +import ru.dragonestia.msb3.api.entity.EntityAI; + +public interface Action { + + /** + * Получить имя действия, которое примерно описывает что должна делать сущность + * @return Имя действия + */ + String getName(); + + /** + * Действие начало выполнение + * @param actor Действующее лицо + * @param entity Действующая сущность + */ + void start(Actor actor, EntityAI entity); + + /** + * Выполнение действия раз в тик + * @param actor Действующее лицо + * @param entity Действующая сущность + * @param delta Сколько времени (в миллисекундах) прошло с предыдущего тика + */ + void tick(Actor actor, EntityAI entity, long delta); + + /** + * Остановка действия + * @param actor Действующее лицо + * @param entity Действующая сущность + */ + void stop(Actor actor, EntityAI entity); + + /** + * Может ли действие начаться? Данная проверка выполняется только, если действие находится в очереди действий + * @param actor Действующее лицо + * @param entity Действующая сущность + * @return Результат проверки + */ + boolean canStart(Actor actor, EntityAI entity); +} diff --git a/api/src/main/java/ru/dragonestia/msb3/api/entity/goal/LookCloseGoal.java b/api/src/main/java/ru/dragonestia/msb3/api/ai/action/LookClosePlayersAction.java similarity index 55% rename from api/src/main/java/ru/dragonestia/msb3/api/entity/goal/LookCloseGoal.java rename to api/src/main/java/ru/dragonestia/msb3/api/ai/action/LookClosePlayersAction.java index de6f120..dec717a 100644 --- a/api/src/main/java/ru/dragonestia/msb3/api/entity/goal/LookCloseGoal.java +++ b/api/src/main/java/ru/dragonestia/msb3/api/ai/action/LookClosePlayersAction.java @@ -1,43 +1,42 @@ -package ru.dragonestia.msb3.api.entity.goal; +package ru.dragonestia.msb3.api.ai.action; import lombok.Getter; import lombok.Setter; -import net.minestom.server.entity.EntityCreature; import net.minestom.server.entity.Player; -import net.minestom.server.entity.ai.GoalSelector; -import org.jetbrains.annotations.NotNull; +import ru.dragonestia.msb3.api.ai.Actor; +import ru.dragonestia.msb3.api.entity.EntityAI; -public class LookCloseGoal extends GoalSelector { +/** + * Entity смотрит на ближайшего игрока в радиусе 7 блоков + */ +public class LookClosePlayersAction implements Action { private final static int MAX_DIST = 7 * 7; @Setter @Getter private volatile boolean enabled = false; + private boolean lastSeePlayer = false; @Getter private float defaultYaw; @Getter private float defaultPitch; - public LookCloseGoal(@NotNull EntityCreature entityCreature) { - super(entityCreature); - - defaultYaw = entityCreature.getPosition().yaw(); - defaultPitch = entityCreature.getPosition().pitch(); + @Override + public String getName() { + return "Смотрит на ближайших игроков"; } @Override - public boolean shouldStart() { - return true; + public void start(Actor actor, EntityAI entity) { + defaultYaw = entity.getPosition().yaw(); + defaultPitch = entity.getPosition().pitch(); } @Override - public void start() {} - - @Override - public void tick(long l) { - if ((l & 0b11) == 0) return; + public void tick(Actor actor, EntityAI entity, long delta) { + if ((delta & 0b11) == 0) return; if (!enabled) { if (lastSeePlayer) { - entityCreature.setView(defaultYaw, defaultPitch); + entity.setView(defaultYaw, defaultPitch); lastSeePlayer = false; } return; @@ -46,8 +45,8 @@ public class LookCloseGoal extends GoalSelector { Player closestPlayer = null; double closestDistance = Double.MAX_VALUE; - for (var player: entityCreature.getViewers()) { - var distance = player.getPosition().distanceSquared(entityCreature.getPosition()); + for (var player: entity.getViewers()) { + var distance = player.getPosition().distanceSquared(entity.getPosition()); if (distance > MAX_DIST) continue; if (distance < closestDistance) { @@ -57,24 +56,24 @@ public class LookCloseGoal extends GoalSelector { } if (closestPlayer != null) { - entityCreature.lookAt(closestPlayer); + entity.lookAt(closestPlayer); lastSeePlayer = true; return; } if (lastSeePlayer) { - entityCreature.setView(defaultYaw, defaultPitch); + entity.setView(defaultYaw, defaultPitch); lastSeePlayer = false; } } @Override - public boolean shouldEnd() { - return false; - } + public void stop(Actor actor, EntityAI entity) {} @Override - public void end() {} + public boolean canStart(Actor actor, EntityAI entity) { + return true; + } public void setDefaultRotation(float yaw, float pitch) { defaultYaw = yaw; diff --git a/api/src/main/java/ru/dragonestia/msb3/api/ai/action/PatrolAction.java b/api/src/main/java/ru/dragonestia/msb3/api/ai/action/PatrolAction.java new file mode 100644 index 0000000..e48eca8 --- /dev/null +++ b/api/src/main/java/ru/dragonestia/msb3/api/ai/action/PatrolAction.java @@ -0,0 +1,105 @@ +package ru.dragonestia.msb3.api.ai.action; + +import lombok.Getter; +import lombok.Setter; +import net.minestom.server.coordinate.Pos; +import net.minestom.server.coordinate.Vec; +import ru.dragonestia.msb3.api.ai.Actor; +import ru.dragonestia.msb3.api.ai.navigator.PathState; +import ru.dragonestia.msb3.api.entity.EntityAI; +import ru.dragonestia.msb3.api.scheduler.Scheduler; + +import java.time.Duration; +import java.util.ArrayList; +import java.util.List; + +/** + * Entity патрулирует местность по заданному маршруту + */ +public class PatrolAction implements Action { + + @Getter private final List path = new ArrayList<>(); + @Getter @Setter private double destinationRadius = 1; + @Getter private Vec currentPos; + private boolean increment = true; + private int posNumber = 0; + private EntityAI entity; + + @Override + public String getName() { + return "Патрулирование территории"; + } + + @Override + public void start(Actor actor, EntityAI entity) { + walkToNextPos(entity); + this.entity = entity; + } + + @Override + public void tick(Actor actor, EntityAI entity, long delta) {} + + @Override + public void stop(Actor actor, EntityAI entity) { + entity.getAi().resetDestinationData(); + this.entity = null; + } + + @Override + public boolean canStart(Actor actor, EntityAI entity) { + return findNearestPos(entity) != null; + } + + public void setPath(List newPath) { + posNumber = 0; + increment = true; + path.clear(); + path.addAll(newPath); + + if (entity != null) walkToNextPos(entity); + } + + private Vec findNearestPos(EntityAI entity) { + if (entity == null) return path.getFirst(); + + Vec nearest = null; + double dist = Double.MAX_VALUE; + for (var pos: path) { + var currentDist = entity.getDistance(pos); + if (currentDist < dist) nearest = pos; + } + return nearest; + } + + private Vec useNextPos() { + int nextIndex = posNumber + (increment? 1 : -1); + if (nextIndex >= path.size()) increment = false; + if (nextIndex < 0) increment = true; + posNumber = posNumber + (increment? 1 : -1); + return currentPos = path.get(posNumber); + } + + private void walkToNextPos(EntityAI entity) { + var nextPos = useNextPos(); + var navigator = entity.getAi(); + + navigator.setPathTo(nextPos, destinationRadius) + .thenAccept(result -> { + if (result == PathState.TERMINATED) return; + if (result == PathState.TOO_FAR) { + Scheduler.ofEntity(entity).delayedTask(() -> { + entity.teleport(Pos.fromPoint(nextPos)) + .thenRun(() -> walkToNextPos(entity)); + }, Duration.ofSeconds(1)); + return; + } + if (result == PathState.DEADLOCKED) { + entity.teleport(Pos.fromPoint(nextPos)) + .thenRun(() -> walkToNextPos(entity)); + return; + } + + walkToNextPos(entity); + }); + } +} diff --git a/api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/DestinationPoint.java b/api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/DestinationPoint.java new file mode 100644 index 0000000..0cb22d2 --- /dev/null +++ b/api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/DestinationPoint.java @@ -0,0 +1,7 @@ +package ru.dragonestia.msb3.api.ai.navigator; + +import net.minestom.server.coordinate.Vec; + +import java.util.concurrent.CompletableFuture; + +public record DestinationPoint(Vec position, double arrivalDistance, Path path, CompletableFuture future) {} diff --git a/api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/Path.java b/api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/Path.java new file mode 100644 index 0000000..bba183b --- /dev/null +++ b/api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/Path.java @@ -0,0 +1,60 @@ +package ru.dragonestia.msb3.api.ai.navigator; + +import lombok.Getter; +import net.minestom.server.coordinate.Point; +import net.minestom.server.coordinate.Vec; +import org.jetbrains.annotations.Nullable; + +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.atomic.AtomicReference; + +public class Path { + + @Getter private final double maxDistance; + @Getter private final double pathVariance; + @Getter private final List nodes = new ArrayList<>(); + private final AtomicReference state = new AtomicReference<>(PathState.FOLLOWING); + private int index = 0; + + public Path(double maxDistance, double pathVariance) { + this.maxDistance = maxDistance; + this.pathVariance = pathVariance; + } + + public PathState getState() { + return state.get(); + } + + public void setState(PathState newState) { + state.set(newState); + } + + @Override + public String toString() { + return nodes.toString(); + } + + public @Nullable PathNode.Type getCurrentType() { + if (index >= nodes.size()) return null; + var current = nodes.get(index); + return current.getType(); + } + + public @Nullable Point getCurrent() { + if (index >= nodes.size()) return null; + var current = nodes.get(index); + return new Vec(current.x(), current.y(), current.z()); + } + + public void next() { + if (index >= nodes.size()) return; + index++; + } + + public Point getNext() { + if (index + 1 >= nodes.size()) return null; + var current = nodes.get(index + 1); + return new Vec(current.x(), current.y(), current.z()); + } +} diff --git a/api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/PathGenerator.java b/api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/PathGenerator.java new file mode 100644 index 0000000..83a8410 --- /dev/null +++ b/api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/PathGenerator.java @@ -0,0 +1,134 @@ +package ru.dragonestia.msb3.api.ai.navigator; + +import it.unimi.dsi.fastutil.objects.ObjectHeapPriorityQueue; +import it.unimi.dsi.fastutil.objects.ObjectOpenHashBigSet; +import lombok.experimental.UtilityClass; +import net.minestom.server.collision.BoundingBox; +import net.minestom.server.coordinate.Point; +import net.minestom.server.coordinate.Pos; +import net.minestom.server.instance.block.Block; +import ru.dragonestia.msb3.api.ai.navigator.node.NodeGenerator; + +import java.util.*; + +@UtilityClass +public class PathGenerator { + + private final Comparator pathNodeComparator = (first, second) -> (int) (((first.g() + first.h()) - (second.g() + second.h())) * 1000); + + public static Path generate(Block.Getter getter, Pos orgStart, Point orgTarget, double closeDistance, double maxDistance, double pathVariance, BoundingBox boundingBox, boolean isOnGround, NodeGenerator generator) { + final Point start = (!isOnGround && generator.hasGravitySnap()) + ? orgStart.withY(generator.gravitySnap(getter, orgStart.x(), orgStart.y(), orgStart.z(), boundingBox, 100).orElse(orgStart.y())) + : orgStart; + + final Point target = (generator.hasGravitySnap()) + ? orgTarget.withY(generator.gravitySnap(getter, orgTarget.x(), orgTarget.y(), orgTarget.z(), boundingBox, 100).orElse(orgTarget.y())) + : Pos.fromPoint(orgTarget); + + var path = new Path(maxDistance, pathVariance); + computePath(getter, start, target, closeDistance, maxDistance, pathVariance, boundingBox, path, generator); + return path; + } + + private static PathNode buildRepathNode(PathNode parent) { + return new PathNode(0, 0, 0, 0, 0, PathNode.Type.REPATH, parent); + } + + private void computePath(Block.Getter getter, Point start, Point target, double closeDistance, double maxDistance, double pathVariance, BoundingBox boundingBox, Path path, NodeGenerator generator) { + double closestDistance = Double.MAX_VALUE; + double straightDistance = generator.heuristic(start, target); + int maxSize = (int) Math.floor(maxDistance * 10); + + closeDistance = Math.max(0.8, closeDistance); + List closestFoundNodes = List.of(); + + var pStart = new PathNode(start, 0, generator.heuristic(start, target), PathNode.Type.WALK, null); + + var open = new ObjectHeapPriorityQueue<>(pathNodeComparator); + open.enqueue(pStart); + + var closed = new ObjectOpenHashBigSet(maxSize); + + while (!open.isEmpty() && closed.size64() < maxSize) { + if (path.getState() == PathState.TERMINATED) { + return; + } + + var current = open.dequeue(); + + if (((current.g() + current.h()) - straightDistance) > pathVariance) continue; + if (!withinDistance(current, start, maxDistance)) continue; + if (withinDistance(current, target, closeDistance)) { + open.enqueue(current); + break; + } + + if (current.h() < closestDistance) { + closestDistance = current.h(); + closestFoundNodes = List.of(current); + } + + Collection found = generator.getWalkable(getter, closed, current, target, boundingBox); + found.forEach(p -> { + if (getDistanceSquared(p.x(), p.y(), p.z(), start) <= (maxDistance * maxDistance)) { + open.enqueue(p); + closed.add(p); + } + }); + } + + PathNode current = open.isEmpty() ? null : open.dequeue(); + + if (current == null || !withinDistance(current, target, closeDistance)) { + if (closestFoundNodes.isEmpty()) { + path.setState(PathState.DEADLOCKED); + return; + } + + current = closestFoundNodes.getFirst(); + + if (!open.isEmpty()) { + current = buildRepathNode(current); + } + } + + while (Objects.requireNonNull(current).parent() != null) { + path.getNodes().add(current); + current = current.parent(); + } + + Collections.reverse(path.getNodes()); + + if (path.getCurrentType() == PathNode.Type.REPATH) { + path.setState(PathState.DEADLOCKED); + path.getNodes().clear(); + return; + } + + if (path.getNodes().isEmpty()) { + path.setState(PathState.DEADLOCKED); + return; + } + + var lastNode = path.getNodes().getLast(); + if (getDistanceSquared(lastNode.x(), lastNode.y(), lastNode.z(), target) > (closeDistance * closeDistance)) { + path.setState(PathState.DEADLOCKED); + return; + } + + PathNode pEnd = new PathNode(target, 0, 0, PathNode.Type.WALK, null); + path.getNodes().add(pEnd); + path.setState(PathState.FOLLOWING); + } + + private boolean withinDistance(PathNode point, Point target, double closeDistance) { + return getDistanceSquared(point.x(), point.y(), point.z(), target) < (closeDistance * closeDistance); + } + + private double getDistanceSquared(double x, double y, double z, Point target) { + var dx = x - target.x(); + var dy = y - target.y(); + var dz = z - target.z(); + return dx * dx + dy * dy + dz * dz; + } +} diff --git a/api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/PathNode.java b/api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/PathNode.java new file mode 100644 index 0000000..239ec09 --- /dev/null +++ b/api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/PathNode.java @@ -0,0 +1,125 @@ +package ru.dragonestia.msb3.api.ai.navigator; + +import lombok.Getter; +import lombok.Setter; +import net.minestom.server.coordinate.Point; +import org.jetbrains.annotations.Nullable; + +public class PathNode { + + @Setter private double g; + @Setter private double h; + private PathNode parent; + private double pointX; + private double pointY; + private double pointZ; + private int hashCode; + @Setter @Getter private Type type; + + public PathNode(double px, double py, double pz, double g, double h, @Nullable PathNode parent) { + this(px, py, pz, g, h, Type.WALK, parent); + } + + public PathNode(double px, double py, double pz, double g, double h, Type type, @Nullable PathNode parent) { + this.g = g; + this.h = h; + this.parent = parent; + this.type = type; + this.pointX = px; + this.pointY = py; + this.pointZ = pz; + this.hashCode = cantor((int) Math.floor(px), cantor((int) Math.floor(py), (int) Math.floor(pz))); + } + + public PathNode(Point point, double g, double h, Type walk, @Nullable PathNode parent) { + this(point.x(), point.y(), point.z(), g, h, walk, parent); + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public boolean equals(Object obj) { + if (obj == null) return false; + if (obj == this) return true; + if (!(obj instanceof PathNode other)) return false; + return this.hashCode == other.hashCode; + } + + @Override + public String toString() { + return "PathNode{point=(%s, %s, %s), d=%s, type=%s}".formatted( + pointX, + pointY, + pointZ, + g + h, + type + ); + } + + public double x() { + return pointX; + } + + public double y() { + return pointY; + } + + public double z() { + return pointZ; + } + + public int blockX() { + return (int) Math.floor(pointX); + } + + public int blockY() { + return (int) Math.floor(pointY); + } + + public int blockZ() { + return (int) Math.floor(pointZ); + } + + public double g() { + return g; + } + + public double h() { + return h; + } + + public void setPoint(double px, double py, double pz) { + this.pointX = px; + this.pointY = py; + this.pointZ = pz; + this.hashCode = cantor((int) Math.floor(px), cantor((int) Math.floor(py), (int) Math.floor(pz))); + } + + public @Nullable PathNode parent() { + return parent; + } + + public void setParent(@Nullable PathNode current) { + this.parent = current; + } + + private static int cantor(int a, int b) { + int ca = a >= 0 ? 2 * a : -2 * a - 1; + int cb = b >= 0 ? 2 * b : -2 * b - 1; + return (ca + cb + 1) * (ca + cb) / 2 + cb; + } + + public enum Type { + WALK, + JUMP, + FALL, + CLIMB, + CLIMB_WALL, + SWIM, + FLY, + REPATH + } +} diff --git a/api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/PathState.java b/api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/PathState.java new file mode 100644 index 0000000..11b5038 --- /dev/null +++ b/api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/PathState.java @@ -0,0 +1,50 @@ +package ru.dragonestia.msb3.api.ai.navigator; + +import lombok.Getter; +import lombok.RequiredArgsConstructor; + +@Getter +@RequiredArgsConstructor +public enum PathState { + + /** + * Путь не задан. + * @apiNote Можно получить только при получении текущего состояния пути Entity + */ + NONE(true, true), + + /** + * Entity находится в состоянии пути к какой-то точке, либо же идет просчет пути до точки + * @apiNote Можно получить только при получении текущего состояния пути Entity + */ + FOLLOWING(false, true), + + /** + * Путь успешно пройден. + * @apiNote Может являться результатом для CompletableFuture + */ + COMPLETED(true, true), + + /** + * Entity зашел в тупик и не может найти путь. + * @apiNote Может являться результатом для CompletableFuture + */ + DEADLOCKED(true, false), + + /** + * Путь был принудительно отклонен. + * @apiNote Может являться результатом для CompletableFuture + */ + TERMINATED(true, false), + + /** + * Entity не может дойти до указанной точки так как она превышает лимит длинны пути. + * @apiNote Может являться результатом для CompletableFuture + */ + TOO_FAR(true, false), + + ; + + private final boolean completed; + private final boolean success; +} diff --git a/api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/follower/GroundNodeFollower.java b/api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/follower/GroundNodeFollower.java new file mode 100644 index 0000000..9231202 --- /dev/null +++ b/api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/follower/GroundNodeFollower.java @@ -0,0 +1,66 @@ +package ru.dragonestia.msb3.api.ai.navigator.follower; + +import lombok.RequiredArgsConstructor; +import net.minestom.server.collision.CollisionUtils; +import net.minestom.server.coordinate.Point; +import net.minestom.server.coordinate.Pos; +import net.minestom.server.coordinate.Vec; +import net.minestom.server.entity.attribute.Attribute; +import net.minestom.server.utils.position.PositionUtils; +import org.jetbrains.annotations.Nullable; +import ru.dragonestia.msb3.api.entity.EntityAI; + +@RequiredArgsConstructor +public class GroundNodeFollower implements NodeFollower { + + private final EntityAI entity; + + @Override + public void moveTowards(Point direction, double speed, Point lookAt) { + var position = entity.getPosition(); + var dx = direction.x() - position.x(); + var dy = direction.y() - position.y(); + var dz = direction.z() - position.z(); + + var dxLook = lookAt.x() - position.x(); + var dyLook = lookAt.y() - position.y(); + var dzLook = lookAt.z() - position.z(); + + // the purpose of these few lines is to slow down entities when they reach their destination + final double distSquared = dx * dx + dy * dy + dz * dz; + if (speed > distSquared) { + speed = distSquared; + } + + var radians = Math.atan2(dz, dx); + var speedX = Math.cos(radians) * speed; + var speedZ = Math.sin(radians) * speed; + var yaw = PositionUtils.getLookYaw(dxLook, dzLook); + var pitch = PositionUtils.getLookPitch(dxLook, dyLook, dzLook); + + var physicsResult = CollisionUtils.handlePhysics(entity, new Vec(speedX, 0, speedZ)); + var newPosition = Pos.fromPoint(physicsResult.newPosition()); + entity.refreshPosition(newPosition.withView(yaw, pitch)); + } + + @Override + public void jump(@Nullable Point point, @Nullable Point target) { + if (entity.isOnGround()) { + jump(4f); + } + } + + @Override + public boolean isAtPoint(Point point) { + return entity.getPosition().distanceSquared(point) < 0.5 * 0.5; + } + + public void jump(float height) { + entity.setVelocity(new Vec(0, height * 2.5f, 0)); + } + + @Override + public double movementSpeed() { + return entity.getAttribute(Attribute.MOVEMENT_SPEED).getValue(); + } +} diff --git a/api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/follower/NodeFollower.java b/api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/follower/NodeFollower.java new file mode 100644 index 0000000..84a4dcd --- /dev/null +++ b/api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/follower/NodeFollower.java @@ -0,0 +1,15 @@ +package ru.dragonestia.msb3.api.ai.navigator.follower; + +import net.minestom.server.coordinate.Point; +import org.jetbrains.annotations.Nullable; + +public interface NodeFollower { + + void moveTowards(Point target, double speed, Point lookAt); + + void jump(@Nullable Point point, @Nullable Point target); + + boolean isAtPoint(Point point); + + double movementSpeed(); +} diff --git a/api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/node/GroundNodeGenerator.java b/api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/node/GroundNodeGenerator.java new file mode 100644 index 0000000..ffdebb9 --- /dev/null +++ b/api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/node/GroundNodeGenerator.java @@ -0,0 +1,128 @@ +package ru.dragonestia.msb3.api.ai.navigator.node; + +import net.minestom.server.collision.BoundingBox; +import net.minestom.server.coordinate.Point; +import net.minestom.server.coordinate.Vec; +import net.minestom.server.instance.block.Block; +import ru.dragonestia.msb3.api.ai.navigator.PathNode; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.OptionalDouble; +import java.util.Set; + +public class GroundNodeGenerator implements NodeGenerator { + + private final static int MAX_FALL_DISTANCE = 5; + + private final BoundingBox.PointIterator pointIterator = new BoundingBox.PointIterator(); + private PathNode tempNode = null; + + @Override + public Collection getWalkable(Block.Getter getter, Set visited, PathNode current, Point goal, BoundingBox boundingBox) { + Collection nearby = new ArrayList<>(); + tempNode = new PathNode(0, 0, 0, 0, 0, current); + + int stepSize = (int) Math.max(Math.floor(boundingBox.width() / 2), 1); + if (stepSize < 1) stepSize = 1; + + for (int x = -stepSize; x <= stepSize; ++x) { + for (int z = -stepSize; z <= stepSize; ++z) { + if (x == 0 && z == 0) continue; + double cost = Math.sqrt(x * x + z * z) * 0.98; + + double floorPointX = current.blockX() + 0.5 + x; + double floorPointY = current.blockY(); + double floorPointZ = current.blockZ() + 0.5 + z; + + var optionalFloorPointY = gravitySnap(getter, floorPointX, floorPointY, floorPointZ, boundingBox, MAX_FALL_DISTANCE); + if (optionalFloorPointY.isEmpty()) continue; + floorPointY = optionalFloorPointY.getAsDouble(); + + var floorPoint = new Vec(floorPointX, floorPointY, floorPointZ); + + var nodeWalk = createWalk(getter, floorPoint, boundingBox, cost, current, goal, visited); + if (nodeWalk != null && !visited.contains(nodeWalk)) nearby.add(nodeWalk); + + for (int i = 1; i == 1; ++i) { + Point jumpPoint = new Vec(current.blockX() + 0.5 + x, current.blockY() + i, current.blockZ() + 0.5 + z); + OptionalDouble jumpPointY = gravitySnap(getter, jumpPoint.x(), jumpPoint.y(), jumpPoint.z(), boundingBox, MAX_FALL_DISTANCE); + if (jumpPointY.isEmpty()) continue; + jumpPoint = jumpPoint.withY(jumpPointY.getAsDouble()); + + if (!floorPoint.sameBlock(jumpPoint)) { + var nodeJump = createJump(getter, jumpPoint, boundingBox, cost + 0.2, current, goal, visited); + if (nodeJump != null && !visited.contains(nodeJump)) nearby.add(nodeJump); + } + } + } + } + + return nearby; + } + + private PathNode createWalk(Block.Getter getter, Point point, BoundingBox boundingBox, double cost, PathNode start, Point goal, Set closed) { + var n = newNode(start, cost, point, goal); + if (closed.contains(n)) return null; + + if (Math.abs(point.y() - start.y()) > Vec.EPSILON && point.y() < start.y()) { + if (start.y() - point.y() > MAX_FALL_DISTANCE) return null; + if (!canMoveTowards(getter, new Vec(start.x(), start.y(), start.z()), point.withY(start.y()), boundingBox)) + return null; + n.setType(PathNode.Type.FALL); + } else { + if (!canMoveTowards(getter, new Vec(start.x(), start.y(), start.z()), point, boundingBox)) return null; + } + return n; + } + + private PathNode createJump(Block.Getter getter, Point point, BoundingBox boundingBox, double cost, PathNode start, Point goal, Set closed) { + if (Math.abs(point.y() - start.y()) < Vec.EPSILON) return null; + if (point.y() - start.y() > 2) return null; + if (point.blockX() != start.blockX() && point.blockZ() != start.blockZ()) return null; + + var n = newNode(start, cost, point, goal); + if (closed.contains(n)) return null; + + if (pointInvalid(getter, point, boundingBox)) return null; + if (pointInvalid(getter, new Vec(start.x(), start.y() + 1, start.z()), boundingBox)) return null; + + n.setType(PathNode.Type.JUMP); + return n; + } + + private PathNode newNode(PathNode current, double cost, Point point, Point goal) { + tempNode.setG(current.g() + cost); + tempNode.setH(heuristic(point, goal)); + tempNode.setPoint(point.x(), point.y(), point.z()); + + var newNode = tempNode; + tempNode = new PathNode(0, 0, 0, 0, 0, PathNode.Type.WALK, current); + + return newNode; + } + + @Override + public boolean hasGravitySnap() { + return true; + } + + @Override + public OptionalDouble gravitySnap(Block.Getter getter, double pointOrgX, double pointOrgY, double pointOrgZ, BoundingBox boundingBox, double maxFall) { + var pointX = (int) Math.floor(pointOrgX) + 0.5; + var pointY = (int) Math.floor(pointOrgY); + var pointZ = (int) Math.floor(pointOrgZ) + 0.5; + + for (int axis = 1; axis <= maxFall; ++axis) { + pointIterator.reset(boundingBox, pointX, pointY, pointZ, BoundingBox.AxisMask.Y, -axis); + + while (pointIterator.hasNext()) { + var block = pointIterator.next(); + if (getter.getBlock(block.blockX(), block.blockY(), block.blockZ(), Block.Getter.Condition.TYPE).isSolid()) { + return OptionalDouble.of(block.blockY() + 1); + } + } + } + return OptionalDouble.empty(); + } +} diff --git a/api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/node/NodeGenerator.java b/api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/node/NodeGenerator.java new file mode 100644 index 0000000..0269412 --- /dev/null +++ b/api/src/main/java/ru/dragonestia/msb3/api/ai/navigator/node/NodeGenerator.java @@ -0,0 +1,46 @@ +package ru.dragonestia.msb3.api.ai.navigator.node; + +import net.minestom.server.collision.BoundingBox; +import net.minestom.server.collision.CollisionUtils; +import net.minestom.server.coordinate.Point; +import net.minestom.server.coordinate.Pos; +import net.minestom.server.coordinate.Vec; +import net.minestom.server.instance.block.Block; +import ru.dragonestia.msb3.api.ai.navigator.PathNode; + +import java.util.Collection; +import java.util.OptionalDouble; +import java.util.Set; + +public interface NodeGenerator { + + Collection getWalkable(Block.Getter getter, Set visited, PathNode current, Point goal, BoundingBox boundingBox); + + boolean hasGravitySnap(); + + OptionalDouble gravitySnap(Block.Getter getter, double pointX, double pointY, double pointZ, BoundingBox boundingBox, double maxFall); + + default boolean canMoveTowards(Block.Getter getter, Point start, Point end, BoundingBox boundingBox) { + final Point diff = end.sub(start); + + if (getter.getBlock(end) != Block.AIR) return false; + var res = CollisionUtils.handlePhysics(getter, boundingBox, Pos.fromPoint(start), Vec.fromPoint(diff), null, false); + return !res.collisionZ() && !res.collisionY() && !res.collisionX(); + } + + default boolean pointInvalid(Block.Getter getter, Point point, BoundingBox boundingBox) { + var iterator = boundingBox.getBlocks(point); + while (iterator.hasNext()) { + var block = iterator.next(); + if (getter.getBlock(block.blockX(), block.blockY(), block.blockZ(), Block.Getter.Condition.TYPE).isSolid()) { + return true; + } + } + + return false; + } + + default double heuristic(Point node, Point target) { + return node.distance(target); + } +} diff --git a/api/src/main/java/ru/dragonestia/msb3/api/boot/DebugAiBootstrap.java b/api/src/main/java/ru/dragonestia/msb3/api/boot/DebugAiBootstrap.java new file mode 100644 index 0000000..01aba31 --- /dev/null +++ b/api/src/main/java/ru/dragonestia/msb3/api/boot/DebugAiBootstrap.java @@ -0,0 +1,50 @@ +package ru.dragonestia.msb3.api.boot; + +import net.minestom.server.coordinate.Pos; +import net.minestom.server.entity.GameMode; +import ru.dragonestia.msb3.api.module.FlatWorldModule; +import ru.dragonestia.msb3.api.module.MotdModule; +import ru.dragonestia.msb3.api.module.ResourcePackRepositoryModule; +import ru.dragonestia.msb3.api.script.ScriptRegistry; +import ru.dragonestia.msb3.api.script.defaults.SpawnTestActorScript; +import ru.dragonestia.msb3.api.util.ChunkPreloader; +import ru.dragonestia.msb3.api.world.WorldFactory; +import team.unnamed.creative.ResourcePack; + +import java.io.File; + +public class DebugAiBootstrap extends ServerInitializer { + + public static void main(String[] args) { + ServerBootstrap.start("0.0.0.0", 25565, new DebugAiBootstrap()); + } + + @Override + public void onLoad() {} + + @Override + public void onDefaultModulesLoaded() { + MotdModule.init("logo.png", "msb3 server - AI test"); + + // Скачать мир можно здесь: http://files.dragonestia.ru/f/fd754add490b42929130/ + FlatWorldModule.init(GameMode.CREATIVE, WorldFactory.anvil(new File("./debug_ai")).createWorldSync(), new Pos(0.5, 61, 0.5, -135, 0)); + + ScriptRegistry.register(SpawnTestActorScript::new); + } + + @Override + public void onInitializeResources(ResourcePack resourcePack) {} + + @Override + public void onResourcePackCompiled(ResourcePack resourcePack) { + ResourcePackRepositoryModule.init("0.0.0.0", 7270); + } + + @Override + public void onServerStarted() { + var instance = FlatWorldModule.getWorld().getInstance(); + ChunkPreloader.preload(instance, -1, -16, 18, 0); + instance.setTimeRate(0); + instance.setTime(5000); + } +} diff --git a/api/src/main/java/ru/dragonestia/msb3/api/entity/EntityAI.java b/api/src/main/java/ru/dragonestia/msb3/api/entity/EntityAI.java new file mode 100644 index 0000000..4b69a73 --- /dev/null +++ b/api/src/main/java/ru/dragonestia/msb3/api/entity/EntityAI.java @@ -0,0 +1,78 @@ +package ru.dragonestia.msb3.api.entity; + +import lombok.Getter; +import lombok.Setter; +import net.minestom.server.coordinate.Pos; +import net.minestom.server.entity.Entity; +import net.minestom.server.entity.EntityType; +import net.minestom.server.entity.LivingEntity; +import net.minestom.server.entity.attribute.Attribute; +import net.minestom.server.event.EventDispatcher; +import net.minestom.server.event.entity.EntityAttackEvent; +import net.minestom.server.instance.Instance; +import net.minestom.server.utils.time.TimeUnit; +import org.jetbrains.annotations.NotNull; +import ru.dragonestia.msb3.api.ai.AI; + +import java.time.Duration; +import java.util.Objects; +import java.util.UUID; +import java.util.concurrent.CompletableFuture; + +@Getter +public class EntityAI extends LivingEntity { + + @Setter private int removalAnimationDelay = 1000; + private final AI ai = new AI(this); + + public EntityAI(@NotNull EntityType entityType) { + this(entityType, UUID.randomUUID()); + } + + public EntityAI(@NotNull EntityType entityType, @NotNull UUID uuid) { + super(entityType, uuid); + getAttribute(Attribute.MOVEMENT_SPEED).setBaseValue(0.2); + heal(); + } + + @Override + public void update(long time) { + ai.tick(time); + super.update(time); + } + + @Override + public CompletableFuture setInstance(@NotNull Instance instance, @NotNull Pos spawnPosition) { + ai.resetDestinationData(); + return super.setInstance(instance, spawnPosition).thenRun(() -> { + var action = ai.getActor().getCurrentAction(); + if (action != null) { + action.start(ai.getActor(), this); + } + }); + } + + @Override + public void kill() { + super.kill(); + + if (removalAnimationDelay > 0) scheduleRemove(Duration.of(removalAnimationDelay, TimeUnit.MILLISECOND)); + else remove(); + } + + public void attack(Entity target, boolean swingHand) { + if (swingHand) swingMainHand(); + EntityAttackEvent attackEvent = new EntityAttackEvent(this, Objects.requireNonNull(target)); + EventDispatcher.call(attackEvent); + } + + public void attack(Entity target) { + attack(target, false); + } + + @Override + protected void remove(boolean permanent) { + super.remove(permanent); + ai.getActor().setActive(false); + } +} diff --git a/api/src/main/java/ru/dragonestia/msb3/api/entity/Human.java b/api/src/main/java/ru/dragonestia/msb3/api/entity/Human.java index c0e9286..a93e0db 100644 --- a/api/src/main/java/ru/dragonestia/msb3/api/entity/Human.java +++ b/api/src/main/java/ru/dragonestia/msb3/api/entity/Human.java @@ -3,7 +3,6 @@ package ru.dragonestia.msb3.api.entity; import lombok.Getter; import net.kyori.adventure.text.Component; import net.kyori.adventure.text.format.NamedTextColor; -import net.kyori.adventure.text.format.TextColor; import net.minestom.server.MinecraftServer; import net.minestom.server.coordinate.Point; import net.minestom.server.coordinate.Pos; @@ -27,7 +26,7 @@ import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.atomic.AtomicInteger; import java.util.function.Predicate; -public class Human extends EntityCreature { +public class Human extends EntityAI { private static final AtomicInteger freeId = new AtomicInteger(0); private static final Map npcTeams = new ConcurrentHashMap<>(); diff --git a/api/src/main/java/ru/dragonestia/msb3/api/player/defaults/DebugParamsContext.java b/api/src/main/java/ru/dragonestia/msb3/api/player/defaults/DebugParamsContext.java index b5cb773..270939f 100644 --- a/api/src/main/java/ru/dragonestia/msb3/api/player/defaults/DebugParamsContext.java +++ b/api/src/main/java/ru/dragonestia/msb3/api/player/defaults/DebugParamsContext.java @@ -1,10 +1,10 @@ package ru.dragonestia.msb3.api.player.defaults; import net.kyori.adventure.text.format.NamedTextColor; -import net.minestom.server.entity.EntityCreature; import net.minestom.server.network.packet.server.play.ParticlePacket; import net.minestom.server.particle.Particle; import net.minestom.server.timer.Task; +import ru.dragonestia.msb3.api.entity.EntityAI; import ru.dragonestia.msb3.api.player.MsbPlayer; import ru.dragonestia.msb3.api.player.PlayerContext; import ru.dragonestia.msb3.api.scheduler.Scheduler; @@ -39,10 +39,10 @@ public class DebugParamsContext extends PlayerContext { taskDebugRendererAiPathFinder = Scheduler.ofPlayer(getPlayer()).repeatingTask(() -> { for (var entity: getPlayer().getInstance().getNearbyEntities(getPlayer().getPosition(), 32)) { - if (entity instanceof EntityCreature creature) { - var nodes = creature.getNavigator().getNodes(); - if (nodes == null) continue; - for (var point: nodes) { + if (entity instanceof EntityAI creature) { + var destinationData = creature.getAi().getDestinationData(); + if (destinationData == null) continue; + for (var point: destinationData.path().getNodes()) { var packet = new ParticlePacket(PARTICLE_AI_PATH, point.x(), point.y() + 0.5, point.z(), 0, 0, 0, 0, 1); entity.sendPacketToViewers(packet); } diff --git a/api/src/main/java/ru/dragonestia/msb3/api/script/defaults/SpawnTestActorScript.java b/api/src/main/java/ru/dragonestia/msb3/api/script/defaults/SpawnTestActorScript.java new file mode 100644 index 0000000..dfd2b5a --- /dev/null +++ b/api/src/main/java/ru/dragonestia/msb3/api/script/defaults/SpawnTestActorScript.java @@ -0,0 +1,40 @@ +package ru.dragonestia.msb3.api.script.defaults; + +import net.kyori.adventure.text.Component; +import net.minestom.server.coordinate.Vec; +import net.minestom.server.entity.EntityType; +import ru.dragonestia.msb3.api.ai.action.PatrolAction; +import ru.dragonestia.msb3.api.entity.EntityAI; +import ru.dragonestia.msb3.api.player.MsbPlayer; +import ru.dragonestia.msb3.api.script.InstantScript; +import ru.dragonestia.msb3.api.util.Params; + +import java.util.List; + +public class SpawnTestActorScript extends InstantScript { + + public SpawnTestActorScript() { + super("test_actor"); + } + + @Override + public void start(MsbPlayer player, Params params) { + var instance = player.getInstance(); + var spawnPos = player.getPosition(); + + var entity = new EntityAI(EntityType.SKELETON); + entity.setCustomName(Component.text("Test actor")); + entity.setCustomNameVisible(true); + + var action = new PatrolAction(); + action.setPath(List.of( + new Vec(10.22, 46.00, -6.13), + new Vec(12.99, 46.00, -22.02), + new Vec(11.82, 46.00, -39.27), + new Vec(47.15, 47.00, -39.14) + )); + entity.getAi().getActor().setCurrentAction(action); + + entity.setInstance(instance, spawnPos); + } +}