diff --git a/patches/server/0046-Async-PathProcessing.patch b/patches/server/0046-Async-PathProcessing.patch new file mode 100644 index 000000000..d6be26d55 --- /dev/null +++ b/patches/server/0046-Async-PathProcessing.patch @@ -0,0 +1,1367 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: IPECTER +Date: Thu, 7 Sep 2023 14:25:08 +0900 +Subject: [PATCH] Async-PathProcessing + + +diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/AcquirePoi.java b/src/main/java/net/minecraft/world/entity/ai/behavior/AcquirePoi.java +index fe502445a77afe7e3807afae48d7bf03f370e290..13392bd98a0c7fa9b859c2dfa7a01b24d5cc56d7 100644 +--- a/src/main/java/net/minecraft/world/entity/ai/behavior/AcquirePoi.java ++++ b/src/main/java/net/minecraft/world/entity/ai/behavior/AcquirePoi.java +@@ -68,28 +68,62 @@ public class AcquirePoi { + io.papermc.paper.util.PoiAccess.findNearestPoiPositions(poiManager, poiPredicate, predicate2, entity.blockPosition(), 48, 48*48, PoiManager.Occupancy.HAS_SPACE, false, 5, poiposes); + Set, BlockPos>> set = new java.util.HashSet<>(poiposes); + // Paper end - optimise POI access +- Path path = findPathToPois(entity, set); +- if (path != null && path.canReach()) { +- BlockPos blockPos = path.getTarget(); +- poiManager.getType(blockPos).ifPresent((poiType) -> { +- poiManager.take(poiPredicate, (holder, blockPos2) -> { +- return blockPos2.equals(blockPos); +- }, blockPos, 1); +- queryResult.set(GlobalPos.of(world.dimension(), blockPos)); +- entityStatus.ifPresent((status) -> { +- world.broadcastEntityEvent(entity, status); ++ // Plazma start - Async Path Processing ++ if (entity.level().plazmaLevelConfiguration().entity.asyncPathProcessing.enabled) { ++ // await on patoh async ++ Path possiblePath = findPathToPois(entity, set); ++ ++ // wait on the path to be processed ++ org.plazmamc.plazma.entity.path.AsyncPathProcessor.awaitProcessing(possiblePath, path -> { ++ // read canReach check ++ if (path == null || !path.canReach()) { ++ for(Pair, BlockPos> pair : set) { ++ long2ObjectMap.computeIfAbsent( ++ pair.getSecond().asLong(), ++ (m) -> new JitteredLinearRetry(entity.level.random, time) ++ ); ++ } ++ return; ++ } ++ BlockPos blockPos = path.getTarget(); ++ poiManager.getType(blockPos).ifPresent((poiType) -> { ++ poiManager.take(poiPredicate, ++ (holder, blockPos2) -> blockPos2.equals(blockPos), ++ blockPos, ++ 1 ++ ); ++ queryResult.set(GlobalPos.of(world.dimension(), blockPos)); ++ entityStatus.ifPresent((status) -> { ++ world.broadcastEntityEvent(entity, status); ++ }); ++ long2ObjectMap.clear(); ++ DebugPackets.sendPoiTicketCountPacket(world, blockPos); + }); +- long2ObjectMap.clear(); +- DebugPackets.sendPoiTicketCountPacket(world, blockPos); + }); + } else { +- for(Pair, BlockPos> pair : set) { +- long2ObjectMap.computeIfAbsent(pair.getSecond().asLong(), (m) -> { +- return new AcquirePoi.JitteredLinearRetry(world.random, time); ++ Path path = findPathToPois(entity, set); ++ if (path != null && path.canReach()) { ++ BlockPos blockPos = path.getTarget(); ++ poiManager.getType(blockPos).ifPresent((poiType) -> { ++ poiManager.take(poiPredicate, (holder, blockPos2) -> { ++ return blockPos2.equals(blockPos); ++ }, blockPos, 1); ++ queryResult.set(GlobalPos.of(world.dimension(), blockPos)); ++ entityStatus.ifPresent((status) -> { ++ world.broadcastEntityEvent(entity, status); ++ }); ++ long2ObjectMap.clear(); ++ DebugPackets.sendPoiTicketCountPacket(world, blockPos); + }); ++ } else { ++ for (Pair, BlockPos> pair : set) { ++ long2ObjectMap.computeIfAbsent(pair.getSecond().asLong(), (m) -> { ++ return new AcquirePoi.JitteredLinearRetry(world.random, time); ++ }); ++ } + } + } +- ++ // Plazma end + return true; + } + }; +diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/MoveToTargetSink.java b/src/main/java/net/minecraft/world/entity/ai/behavior/MoveToTargetSink.java +index 1ab77f3518d1df30f66ae44d7d4fa69e5b32d93a..20f4279a51a89912bf8c0023a49a39c7112689a4 100644 +--- a/src/main/java/net/minecraft/world/entity/ai/behavior/MoveToTargetSink.java ++++ b/src/main/java/net/minecraft/world/entity/ai/behavior/MoveToTargetSink.java +@@ -21,6 +21,7 @@ public class MoveToTargetSink extends Behavior { + private int remainingCooldown; + @Nullable + private Path path; ++ private boolean finishedProcessing; // Plazma - track when path is processed + @Nullable + private BlockPos lastTargetPos; + private float speedModifier; +@@ -42,9 +43,11 @@ public class MoveToTargetSink extends Behavior { + Brain brain = entity.getBrain(); + WalkTarget walkTarget = brain.getMemory(MemoryModuleType.WALK_TARGET).get(); + boolean bl = this.reachedTarget(entity, walkTarget); +- if (!bl && this.tryComputePath(entity, walkTarget, world.getGameTime())) { ++ if (!world.plazmaLevelConfiguration().entity.asyncPathProcessing.enabled && !bl && this.tryComputePath(entity, walkTarget, world.getGameTime())) { // Plazma - async path processing means we can't know if the path is reachable here + this.lastTargetPos = walkTarget.getTarget().currentBlockPosition(); + return true; ++ } else if (world.plazmaLevelConfiguration().entity.asyncPathProcessing.enabled && !bl) { ++ return true; // Plazma - async pathfinding + } else { + brain.eraseMemory(MemoryModuleType.WALK_TARGET); + if (bl) { +@@ -58,6 +61,7 @@ public class MoveToTargetSink extends Behavior { + + @Override + protected boolean canStillUse(ServerLevel world, Mob entity, long time) { ++ if (world.plazmaLevelConfiguration().entity.asyncPathProcessing.enabled && !this.finishedProcessing) return true; // Plazma - wait for processing + if (this.path != null && this.lastTargetPos != null) { + Optional optional = entity.getBrain().getMemory(MemoryModuleType.WALK_TARGET); + boolean bl = optional.map(MoveToTargetSink::isWalkTargetSpectator).orElse(false); +@@ -82,28 +86,99 @@ public class MoveToTargetSink extends Behavior { + + @Override + protected void start(ServerLevel serverLevel, Mob mob, long l) { ++ // Plazma start - petal - start processing ++ if (serverLevel.plazmaLevelConfiguration().entity.asyncPathProcessing.enabled) { ++ Brain brain = mob.getBrain(); ++ WalkTarget walkTarget = brain.getMemory(MemoryModuleType.WALK_TARGET).get(); ++ ++ this.finishedProcessing = false; ++ this.lastTargetPos = walkTarget.getTarget().currentBlockPosition(); ++ this.path = this.computePath(mob, walkTarget); ++ return; ++ } ++ // Plazma end + mob.getBrain().setMemory(MemoryModuleType.PATH, this.path); + mob.getNavigation().moveTo(this.path, (double)this.speedModifier); + } + + @Override + protected void tick(ServerLevel serverLevel, Mob mob, long l) { +- Path path = mob.getNavigation().getPath(); +- Brain brain = mob.getBrain(); +- if (this.path != path) { +- this.path = path; +- brain.setMemory(MemoryModuleType.PATH, path); +- } ++ // Plazma start - Async path processing ++ if (serverLevel.plazmaLevelConfiguration().entity.asyncPathProcessing.enabled) { ++ if (this.path != null && !this.path.isProcessed()) return; // wait for processing ++ ++ if (!this.finishedProcessing) { ++ this.finishedProcessing = true; ++ ++ Brain brain = mob.getBrain(); ++ boolean canReach = this.path != null && this.path.canReach(); ++ if (canReach) { ++ brain.eraseMemory(MemoryModuleType.CANT_REACH_WALK_TARGET_SINCE); ++ } else if (!brain.hasMemoryValue(MemoryModuleType.CANT_REACH_WALK_TARGET_SINCE)) { ++ brain.setMemory(MemoryModuleType.CANT_REACH_WALK_TARGET_SINCE, l); ++ } ++ ++ if (!canReach) { ++ Optional walkTarget = brain.getMemory(MemoryModuleType.WALK_TARGET); ++ ++ if (!walkTarget.isPresent()) return; ++ ++ BlockPos blockPos = walkTarget.get().getTarget().currentBlockPosition(); ++ Vec3 vec3 = DefaultRandomPos.getPosTowards((PathfinderMob) mob, 10, 7, Vec3.atBottomCenterOf(blockPos), (float) Math.PI / 2F); ++ if (vec3 != null) { ++ // try recalculating the path using a random position ++ this.path = mob.getNavigation().createPath(vec3.x, vec3.y, vec3.z, 0); ++ this.finishedProcessing = false; ++ return; ++ } ++ } ++ ++ mob.getBrain().setMemory(MemoryModuleType.PATH, this.path); ++ mob.getNavigation().moveTo(this.path, this.speedModifier); ++ } ++ ++ Path path = mob.getNavigation().getPath(); ++ Brain brain = mob.getBrain(); ++ ++ if (path != null && this.lastTargetPos != null && brain.hasMemoryValue(MemoryModuleType.WALK_TARGET)) { ++ WalkTarget walkTarget = brain.getMemory(MemoryModuleType.WALK_TARGET).get(); // we know isPresent = true ++ if (walkTarget.getTarget().currentBlockPosition().distSqr(this.lastTargetPos) > 4.0D) { ++ this.start(serverLevel, mob, l); ++ } ++ } ++ } else { ++ Path path = mob.getNavigation().getPath(); ++ Brain brain = mob.getBrain(); ++ if (this.path != path) { ++ this.path = path; ++ brain.setMemory(MemoryModuleType.PATH, path); ++ } ++ ++ if (path != null && this.lastTargetPos != null) { ++ WalkTarget walkTarget = brain.getMemory(MemoryModuleType.WALK_TARGET).get(); ++ if (walkTarget.getTarget().currentBlockPosition().distSqr(this.lastTargetPos) > 4.0D && this.tryComputePath(mob, walkTarget, serverLevel.getGameTime())) { ++ this.lastTargetPos = walkTarget.getTarget().currentBlockPosition(); ++ this.start(serverLevel, mob, l); ++ } + +- if (path != null && this.lastTargetPos != null) { +- WalkTarget walkTarget = brain.getMemory(MemoryModuleType.WALK_TARGET).get(); +- if (walkTarget.getTarget().currentBlockPosition().distSqr(this.lastTargetPos) > 4.0D && this.tryComputePath(mob, walkTarget, serverLevel.getGameTime())) { +- this.lastTargetPos = walkTarget.getTarget().currentBlockPosition(); +- this.start(serverLevel, mob, l); + } ++ } ++ // Plazma end ++ } + ++ // Plazma start - Async path processing ++ @Nullable ++ private Path computePath(Mob entity, WalkTarget walkTarget) { ++ BlockPos blockPos = walkTarget.getTarget().currentBlockPosition(); ++ // don't pathfind outside region ++ this.speedModifier = walkTarget.getSpeedModifier(); ++ Brain brain = entity.getBrain(); ++ if (this.reachedTarget(entity, walkTarget)) { ++ brain.eraseMemory(MemoryModuleType.CANT_REACH_WALK_TARGET_SINCE); + } ++ return entity.getNavigation().createPath(blockPos, 0); + } ++ // Plazma end + + private boolean tryComputePath(Mob entity, WalkTarget walkTarget, long time) { + BlockPos blockPos = walkTarget.getTarget().currentBlockPosition(); +diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/SetClosestHomeAsWalkTarget.java b/src/main/java/net/minecraft/world/entity/ai/behavior/SetClosestHomeAsWalkTarget.java +index 271efbb027f6f5d69ac5bc5dc51102a1eb00ab31..be7e1f4faf60bb36431ede0312e3d3d312e88846 100644 +--- a/src/main/java/net/minecraft/world/entity/ai/behavior/SetClosestHomeAsWalkTarget.java ++++ b/src/main/java/net/minecraft/world/entity/ai/behavior/SetClosestHomeAsWalkTarget.java +@@ -57,20 +57,40 @@ public class SetClosestHomeAsWalkTarget { + Set, BlockPos>> set = poiManager.findAllWithType((poiType) -> { + return poiType.is(PoiTypes.HOME); + }, predicate, entity.blockPosition(), 48, PoiManager.Occupancy.ANY).collect(Collectors.toSet()); +- Path path = AcquirePoi.findPathToPois(entity, set); +- if (path != null && path.canReach()) { +- BlockPos blockPos = path.getTarget(); +- Optional> optional2 = poiManager.getType(blockPos); +- if (optional2.isPresent()) { +- walkTarget.set(new WalkTarget(blockPos, speed, 1)); +- DebugPackets.sendPoiTicketCountPacket(world, blockPos); +- } +- } else if (mutableInt.getValue() < 5) { +- long2LongMap.long2LongEntrySet().removeIf((entry) -> { +- return entry.getLongValue() < mutableLong.getValue(); ++ // Plazma start - Async path processing ++ if (entity.level().plazmaLevelConfiguration().entity.asyncPathProcessing.enabled) { ++ // await on path async ++ Path possiblePath = AcquirePoi.findPathToPois(entity, set); ++ ++ // wait on the path to be processed ++ org.plazmamc.plazma.entity.path.AsyncPathProcessor.awaitProcessing(possiblePath, path -> { ++ if (path == null || !path.canReach() || mutableInt.getValue() < 5) { // read canReach check ++ long2LongMap.long2LongEntrySet().removeIf((entry) -> entry.getLongValue() < mutableLong.getValue()); ++ return; ++ } ++ BlockPos blockPos = path.getTarget(); ++ Optional> optional2 = poiManager.getType(blockPos); ++ if (optional2.isPresent()) { ++ walkTarget.set(new WalkTarget(blockPos, speed, 1)); ++ DebugPackets.sendPoiTicketCountPacket(world, blockPos); ++ } + }); ++ } else { ++ Path path = AcquirePoi.findPathToPois(entity, set); ++ if (path != null && path.canReach()) { ++ BlockPos blockPos = path.getTarget(); ++ Optional> optional2 = poiManager.getType(blockPos); ++ if (optional2.isPresent()) { ++ walkTarget.set(new WalkTarget(blockPos, speed, 1)); ++ DebugPackets.sendPoiTicketCountPacket(world, blockPos); ++ } ++ } else if (mutableInt.getValue() < 5) { ++ long2LongMap.long2LongEntrySet().removeIf((entry) -> { ++ return entry.getLongValue() < mutableLong.getValue(); ++ }); ++ } + } +- ++ // Plazma end + return true; + } else { + return false; +diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/DoorInteractGoal.java b/src/main/java/net/minecraft/world/entity/ai/goal/DoorInteractGoal.java +index 6771f2dc974317b6b152288bf41d1a95bc78a8e4..3bc56fddd5b8615df6da69552190c62c5c53646a 100644 +--- a/src/main/java/net/minecraft/world/entity/ai/goal/DoorInteractGoal.java ++++ b/src/main/java/net/minecraft/world/entity/ai/goal/DoorInteractGoal.java +@@ -57,7 +57,7 @@ public abstract class DoorInteractGoal extends Goal { + } else { + GroundPathNavigation groundPathNavigation = (GroundPathNavigation)this.mob.getNavigation(); + Path path = groundPathNavigation.getPath(); +- if (path != null && !path.isDone() && groundPathNavigation.canOpenDoors()) { ++ if (path != null && path.isProcessed() && !path.isDone() && groundPathNavigation.canOpenDoors()) { // Plazma - async pathfinding - ensure path is processed + for(int i = 0; i < Math.min(path.getNextNodeIndex() + 2, path.getNodeCount()); ++i) { + Node node = path.getNode(i); + this.doorPos = new BlockPos(node.x, node.y + 1, node.z); +diff --git a/src/main/java/net/minecraft/world/entity/ai/navigation/AmphibiousPathNavigation.java b/src/main/java/net/minecraft/world/entity/ai/navigation/AmphibiousPathNavigation.java +index 97bd4c9f83257c8c54694110d369d0487e4df9f9..30ce068d985d418f4c97e2e72fceafa0e1e945fe 100644 +--- a/src/main/java/net/minecraft/world/entity/ai/navigation/AmphibiousPathNavigation.java ++++ b/src/main/java/net/minecraft/world/entity/ai/navigation/AmphibiousPathNavigation.java +@@ -12,10 +12,22 @@ public class AmphibiousPathNavigation extends PathNavigation { + super(mob, world); + } + ++ // Plamza start - async path processing ++ private static final org.plazmamc.plazma.entity.path.NodeEvaluatorGenerator nodeEvaluatorGenerator = (org.plazmamc.plazma.entity.path.NodeEvaluatorFeatures nodeEvaluatorFeatures) -> { ++ AmphibiousNodeEvaluator nodeEvaluator = new AmphibiousNodeEvaluator(false); ++ nodeEvaluator.setCanPassDoors(nodeEvaluatorFeatures.canPassDoors()); ++ nodeEvaluator.setCanFloat(nodeEvaluatorFeatures.canFloat()); ++ nodeEvaluator.setCanWalkOverFences(nodeEvaluatorFeatures.canWalkOverFences()); ++ nodeEvaluator.setCanOpenDoors(nodeEvaluatorFeatures.canOpenDoors()); ++ return nodeEvaluator; ++ }; ++ // Plazma end ++ + @Override + protected PathFinder createPathFinder(int range) { + this.nodeEvaluator = new AmphibiousNodeEvaluator(false); + this.nodeEvaluator.setCanPassDoors(true); ++ if (this.level.plazmaLevelConfiguration().entity.asyncPathProcessing.enabled) return new PathFinder(this.nodeEvaluator, range, nodeEvaluatorGenerator); // Plazma - async path processing + return new PathFinder(this.nodeEvaluator, range); + } + +diff --git a/src/main/java/net/minecraft/world/entity/ai/navigation/FlyingPathNavigation.java b/src/main/java/net/minecraft/world/entity/ai/navigation/FlyingPathNavigation.java +index acd0b946cab86eb173e713535194d3a9347c7d48..4aabbd23c45a8b0f366e4234340bc1e6929093e2 100644 +--- a/src/main/java/net/minecraft/world/entity/ai/navigation/FlyingPathNavigation.java ++++ b/src/main/java/net/minecraft/world/entity/ai/navigation/FlyingPathNavigation.java +@@ -16,10 +16,22 @@ public class FlyingPathNavigation extends PathNavigation { + super(entity, world); + } + ++ // Plamza start - async path processing ++ private static final org.plazmamc.plazma.entity.path.NodeEvaluatorGenerator nodeEvaluatorGenerator = (org.plazmamc.plazma.entity.path.NodeEvaluatorFeatures nodeEvaluatorFeatures) -> { ++ FlyNodeEvaluator nodeEvaluator = new FlyNodeEvaluator(); ++ nodeEvaluator.setCanPassDoors(nodeEvaluatorFeatures.canPassDoors()); ++ nodeEvaluator.setCanFloat(nodeEvaluatorFeatures.canFloat()); ++ nodeEvaluator.setCanWalkOverFences(nodeEvaluatorFeatures.canWalkOverFences()); ++ nodeEvaluator.setCanOpenDoors(nodeEvaluatorFeatures.canOpenDoors()); ++ return nodeEvaluator; ++ }; ++ // Plazma end ++ + @Override + protected PathFinder createPathFinder(int range) { + this.nodeEvaluator = new FlyNodeEvaluator(); + this.nodeEvaluator.setCanPassDoors(true); ++ if (this.level.plazmaLevelConfiguration().entity.asyncPathProcessing.enabled) return new PathFinder(this.nodeEvaluator, range, nodeEvaluatorGenerator); // Plazma - async path processing + return new PathFinder(this.nodeEvaluator, range); + } + +@@ -49,7 +61,7 @@ public class FlyingPathNavigation extends PathNavigation { + if (this.hasDelayedRecomputation) { + this.recomputePath(); + } +- ++ if (this.path != null && !this.path.isProcessed()) return; // Plamza - async path processing + if (!this.isDone()) { + if (this.canUpdatePath()) { + this.followThePath(); +diff --git a/src/main/java/net/minecraft/world/entity/ai/navigation/GroundPathNavigation.java b/src/main/java/net/minecraft/world/entity/ai/navigation/GroundPathNavigation.java +index 71934af2dc4d209a9fbccfd36b5f2815ec196892..3700d973e19f134f908c9579a4b840f61790a72b 100644 +--- a/src/main/java/net/minecraft/world/entity/ai/navigation/GroundPathNavigation.java ++++ b/src/main/java/net/minecraft/world/entity/ai/navigation/GroundPathNavigation.java +@@ -21,10 +21,22 @@ public class GroundPathNavigation extends PathNavigation { + super(entity, world); + } + ++ // Plamza start - async path processing ++ protected static final org.plazmamc.plazma.entity.path.NodeEvaluatorGenerator nodeEvaluatorGenerator = (org.plazmamc.plazma.entity.path.NodeEvaluatorFeatures nodeEvaluatorFeatures) -> { ++ WalkNodeEvaluator nodeEvaluator = new WalkNodeEvaluator(); ++ nodeEvaluator.setCanPassDoors(nodeEvaluatorFeatures.canPassDoors()); ++ nodeEvaluator.setCanFloat(nodeEvaluatorFeatures.canFloat()); ++ nodeEvaluator.setCanWalkOverFences(nodeEvaluatorFeatures.canWalkOverFences()); ++ nodeEvaluator.setCanOpenDoors(nodeEvaluatorFeatures.canOpenDoors()); ++ return nodeEvaluator; ++ }; ++ // Plazma end ++ + @Override + protected PathFinder createPathFinder(int range) { + this.nodeEvaluator = new WalkNodeEvaluator(); + this.nodeEvaluator.setCanPassDoors(true); ++ if (this.level.plazmaLevelConfiguration().entity.asyncPathProcessing.enabled) return new PathFinder(this.nodeEvaluator, range, nodeEvaluatorGenerator); // Plazma - async path processing + return new PathFinder(this.nodeEvaluator, range); + } + +diff --git a/src/main/java/net/minecraft/world/entity/ai/navigation/PathNavigation.java b/src/main/java/net/minecraft/world/entity/ai/navigation/PathNavigation.java +index fdb08ecc19bc4a1bc93cf6b18adcea2bc5573965..b49b8ee63c67cbaa9e37c39d0559ad5c7b4f55a9 100644 +--- a/src/main/java/net/minecraft/world/entity/ai/navigation/PathNavigation.java ++++ b/src/main/java/net/minecraft/world/entity/ai/navigation/PathNavigation.java +@@ -152,6 +152,8 @@ public abstract class PathNavigation { + return null; + } else if (!this.canUpdatePath()) { + return null; ++ } else if (this.path instanceof org.plazmamc.plazma.entity.path.AsyncPath asyncPath && !asyncPath.isProcessed() && asyncPath.hasSameProcessingPositions(positions)) { // Plazma start - catch early if it's still processing these positions let it keep processing ++ return this.path; // plazma end + } else if (this.path != null && !this.path.isDone() && positions.contains(this.targetPos)) { + return this.path; + } else { +@@ -177,13 +179,30 @@ public abstract class PathNavigation { + int i = (int)(followRange + (float)range); + PathNavigationRegion pathNavigationRegion = new PathNavigationRegion(this.level, blockPos.offset(-i, -i, -i), blockPos.offset(i, i, i)); + Path path = this.pathFinder.findPath(pathNavigationRegion, this.mob, positions, followRange, distance, this.maxVisitedNodesMultiplier); +- //this.level.getProfiler().pop(); // Purpur +- if (path != null && path.getTarget() != null) { +- this.targetPos = path.getTarget(); +- this.reachRange = distance; +- this.resetStuckTimeout(); ++ // Plazma start - async path processing ++ if (this.level.plazmaLevelConfiguration().entity.asyncPathProcessing.enabled) { ++ // assign early a target position. most calls will only have 1 position ++ if (!positions.isEmpty()) this.targetPos = positions.iterator().next(); ++ ++ org.plazmamc.plazma.entity.path.AsyncPathProcessor.awaitProcessing(path, processedPath -> { ++ // check that processing didn't take so long that we calculated a new path ++ if (processedPath != this.path) return; ++ ++ if (processedPath != null && processedPath.getTarget() != null) { ++ this.targetPos = processedPath.getTarget(); ++ this.reachRange = distance; ++ this.resetStuckTimeout(); ++ } ++ }); ++ } else { ++ //this.level.getProfiler().pop(); // Purpur ++ if (path != null && path.getTarget() != null) { ++ this.targetPos = path.getTarget(); ++ this.reachRange = distance; ++ this.resetStuckTimeout(); ++ } + } +- ++ // Plazma end + return path; + } + } +@@ -229,8 +248,8 @@ public abstract class PathNavigation { + if (this.isDone()) { + return false; + } else { +- this.trimPath(); +- if (this.path.getNodeCount() <= 0) { ++ if (path.isProcessed()) this.trimPath(); // Plazma start - only trim if processed ++ if (path.isProcessed() && this.path.getNodeCount() <= 0) { // Plazma end + return false; + } else { + this.speedModifier = speed; +@@ -253,7 +272,7 @@ public abstract class PathNavigation { + if (this.hasDelayedRecomputation) { + this.recomputePath(); + } +- ++ if (this.path != null && !this.path.isProcessed()) return; // Plazma - skip pathfinding if we're still processing + if (!this.isDone()) { + if (this.canUpdatePath()) { + this.followThePath(); +@@ -279,6 +298,7 @@ public abstract class PathNavigation { + } + + protected void followThePath() { ++ if (!this.path.isProcessed()) return; // Plazma - skip if not processed + Vec3 vec3 = this.getTempMobPos(); + this.maxDistanceToWaypoint = this.mob.getBbWidth() > 0.75F ? this.mob.getBbWidth() / 2.0F : 0.75F - this.mob.getBbWidth() / 2.0F; + Vec3i vec3i = this.path.getNextNodePos(); +@@ -438,7 +458,7 @@ public abstract class PathNavigation { + public boolean shouldRecomputePath(BlockPos pos) { + if (this.hasDelayedRecomputation) { + return false; +- } else if (this.path != null && !this.path.isDone() && this.path.getNodeCount() != 0) { ++ } else if (this.path != null && this.path.isProcessed() && !this.path.isDone() && this.path.getNodeCount() != 0) { // Plazma - Skip if not processed + Node node = this.path.getEndNode(); + Vec3 vec3 = new Vec3(((double)node.x + this.mob.getX()) / 2.0D, ((double)node.y + this.mob.getY()) / 2.0D, ((double)node.z + this.mob.getZ()) / 2.0D); + return pos.closerToCenterThan(vec3, (double)(this.path.getNodeCount() - this.path.getNextNodeIndex())); +diff --git a/src/main/java/net/minecraft/world/entity/ai/navigation/WaterBoundPathNavigation.java b/src/main/java/net/minecraft/world/entity/ai/navigation/WaterBoundPathNavigation.java +index 87887916ff2f685346699989ba30c35ef7e5715f..f33e96de71a2e2815e859a8d8ad7136c50959b69 100644 +--- a/src/main/java/net/minecraft/world/entity/ai/navigation/WaterBoundPathNavigation.java ++++ b/src/main/java/net/minecraft/world/entity/ai/navigation/WaterBoundPathNavigation.java +@@ -15,10 +15,22 @@ public class WaterBoundPathNavigation extends PathNavigation { + super(entity, world); + } + ++ // Plazma start - async path processing ++ private static final org.plazmamc.plazma.entity.path.NodeEvaluatorGenerator nodeEvaluatorGenerator = (org.plazmamc.plazma.entity.path.NodeEvaluatorFeatures nodeEvaluatorFeatures) -> { ++ SwimNodeEvaluator nodeEvaluator = new SwimNodeEvaluator(nodeEvaluatorFeatures.allowBreaching()); ++ nodeEvaluator.setCanPassDoors(nodeEvaluatorFeatures.canPassDoors()); ++ nodeEvaluator.setCanFloat(nodeEvaluatorFeatures.canFloat()); ++ nodeEvaluator.setCanWalkOverFences(nodeEvaluatorFeatures.canWalkOverFences()); ++ nodeEvaluator.setCanOpenDoors(nodeEvaluatorFeatures.canOpenDoors()); ++ return nodeEvaluator; ++ }; ++ // Plazma end ++ + @Override + protected PathFinder createPathFinder(int range) { + this.allowBreaching = this.mob.getType() == EntityType.DOLPHIN; + this.nodeEvaluator = new SwimNodeEvaluator(this.allowBreaching); ++ if (this.level.plazmaLevelConfiguration().entity.asyncPathProcessing.enabled) return new PathFinder(this.nodeEvaluator, range, nodeEvaluatorGenerator); // Plazma - async path processing + return new PathFinder(this.nodeEvaluator, range); + } + +diff --git a/src/main/java/net/minecraft/world/entity/ai/sensing/NearestBedSensor.java b/src/main/java/net/minecraft/world/entity/ai/sensing/NearestBedSensor.java +index 8db20db72cd51046213625fac46c35854c59ec5d..3dace9e190a65dc5a6cca484ab900c696e7d6034 100644 +--- a/src/main/java/net/minecraft/world/entity/ai/sensing/NearestBedSensor.java ++++ b/src/main/java/net/minecraft/world/entity/ai/sensing/NearestBedSensor.java +@@ -57,20 +57,39 @@ public class NearestBedSensor extends Sensor { + java.util.List, BlockPos>> poiposes = new java.util.ArrayList<>(); + // don't ask me why it's unbounded. ask mojang. + io.papermc.paper.util.PoiAccess.findAnyPoiPositions(poiManager, type -> type.is(PoiTypes.HOME), predicate, entity.blockPosition(), 48, PoiManager.Occupancy.ANY, false, Integer.MAX_VALUE, poiposes); +- Path path = AcquirePoi.findPathToPois(entity, new java.util.HashSet<>(poiposes)); +- // Paper end - optimise POI access +- if (path != null && path.canReach()) { +- BlockPos blockPos = path.getTarget(); +- Optional> optional = poiManager.getType(blockPos); +- if (optional.isPresent()) { +- entity.getBrain().setMemory(MemoryModuleType.NEAREST_BED, blockPos); +- } +- } else if (this.triedCount < 5) { +- this.batchCache.long2LongEntrySet().removeIf((entry) -> { +- return entry.getLongValue() < this.lastUpdate; ++ // Plazma start - await on async path processing ++ if (world.plazmaLevelConfiguration().entity.asyncPathProcessing.enabled) { ++ Path possiblePath = AcquirePoi.findPathToPois(entity, new java.util.HashSet<>(poiposes)); ++ org.plazmamc.plazma.entity.path.AsyncPathProcessor.awaitProcessing(possiblePath, path -> { ++ // read canReach check ++ if ((path == null || !path.canReach()) && this.triedCount < 5) { ++ this.batchCache.long2LongEntrySet().removeIf((entry) -> entry.getLongValue() < this.lastUpdate); ++ return; ++ } ++ if (path == null) return; ++ ++ BlockPos blockPos = path.getTarget(); ++ Optional> optional = poiManager.getType(blockPos); ++ if (optional.isPresent()) { ++ entity.getBrain().setMemory(MemoryModuleType.NEAREST_BED, blockPos); ++ } + }); ++ } else { ++ Path path = AcquirePoi.findPathToPois(entity, new java.util.HashSet<>(poiposes)); ++ // Paper end - optimise POI access ++ if (path != null && path.canReach()) { ++ BlockPos blockPos = path.getTarget(); ++ Optional> optional = poiManager.getType(blockPos); ++ if (optional.isPresent()) { ++ entity.getBrain().setMemory(MemoryModuleType.NEAREST_BED, blockPos); ++ } ++ } else if (this.triedCount < 5) { ++ this.batchCache.long2LongEntrySet().removeIf((entry) -> { ++ return entry.getLongValue() < this.lastUpdate; ++ }); ++ } + } +- ++ // Plazma end + } + } + } +diff --git a/src/main/java/net/minecraft/world/entity/animal/Bee.java b/src/main/java/net/minecraft/world/entity/animal/Bee.java +index e0200f84270068612e67671cb027cc0c5145bdf9..c692fcd94d48cba73e4110a2ae7bf290ce5af330 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/Bee.java ++++ b/src/main/java/net/minecraft/world/entity/animal/Bee.java +@@ -1147,7 +1147,7 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal { + } else { + Bee.this.pathfindRandomlyTowards(Bee.this.hivePos); + } +- } else { ++ } else if (navigation.getPath() != null && navigation.getPath().isProcessed()) { // Plazma - check processing + boolean flag = this.pathfindDirectlyTowards(Bee.this.hivePos); + + if (!flag) { +@@ -1209,7 +1209,7 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal { + } else { + Path pathentity = Bee.this.navigation.getPath(); + +- return pathentity != null && pathentity.getTarget().equals(pos) && pathentity.canReach() && pathentity.isDone(); ++ return pathentity != null && pathentity.isProcessed() && pathentity.getTarget().equals(pos) && pathentity.canReach() && pathentity.isDone(); // Plazma - ensure path is processed + } + } + } +diff --git a/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java b/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java +index c0fce0582530e24d25368a9600b4f8c06d4f8286..64ef4487c751e9f7443cdf292b9da544d71d1a4b 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java ++++ b/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java +@@ -453,6 +453,17 @@ public class Frog extends Animal implements VariantHolder { + super(frog, world); + } + ++ // Plazma start - async path processing ++ private static final org.plazmamc.plazma.entity.path.NodeEvaluatorGenerator nodeEvaluatorGenerator = (org.plazmamc.plazma.entity.path.NodeEvaluatorFeatures nodeEvaluatorFeatures) -> { ++ Frog.FrogNodeEvaluator nodeEvaluator = new Frog.FrogNodeEvaluator(true); ++ nodeEvaluator.setCanPassDoors(nodeEvaluatorFeatures.canPassDoors()); ++ nodeEvaluator.setCanFloat(nodeEvaluatorFeatures.canFloat()); ++ nodeEvaluator.setCanWalkOverFences(nodeEvaluatorFeatures.canWalkOverFences()); ++ nodeEvaluator.setCanOpenDoors(nodeEvaluatorFeatures.canOpenDoors()); ++ return nodeEvaluator; ++ }; ++ // Plazma end ++ + @Override + public boolean canCutCorner(BlockPathTypes nodeType) { + return nodeType != BlockPathTypes.WATER_BORDER && super.canCutCorner(nodeType); +@@ -462,6 +473,7 @@ public class Frog extends Animal implements VariantHolder { + protected PathFinder createPathFinder(int range) { + this.nodeEvaluator = new Frog.FrogNodeEvaluator(true); + this.nodeEvaluator.setCanPassDoors(true); ++ if (this.level.plazmaLevelConfiguration().entity.asyncPathProcessing.enabled) return new PathFinder(this.nodeEvaluator, range, nodeEvaluatorGenerator); // Plazma - async path processing + return new PathFinder(this.nodeEvaluator, range); + } + } +diff --git a/src/main/java/net/minecraft/world/entity/monster/Drowned.java b/src/main/java/net/minecraft/world/entity/monster/Drowned.java +index 63a1cf5604c14025171d7be7434e2d6b64c98107..c592624162737b22cee310afd7052c7da01b72c2 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/Drowned.java ++++ b/src/main/java/net/minecraft/world/entity/monster/Drowned.java +@@ -293,7 +293,7 @@ public class Drowned extends Zombie implements RangedAttackMob { + protected boolean closeToNextPos() { + Path pathentity = this.getNavigation().getPath(); + +- if (pathentity != null) { ++ if (pathentity != null && pathentity.isProcessed()) { // Plazma - ensure path is processed + BlockPos blockposition = pathentity.getTarget(); + + if (blockposition != null) { +diff --git a/src/main/java/net/minecraft/world/entity/monster/Strider.java b/src/main/java/net/minecraft/world/entity/monster/Strider.java +index cfa603c7ccaaf1940aa89fa7cd8fafba29529075..502375a751df060a6ce23de0fb858b904abaebbe 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/Strider.java ++++ b/src/main/java/net/minecraft/world/entity/monster/Strider.java +@@ -100,6 +100,17 @@ public class Strider extends Animal implements ItemSteerable, Saddleable { + this.setPathfindingMalus(BlockPathTypes.DAMAGE_FIRE, 0.0F); + } + ++ // Plazma start - async path processing ++ private static final org.plazmamc.plazma.entity.path.NodeEvaluatorGenerator nodeEvaluatorGenerator = (org.plazmamc.plazma.entity.path.NodeEvaluatorFeatures nodeEvaluatorFeatures) -> { ++ WalkNodeEvaluator nodeEvaluator = new WalkNodeEvaluator(); ++ nodeEvaluator.setCanPassDoors(nodeEvaluatorFeatures.canPassDoors()); ++ nodeEvaluator.setCanFloat(nodeEvaluatorFeatures.canFloat()); ++ nodeEvaluator.setCanWalkOverFences(nodeEvaluatorFeatures.canWalkOverFences()); ++ nodeEvaluator.setCanOpenDoors(nodeEvaluatorFeatures.canOpenDoors()); ++ return nodeEvaluator; ++ }; ++ // Plazma end ++ + // Purpur start + @Override + public boolean isRidable() { +@@ -615,6 +626,7 @@ public class Strider extends Animal implements ItemSteerable, Saddleable { + protected PathFinder createPathFinder(int range) { + this.nodeEvaluator = new WalkNodeEvaluator(); + this.nodeEvaluator.setCanPassDoors(true); ++ if (this.level.plazmaLevelConfiguration().entity.asyncPathProcessing.enabled) return new PathFinder(this.nodeEvaluator, range, nodeEvaluatorGenerator); // Plazma - async path processing + return new PathFinder(this.nodeEvaluator, range); + } + +diff --git a/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java b/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java +index 6d3373393e38f0ee530baab0d828e7c2722e9b9b..5b37246466634f5c39891b34b8f5081dc7bde2a7 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java ++++ b/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java +@@ -640,12 +640,23 @@ public class Warden extends Monster implements VibrationSystem { + protected PathFinder createPathFinder(int range) { + this.nodeEvaluator = new WalkNodeEvaluator(); + this.nodeEvaluator.setCanPassDoors(true); +- return new PathFinder(this.nodeEvaluator, range) { +- @Override +- protected float distance(Node a, Node b) { +- return a.distanceToXZ(b); +- } +- }; ++ // Plazma start - async path processing ++ if (this.level.plazmaLevelConfiguration().entity.asyncPathProcessing.enabled) { ++ return new PathFinder(this.nodeEvaluator, range, GroundPathNavigation.nodeEvaluatorGenerator) { ++ @Override ++ protected float distance(Node a, Node b) { ++ return a.distanceToXZ(b); ++ } ++ }; ++ } else { ++ return new PathFinder(this.nodeEvaluator, range) { ++ @Override ++ protected float distance(Node a, Node b) { ++ return a.distanceToXZ(b); ++ } ++ }; ++ } ++ // Plazma end + } + }; + } +diff --git a/src/main/java/net/minecraft/world/level/pathfinder/Path.java b/src/main/java/net/minecraft/world/level/pathfinder/Path.java +index c4395df154e8c7066d213316f300d62db9231e5c..235e842534bebf17ae447431994b7dac1a272cd3 100644 +--- a/src/main/java/net/minecraft/world/level/pathfinder/Path.java ++++ b/src/main/java/net/minecraft/world/level/pathfinder/Path.java +@@ -33,6 +33,17 @@ public class Path { + this.reached = reachesTarget; + } + ++ // Plazma start - async path processing ++ /** ++ * checks if the path is completely processed in the case of it being computed async ++ * ++ * @return true if the path is processed ++ */ ++ public boolean isProcessed() { ++ return true; ++ } ++ // Plazma end ++ + public void advance() { + ++this.nextNodeIndex; + } +@@ -107,6 +118,7 @@ public class Path { + } + + public boolean sameAs(@Nullable Path o) { ++ if (o == this) return true; // Plazma - short circuit + if (o == null) { + return false; + } else if (o.nodes.size() != this.nodes.size()) { +diff --git a/src/main/java/net/minecraft/world/level/pathfinder/PathFinder.java b/src/main/java/net/minecraft/world/level/pathfinder/PathFinder.java +index a8af51a25b0f99c3a64d9150fdfcd6b818aa7581..bd7a98a3cf36a36fea7db8c2933f925ed9b62056 100644 +--- a/src/main/java/net/minecraft/world/level/pathfinder/PathFinder.java ++++ b/src/main/java/net/minecraft/world/level/pathfinder/PathFinder.java +@@ -24,35 +24,76 @@ public class PathFinder { + public final NodeEvaluator nodeEvaluator; + private static final boolean DEBUG = false; + private final BinaryHeap openSet = new BinaryHeap(); ++ private final @Nullable org.plazmamc.plazma.entity.path.NodeEvaluatorGenerator nodeEvaluatorGenerator; // Plazma - we use this later to generate an evaluator + ++ // Plazma start - support nodeEvaluatorgenerators + public PathFinder(NodeEvaluator pathNodeMaker, int range) { ++ this(pathNodeMaker, range, null); ++ } ++ ++ public PathFinder(NodeEvaluator pathNodeMaker, int range, @Nullable org.plazmamc.plazma.entity.path.NodeEvaluatorGenerator nodeEvaluatorGenerator) { + this.nodeEvaluator = pathNodeMaker; + this.maxVisitedNodes = range; ++ this.nodeEvaluatorGenerator = nodeEvaluatorGenerator; + } ++ // Plazma end + + @Nullable + public Path findPath(PathNavigationRegion world, Mob mob, Set positions, float followRange, int distance, float rangeMultiplier) { +- this.openSet.clear(); +- this.nodeEvaluator.prepare(world, mob); +- Node node = this.nodeEvaluator.getStart(); ++ if (!mob.level.plazmaLevelConfiguration().entity.asyncPathProcessing.enabled) this.openSet.clear();// Plazma - it's always cleared in processPath ++ // Plazma start - use a generated evaluator if we have one otherwise run sync ++ NodeEvaluator nodeEvaluator = this.nodeEvaluatorGenerator == null ? this.nodeEvaluator : org.plazmamc.plazma.entity.path.NodeEvaluatorCache.takeNodeEvaluator(this.nodeEvaluatorGenerator, this.nodeEvaluator); ++ nodeEvaluator.prepare(world, mob); ++ Node node = nodeEvaluator.getStart(); ++ // Plazma end + if (node == null) { ++ org.plazmamc.plazma.entity.path.NodeEvaluatorCache.removeNodeEvaluator(nodeEvaluator); // Plazma - handle nodeEvaluatorGenerator + return null; + } else { + // Paper start - remove streams - and optimize collection + List> map = Lists.newArrayList(); + for (BlockPos pos : positions) { +- map.add(new java.util.AbstractMap.SimpleEntry<>(this.nodeEvaluator.getGoal(pos.getX(), pos.getY(), pos.getZ()), pos)); ++ map.add(new java.util.AbstractMap.SimpleEntry<>(nodeEvaluator.getGoal(pos.getX(), pos.getY(), pos.getZ()), pos)); // Plazma - handle nodeEvaluatorGenerator + } + // Paper end +- Path path = this.findPath(world.getProfiler(), node, map, followRange, distance, rangeMultiplier); +- this.nodeEvaluator.done(); +- return path; ++ // Plazma start - async path processing ++ if (this.nodeEvaluatorGenerator == null) { ++ // run sync :( ++ org.plazmamc.plazma.entity.path.NodeEvaluatorCache.removeNodeEvaluator(nodeEvaluator); ++ return this.findPath(world.getProfiler(), node, map, followRange, distance, rangeMultiplier); // Gale - Purpur - remove vanilla profiler ++ } ++ ++ return new org.plazmamc.plazma.entity.path.AsyncPath(Lists.newArrayList(), positions, () -> { ++ try { ++ return this.processPath(nodeEvaluator, node, map, followRange, distance, rangeMultiplier); ++ } catch (Exception e) { ++ e.printStackTrace(); ++ return null; ++ } finally { ++ nodeEvaluator.done(); ++ org.plazmamc.plazma.entity.path.NodeEvaluatorCache.returnNodeEvaluator(nodeEvaluator); ++ } ++ }); ++ // Plazma end + } + } + +- @Nullable ++ // Plazma start - split pathfinding into the original sync method for compat and processing for delaying ++ //@Nullable // Plazma - Always not null + // Paper start - optimize collection + private Path findPath(ProfilerFiller profiler, Node startNode, List> positions, float followRange, int distance, float rangeMultiplier) { ++ try { ++ return this.processPath(this.nodeEvaluator, startNode, positions, followRange, distance, rangeMultiplier); ++ } catch (Exception e) { ++ e.printStackTrace(); ++ return null; ++ } finally { ++ this.nodeEvaluator.done(); ++ } ++ } ++ ++ private synchronized @org.jetbrains.annotations.NotNull Path processPath(NodeEvaluator nodeEvaluator, Node startNode, List> positions, float followRange, int distance, float rangeMultiplier) { // sync to only use the caching functions in this class on a single thread ++ org.apache.commons.lang3.Validate.isTrue(!positions.isEmpty()); // ensure that we have at least one position, which means we'll always return a path + //profiler.push("find_path"); // Purpur + //profiler.markForCharting(MetricCategory.PATH_FINDING); // Purpur + // Set set = positions.keySet(); +@@ -91,7 +132,7 @@ public class PathFinder { + } + + if (!(node.distanceTo(startNode) >= followRange)) { +- int k = this.nodeEvaluator.getNeighbors(this.neighbors, node); ++ int k = nodeEvaluator.getNeighbors(this.neighbors, node); // Plazma - use provided nodeEvaluator + + for(int l = 0; l < k; ++l) { + Node node2 = this.neighbors[l]; +@@ -126,6 +167,7 @@ public class PathFinder { + return best; + // Paper end + } ++ // Plazma end + + protected float distance(Node a, Node b) { + return a.distanceTo(b); +diff --git a/src/main/java/net/minecraft/world/level/pathfinder/SwimNodeEvaluator.java b/src/main/java/net/minecraft/world/level/pathfinder/SwimNodeEvaluator.java +index 0e2b14e7dfedf209d63279c81723fd7955122d78..6e2c0790c3b932d3aad1b1eaf11d279840f19914 100644 +--- a/src/main/java/net/minecraft/world/level/pathfinder/SwimNodeEvaluator.java ++++ b/src/main/java/net/minecraft/world/level/pathfinder/SwimNodeEvaluator.java +@@ -16,7 +16,7 @@ import net.minecraft.world.level.block.state.BlockState; + import net.minecraft.world.level.material.FluidState; + + public class SwimNodeEvaluator extends NodeEvaluator { +- private final boolean allowBreaching; ++ public final boolean allowBreaching; // Plazma - make this public + private final Long2ObjectMap pathTypesByPosCache = new Long2ObjectOpenHashMap<>(); + + public SwimNodeEvaluator(boolean canJumpOutOfWater) { +diff --git a/src/main/java/org/plazmamc/plazma/configurations/GlobalConfiguration.java b/src/main/java/org/plazmamc/plazma/configurations/GlobalConfiguration.java +index 36511f71fcf3a8a5da746dd087003861a4f0a8f4..06947eea29a23d8fa1fc87d5036b9297274f9060 100644 +--- a/src/main/java/org/plazmamc/plazma/configurations/GlobalConfiguration.java ++++ b/src/main/java/org/plazmamc/plazma/configurations/GlobalConfiguration.java +@@ -94,4 +94,33 @@ public class GlobalConfiguration extends ConfigurationPart { + } + + } ++ ++ public Entity entity; ++ ++ public class Entity extends ConfigurationPart { ++ ++ public AsyncPathProcessing asyncPathProcessing; ++ ++ public class AsyncPathProcessing extends ConfigurationPart.Post { ++ ++ public boolean enabled = false; ++ public int maxThreads = 0; ++ public int keepAlive = 60; ++ ++ @Override ++ public void postProcess() { ++ if (maxThreads < 0) { ++ maxThreads = Math.max(Runtime.getRuntime().availableProcessors() + maxThreads, 1); ++ } else if (maxThreads == 0) { ++ maxThreads = Math.max(Runtime.getRuntime().availableProcessors() / 4, 1); ++ } ++ if (!enabled) { ++ maxThreads = 0; ++ } else { ++ org.bukkit.Bukkit.getLogger().log(java.util.logging.Level.INFO, "Using " + maxThreads + " threads for Async Pathfinding"); ++ } ++ } ++ ++ } ++ } + } +diff --git a/src/main/java/org/plazmamc/plazma/configurations/LevelConfigurations.java b/src/main/java/org/plazmamc/plazma/configurations/LevelConfigurations.java +index 29d451f55dabc15478e9c32d2c37bd0ea2d9bebc..ed1963723db04aa027e987f1aa421b2a3e914cc4 100644 +--- a/src/main/java/org/plazmamc/plazma/configurations/LevelConfigurations.java ++++ b/src/main/java/org/plazmamc/plazma/configurations/LevelConfigurations.java +@@ -130,6 +130,19 @@ public class LevelConfigurations extends ConfigurationPart { + + } + ++ public AsyncPathProcessing asyncPathProcessing; ++ ++ public class AsyncPathProcessing extends ConfigurationPart.Post { ++ ++ public boolean enabled = DO_OPTIMIZE; ++ ++ @Override ++ public void postProcess() { ++ enabled = enabled && org.plazmamc.plazma.configurations.GlobalConfiguration.get().entity.asyncPathProcessing.enabled; ++ } ++ ++ } ++ + } + + public CarpetFixes carpetFixes; +diff --git a/src/main/java/org/plazmamc/plazma/entity/path/AsyncPath.java b/src/main/java/org/plazmamc/plazma/entity/path/AsyncPath.java +new file mode 100644 +index 0000000000000000000000000000000000000000..dace533ffe536a56a38b5db8084fd8e84d91f759 +--- /dev/null ++++ b/src/main/java/org/plazmamc/plazma/entity/path/AsyncPath.java +@@ -0,0 +1,283 @@ ++package org.plazmamc.plazma.entity.path; ++ ++import net.minecraft.core.BlockPos; ++import net.minecraft.world.entity.Entity; ++import net.minecraft.world.level.pathfinder.Node; ++import net.minecraft.world.level.pathfinder.Path; ++import net.minecraft.world.phys.Vec3; ++import org.jetbrains.annotations.NotNull; ++import org.jetbrains.annotations.Nullable; ++ ++import java.util.ArrayList; ++import java.util.List; ++import java.util.Set; ++import java.util.function.Supplier; ++ ++/** ++ * i'll be using this to represent a path that not be processed yet! ++ */ ++public class AsyncPath extends Path { ++ ++ /** ++ * runnables waiting for this to be processed ++ */ ++ private final List postProcessing = new ArrayList<>(0); ++ /** ++ * a list of positions that this path could path towards ++ */ ++ private final Set positions; ++ /** ++ * the supplier of the real processed path ++ */ ++ private final Supplier pathSupplier; ++ /** ++ * this is a reference to the nodes list in the parent `Path` object ++ */ ++ private final List nodes; ++ ++ /* ++ * Processed values ++ */ ++ /** ++ * marks whether this async path has been processed ++ */ ++ private volatile boolean processed = false; ++ /** ++ * the block we're trying to path to ++ *

++ * while processing, we have no idea where this is so consumers of `Path` should check that the path is processed before checking the target block ++ */ ++ private @Nullable BlockPos target; ++ /** ++ * how far we are to the target ++ *

++ * while processing, the target could be anywhere but theoretically we're always "close" to a theoretical target so default is 0 ++ */ ++ private float distToTarget = 0; ++ /** ++ * whether we can reach the target ++ *

++ * while processing, we can always theoretically reach the target so default is true ++ */ ++ private boolean canReach = true; ++ ++ public AsyncPath(@NotNull List emptyNodeList, @NotNull Set positions, @NotNull Supplier pathSupplier) { ++ //noinspection ConstantConditions ++ super(emptyNodeList, null, false); ++ ++ this.nodes = emptyNodeList; ++ this.positions = positions; ++ this.pathSupplier = pathSupplier; ++ ++ AsyncPathProcessor.queue(this); ++ } ++ ++ @Override ++ public boolean isProcessed() { ++ return this.processed; ++ } ++ ++ /** ++ * returns the future representing the processing state of this path ++ */ ++ public synchronized void postProcessing(@NotNull Runnable runnable) { ++ if (this.processed) { ++ runnable.run(); ++ } else { ++ this.postProcessing.add(runnable); ++ } ++ } ++ ++ /** ++ * an easy way to check if this processing path is the same as an attempted new path ++ * ++ * @param positions - the positions to compare against ++ * @return true if we are processing the same positions ++ */ ++ public boolean hasSameProcessingPositions(final Set positions) { ++ if (this.positions.size() != positions.size()) { ++ return false; ++ } ++ ++ return this.positions.containsAll(positions); ++ } ++ ++ /** ++ * starts processing this path ++ */ ++ public synchronized void process() { ++ if (this.processed) { ++ return; ++ } ++ ++ final Path bestPath = this.pathSupplier.get(); ++ ++ this.nodes.addAll(bestPath.nodes); // we mutate this list to reuse the logic in Path ++ this.target = bestPath.getTarget(); ++ this.distToTarget = bestPath.getDistToTarget(); ++ this.canReach = bestPath.canReach(); ++ ++ this.processed = true; ++ ++ for (Runnable runnable : this.postProcessing) { ++ runnable.run(); ++ } ++ } ++ ++ /** ++ * if this path is accessed while it hasn't processed, just process it in-place ++ */ ++ private void checkProcessed() { ++ if (!this.processed) { ++ this.process(); ++ } ++ } ++ ++ /* ++ * overrides we need for final fields that we cannot modify after processing ++ */ ++ ++ @Override ++ public @NotNull BlockPos getTarget() { ++ this.checkProcessed(); ++ ++ return this.target; ++ } ++ ++ @Override ++ public float getDistToTarget() { ++ this.checkProcessed(); ++ ++ return this.distToTarget; ++ } ++ ++ @Override ++ public boolean canReach() { ++ this.checkProcessed(); ++ ++ return this.canReach; ++ } ++ ++ /* ++ * overrides to ensure we're processed first ++ */ ++ ++ @Override ++ public boolean isDone() { ++ return this.isProcessed() && super.isDone(); ++ } ++ ++ @Override ++ public void advance() { ++ this.checkProcessed(); ++ ++ super.advance(); ++ } ++ ++ @Override ++ public boolean notStarted() { ++ this.checkProcessed(); ++ ++ return super.notStarted(); ++ } ++ ++ @Nullable ++ @Override ++ public Node getEndNode() { ++ this.checkProcessed(); ++ ++ return super.getEndNode(); ++ } ++ ++ @Override ++ public Node getNode(int index) { ++ this.checkProcessed(); ++ ++ return super.getNode(index); ++ } ++ ++ @Override ++ public void truncateNodes(int length) { ++ this.checkProcessed(); ++ ++ super.truncateNodes(length); ++ } ++ ++ @Override ++ public void replaceNode(int index, Node node) { ++ this.checkProcessed(); ++ ++ super.replaceNode(index, node); ++ } ++ ++ @Override ++ public int getNodeCount() { ++ this.checkProcessed(); ++ ++ return super.getNodeCount(); ++ } ++ ++ @Override ++ public int getNextNodeIndex() { ++ this.checkProcessed(); ++ ++ return super.getNextNodeIndex(); ++ } ++ ++ @Override ++ public void setNextNodeIndex(int nodeIndex) { ++ this.checkProcessed(); ++ ++ super.setNextNodeIndex(nodeIndex); ++ } ++ ++ @Override ++ public Vec3 getEntityPosAtNode(Entity entity, int index) { ++ this.checkProcessed(); ++ ++ return super.getEntityPosAtNode(entity, index); ++ } ++ ++ @Override ++ public BlockPos getNodePos(int index) { ++ this.checkProcessed(); ++ ++ return super.getNodePos(index); ++ } ++ ++ @Override ++ public Vec3 getNextEntityPos(Entity entity) { ++ this.checkProcessed(); ++ ++ return super.getNextEntityPos(entity); ++ } ++ ++ @Override ++ public BlockPos getNextNodePos() { ++ this.checkProcessed(); ++ ++ return super.getNextNodePos(); ++ } ++ ++ @Override ++ public Node getNextNode() { ++ this.checkProcessed(); ++ ++ return super.getNextNode(); ++ } ++ ++ @Nullable ++ @Override ++ public Node getPreviousNode() { ++ this.checkProcessed(); ++ ++ return super.getPreviousNode(); ++ } ++ ++ @Override ++ public boolean hasNext() { ++ this.checkProcessed(); ++ ++ return super.hasNext(); ++ } ++} +diff --git a/src/main/java/org/plazmamc/plazma/entity/path/AsyncPathProcessor.java b/src/main/java/org/plazmamc/plazma/entity/path/AsyncPathProcessor.java +new file mode 100644 +index 0000000000000000000000000000000000000000..8e19489f53c4386963ef03c4b5ac716aa1733be6 +--- /dev/null ++++ b/src/main/java/org/plazmamc/plazma/entity/path/AsyncPathProcessor.java +@@ -0,0 +1,49 @@ ++package org.plazmamc.plazma.entity.path; ++ ++import com.google.common.util.concurrent.ThreadFactoryBuilder; ++import net.minecraft.server.MinecraftServer; ++import net.minecraft.world.level.pathfinder.Path; ++import org.jetbrains.annotations.NotNull; ++import org.jetbrains.annotations.Nullable; ++import org.plazmamc.plazma.configurations.GlobalConfiguration; ++ ++import java.util.concurrent.*; ++import java.util.function.Consumer; ++ ++/** ++ * used to handle the scheduling of async path processing ++ */ ++public class AsyncPathProcessor { ++ ++ private static final Executor mainThreadExecutor = MinecraftServer.getServer(); ++ private static final Executor pathProcessingExecutor = new ThreadPoolExecutor( ++ 1, ++ GlobalConfiguration.get().entity.asyncPathProcessing.maxThreads, ++ GlobalConfiguration.get().entity.asyncPathProcessing.keepAlive, TimeUnit.SECONDS, ++ new LinkedBlockingQueue<>(), ++ new ThreadFactoryBuilder() ++ .setNameFormat("plazma-path-processor-%d") ++ .setPriority(Thread.NORM_PRIORITY - 2) ++ .build() ++ ); ++ ++ protected static CompletableFuture queue(@NotNull AsyncPath path) { ++ return CompletableFuture.runAsync(path::process, pathProcessingExecutor); ++ } ++ ++ /** ++ * takes a possibly unprocessed path, and waits until it is completed ++ * the consumer will be immediately invoked if the path is already processed ++ * the consumer will always be called on the main thread ++ * ++ * @param path a path to wait on ++ * @param afterProcessing a consumer to be called ++ */ ++ public static void awaitProcessing(@Nullable Path path, Consumer<@Nullable Path> afterProcessing) { ++ if (path != null && !path.isProcessed() && path instanceof AsyncPath asyncPath) { ++ asyncPath.postProcessing(() -> mainThreadExecutor.execute(() -> afterProcessing.accept(path))); ++ } else { ++ afterProcessing.accept(path); ++ } ++ } ++} +diff --git a/src/main/java/org/plazmamc/plazma/entity/path/NodeEvaluatorCache.java b/src/main/java/org/plazmamc/plazma/entity/path/NodeEvaluatorCache.java +new file mode 100644 +index 0000000000000000000000000000000000000000..9bdc1b8db55bc29012755edcee742c1daddc2077 +--- /dev/null ++++ b/src/main/java/org/plazmamc/plazma/entity/path/NodeEvaluatorCache.java +@@ -0,0 +1,44 @@ ++package org.plazmamc.plazma.entity.path; ++ ++import net.minecraft.world.level.pathfinder.NodeEvaluator; ++import org.apache.commons.lang.Validate; ++import org.jetbrains.annotations.NotNull; ++ ++import java.util.Map; ++import java.util.Queue; ++import java.util.concurrent.ConcurrentHashMap; ++import java.util.concurrent.ConcurrentLinkedQueue; ++ ++public class NodeEvaluatorCache { ++ private static final Map> threadLocalNodeEvaluators = new ConcurrentHashMap<>(); ++ private static final Map nodeEvaluatorToGenerator = new ConcurrentHashMap<>(); ++ ++ private static @NotNull Queue getQueueForFeatures(@NotNull NodeEvaluatorFeatures nodeEvaluatorFeatures) { ++ return threadLocalNodeEvaluators.computeIfAbsent(nodeEvaluatorFeatures, (key) -> new ConcurrentLinkedQueue<>()); ++ } ++ ++ public static @NotNull NodeEvaluator takeNodeEvaluator(@NotNull NodeEvaluatorGenerator generator, @NotNull NodeEvaluator localNodeEvaluator) { ++ final NodeEvaluatorFeatures nodeEvaluatorFeatures = NodeEvaluatorFeatures.fromNodeEvaluator(localNodeEvaluator); ++ NodeEvaluator nodeEvaluator = getQueueForFeatures(nodeEvaluatorFeatures).poll(); ++ ++ if (nodeEvaluator == null) { ++ nodeEvaluator = generator.generate(nodeEvaluatorFeatures); ++ } ++ ++ nodeEvaluatorToGenerator.put(nodeEvaluator, generator); ++ ++ return nodeEvaluator; ++ } ++ ++ public static void returnNodeEvaluator(@NotNull NodeEvaluator nodeEvaluator) { ++ final NodeEvaluatorGenerator generator = nodeEvaluatorToGenerator.remove(nodeEvaluator); ++ Validate.notNull(generator, "NodeEvaluator already returned"); ++ ++ final NodeEvaluatorFeatures nodeEvaluatorFeatures = NodeEvaluatorFeatures.fromNodeEvaluator(nodeEvaluator); ++ getQueueForFeatures(nodeEvaluatorFeatures).offer(nodeEvaluator); ++ } ++ ++ public static void removeNodeEvaluator(@NotNull NodeEvaluator nodeEvaluator) { ++ nodeEvaluatorToGenerator.remove(nodeEvaluator); ++ } ++} +diff --git a/src/main/java/org/plazmamc/plazma/entity/path/NodeEvaluatorFeatures.java b/src/main/java/org/plazmamc/plazma/entity/path/NodeEvaluatorFeatures.java +new file mode 100644 +index 0000000000000000000000000000000000000000..967683e8d3cd8e946c7e8478bf70e68ec62baead +--- /dev/null ++++ b/src/main/java/org/plazmamc/plazma/entity/path/NodeEvaluatorFeatures.java +@@ -0,0 +1,21 @@ ++package org.plazmamc.plazma.entity.path; ++ ++import net.minecraft.world.level.pathfinder.NodeEvaluator; ++import net.minecraft.world.level.pathfinder.SwimNodeEvaluator; ++ ++public record NodeEvaluatorFeatures(NodeEvaluatorType type, ++ boolean canPassDoors, ++ boolean canFloat, ++ boolean canWalkOverFences, ++ boolean canOpenDoors, ++ boolean allowBreaching) { ++ public static NodeEvaluatorFeatures fromNodeEvaluator(NodeEvaluator nodeEvaluator) { ++ NodeEvaluatorType type = NodeEvaluatorType.fromNodeEvaluator(nodeEvaluator); ++ boolean canPassDoors = nodeEvaluator.canPassDoors(); ++ boolean canFloat = nodeEvaluator.canFloat(); ++ boolean canWalkOverFences = nodeEvaluator.canWalkOverFences(); ++ boolean canOpenDoors = nodeEvaluator.canOpenDoors(); ++ boolean allowBreaching = nodeEvaluator instanceof SwimNodeEvaluator swimNodeEvaluator && swimNodeEvaluator.allowBreaching; ++ return new NodeEvaluatorFeatures(type, canPassDoors, canFloat, canWalkOverFences, canOpenDoors, allowBreaching); ++ } ++} +diff --git a/src/main/java/org/plazmamc/plazma/entity/path/NodeEvaluatorGenerator.java b/src/main/java/org/plazmamc/plazma/entity/path/NodeEvaluatorGenerator.java +new file mode 100644 +index 0000000000000000000000000000000000000000..ac46dc9f8184a2429471b3dd8755a6b64f750539 +--- /dev/null ++++ b/src/main/java/org/plazmamc/plazma/entity/path/NodeEvaluatorGenerator.java +@@ -0,0 +1,10 @@ ++package org.plazmamc.plazma.entity.path; ++ ++import net.minecraft.world.level.pathfinder.NodeEvaluator; ++import org.jetbrains.annotations.NotNull; ++ ++public interface NodeEvaluatorGenerator { ++ ++ @NotNull NodeEvaluator generate(NodeEvaluatorFeatures nodeEvaluatorFeatures); ++ ++} +\ No newline at end of file +diff --git a/src/main/java/org/plazmamc/plazma/entity/path/NodeEvaluatorType.java b/src/main/java/org/plazmamc/plazma/entity/path/NodeEvaluatorType.java +new file mode 100644 +index 0000000000000000000000000000000000000000..300abc5963754002956efbc3b9c3d9921129038e +--- /dev/null ++++ b/src/main/java/org/plazmamc/plazma/entity/path/NodeEvaluatorType.java +@@ -0,0 +1,20 @@ ++package org.plazmamc.plazma.entity.path; ++ ++import net.minecraft.world.level.pathfinder.AmphibiousNodeEvaluator; ++import net.minecraft.world.level.pathfinder.FlyNodeEvaluator; ++import net.minecraft.world.level.pathfinder.NodeEvaluator; ++import net.minecraft.world.level.pathfinder.SwimNodeEvaluator; ++ ++public enum NodeEvaluatorType { ++ WALK, ++ SWIM, ++ AMPHIBIOUS, ++ FLY; ++ ++ public static NodeEvaluatorType fromNodeEvaluator(NodeEvaluator nodeEvaluator) { ++ if (nodeEvaluator instanceof SwimNodeEvaluator) return SWIM; ++ if (nodeEvaluator instanceof FlyNodeEvaluator) return FLY; ++ if (nodeEvaluator instanceof AmphibiousNodeEvaluator) return AMPHIBIOUS; ++ return WALK; ++ } ++}