Merge pull request #833 from Swofty-Developments/chore/minestom-26.2

feat(mob): vanilla mob AI on Minestom 26.2

Author: Swofty-Developments

gradle/libs.versions.toml

@@ -20,7 +20,7 @@ junit = "4.13.2"
 junit-jupiter = "6.1.0"
 kotlin-stdlib = "2.3.20"
 lombok = "1.18.46"
-minestom = "2026.06.05-26.1.2"
+minestom = "2026.07.22-26.2"
 mongodb = "5.6.4"
 netty-bom = "4.2.9.Final"
 polar = "1.16.0"

type.bedwarsgame/src/main/java/net/swofty/type/bedwarsgame/game/v2/listener/PlayerTeamAssignationListener.java

@@ -12,6 +12,7 @@
 import net.swofty.type.generic.event.EventNodes;
 import net.swofty.type.generic.event.phase.PhasedEvent;
 import net.swofty.type.generic.event.HypixelEventClass;
+import net.swofty.type.generic.utility.TeamColorUtility;
 
 public class PlayerTeamAssignationListener implements HypixelEventClass {
 
@@ -24,7 +25,7 @@ public void onPlayerTeamAssign(PlayerAssignedTeamEvent<BedWarsTeam> event) {
         NamedTextColor color = NamedTextColor.nearestTo(textColor); // possible performance hit?
         player.setTeam(new TeamBuilder(event.team().getName(), MinecraftServer.getTeamManager())
             .prefix(Component.text(event.team().firstLetter(), textColor, TextDecoration.BOLD).appendSpace())
-            .teamColor(color)
+            .teamColor(TeamColorUtility.fromNamedColor(color))
             .build());
         player.getTeam().sendUpdatePacket();
     }

type.generic/src/main/java/net/swofty/type/generic/HypixelGenericLoader.java

@@ -24,7 +24,6 @@
 import net.minestom.server.instance.InstanceContainer;
 import net.minestom.server.instance.InstanceManager;
 import net.minestom.server.instance.block.Block;
-import net.minestom.server.monitoring.BenchmarkManager;
 import net.minestom.server.monitoring.TickMonitor;
 import net.minestom.server.registry.RegistryKey;
 import net.minestom.server.timer.TaskSchedule;
@@ -69,7 +68,6 @@
 import java.io.IOException;
 import java.lang.reflect.InvocationTargetException;
 import java.nio.file.Files;
-import java.time.Duration;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
@@ -180,14 +178,12 @@ public int getBiomeId(@NotNull String name) {
         if (!isSkyBlockType && !(loader.getType() == ServerType.BEDWARS_GAME)) {
             MinecraftServer.getGlobalEventHandler().addListener(ServerTickMonitorEvent.class, event ->
                     LAST_TICK.set(event.getTickMonitor()));
-            BenchmarkManager benchmarkManager = MinecraftServer.getBenchmarkManager();
-            benchmarkManager.enable(Duration.ofDays(3));
             MinecraftServer.getSchedulerManager().buildTask(() -> {
                 Collection<HypixelPlayer> players = getLoadedPlayers();
                 if (players.isEmpty())
                     return;
 
-                long ramUsage = benchmarkManager.getUsedMemory();
+                long ramUsage = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
                 ramUsage /= (long) 1e6; // bytes to MB
                 TickMonitor tickMonitor = LAST_TICK.get();
                 double TPS = 1000 / tickMonitor.getTickTime();

type.generic/src/main/java/net/swofty/type/generic/data/HypixelDataHandler.java

@@ -7,6 +7,7 @@
 import net.minestom.server.entity.Player;
 import net.minestom.server.scoreboard.Team;
 import net.minestom.server.scoreboard.TeamBuilder;
+import net.swofty.type.generic.utility.TeamColorUtility;
 import net.swofty.commons.ServerType;
 import net.swofty.commons.StringUtility;
 import net.swofty.type.generic.HypixelConst;
@@ -190,7 +191,7 @@ public enum Data {
                 String teamName = StringUtility.limitStringLength(rank.getPriorityCharacter() + player.getUsername(), 15);
                 Team team = new TeamBuilder("H" + teamName, MinecraftServer.getTeamManager())
                     .prefix(((HypixelPlayer) player).getRankPrefix())
-                        .teamColor(rank.getTextColor())
+                        .teamColor(TeamColorUtility.fromNamedColor(rank.getTextColor()))
                         .build();
                 player.setTeam(team);
                 player.getTeam().sendUpdatePacket();
@@ -204,7 +205,7 @@ public enum Data {
             String teamName = StringUtility.limitStringLength(rank.getPriorityCharacter() + player.getUsername(), 15);
             player.setTeam(new TeamBuilder("H" + teamName, MinecraftServer.getTeamManager())
                 .prefix(((HypixelPlayer) player).getRankPrefix())
-                    .teamColor(rank.getTextColor())
+                    .teamColor(TeamColorUtility.fromNamedColor(rank.getTextColor()))
                     .build());
             player.getTeam().sendUpdatePacket();
         }),

type.generic/src/main/java/net/swofty/type/generic/entity/ai/vanilla/PathComputationType.java

@@ -0,0 +1,8 @@
+package net.swofty.type.generic.entity.ai.vanilla;
+
+/** Port of {@code net.minecraft.world.level.pathfinder.PathComputationType}. */
+public enum PathComputationType {
+   LAND,
+   WATER,
+   AIR;
+}

type.generic/src/main/java/net/swofty/type/generic/entity/ai/vanilla/PathType.java

@@ -0,0 +1,42 @@
+package net.swofty.type.generic.entity.ai.vanilla;
+
+/** Port of {@code net.minecraft.world.level.pathfinder.PathType} (27 node classifications). */
+public enum PathType {
+   BLOCKED(-1.0F),
+   OPEN(0.0F),
+   WALKABLE(0.0F),
+   WALKABLE_DOOR(0.0F),
+   TRAPDOOR(0.0F),
+   POWDER_SNOW(-1.0F),
+   ON_TOP_OF_POWDER_SNOW(0.0F),
+   FENCE(-1.0F),
+   LAVA(-1.0F),
+   WATER(8.0F),
+   WATER_BORDER(8.0F),
+   RAIL(0.0F),
+   UNPASSABLE_RAIL(-1.0F),
+   FIRE_IN_NEIGHBOR(8.0F),
+   FIRE(16.0F),
+   DAMAGING_IN_NEIGHBOR(8.0F),
+   DAMAGING(-1.0F),
+   DOOR_OPEN(0.0F),
+   DOOR_WOOD_CLOSED(-1.0F),
+   DOOR_IRON_CLOSED(-1.0F),
+   BREACH(4.0F),
+   LEAVES(-1.0F),
+   STICKY_HONEY(8.0F),
+   COCOA(0.0F),
+   DAMAGE_CAUTIOUS(0.0F),
+   ON_TOP_OF_TRAPDOOR(0.0F),
+   BIG_MOBS_CLOSE_TO_DANGER(4.0F);
+
+   private final float malus;
+
+   PathType(final float defaultCost) {
+      this.malus = defaultCost;
+   }
+
+   public float getMalus() {
+      return this.malus;
+   }
+}

type.generic/src/main/java/net/swofty/type/generic/entity/ai/vanilla/VanillaGroundNodeFollower.java

@@ -0,0 +1,106 @@
+package net.swofty.type.generic.entity.ai.vanilla;
+
+import net.minestom.server.collision.BoundingBox;
+import net.minestom.server.collision.CollisionUtils;
+import net.minestom.server.collision.PhysicsResult;
+import net.minestom.server.coordinate.Point;
+import net.minestom.server.coordinate.Pos;
+import net.minestom.server.coordinate.Vec;
+import net.minestom.server.entity.Entity;
+import net.minestom.server.entity.LivingEntity;
+import net.minestom.server.entity.attribute.Attribute;
+import net.minestom.server.entity.pathfinding.followers.NodeFollower;
+import net.minestom.server.instance.Instance;
+import net.minestom.server.utils.position.PositionUtils;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * A {@link NodeFollower} that moves an entity along a path with vanilla ground movement. It mirrors
+ * Minestom's own {@code GroundNodeFollower} (horizontal {@code Vec} toward the target,
+ * {@link CollisionUtils#handlePhysics} then {@code refreshPosition} with yaw/pitch from the look
+ * point) but adds vanilla auto-step: when the horizontal move is blocked and the entity is on the
+ * ground it retries the move raised by up to {@link #STEP_HEIGHT} and settles back down, so it
+ * climbs 0.5-1.0 block ledges smoothly instead of only being able to jump them.
+ */
+public class VanillaGroundNodeFollower implements NodeFollower {
+   /** Vanilla maximum auto-step height for a ground mob. */
+   private static final double STEP_HEIGHT = 0.6;
+   /** Horizontal "arrived" radius. */
+   private static final double AT_POINT_RADIUS = 0.2;
+   /** Vanilla jump impulse: ~0.42 blocks/tick, expressed in Minestom's blocks/second velocity. */
+   private static final double JUMP_VELOCITY = 0.42 * 20.0;
+
+   private final Entity entity;
+
+   public VanillaGroundNodeFollower(Entity entity) {
+      this.entity = entity;
+   }
+
+   @Override
+   public void moveTowards(Point target, double speed, Point lookAt) {
+      Pos position = this.entity.getPosition();
+      double dx = target.x() - position.x();
+      double dy = target.y() - position.y();
+      double dz = target.z() - position.z();
+      double dxLook = lookAt.x() - position.x();
+      double dyLook = lookAt.y() - position.y();
+      double dzLook = lookAt.z() - position.z();
+
+      // Slow down as the entity reaches its destination (mirrors GroundNodeFollower).
+      double distSquared = dx * dx + dy * dy + dz * dz;
+      if (speed > distSquared) {
+         speed = distSquared;
+      }
+
+      double radians = Math.atan2(dz, dx);
+      double speedX = Math.cos(radians) * speed;
+      double speedZ = Math.sin(radians) * speed;
+      float yaw = PositionUtils.getLookYaw(dxLook, dzLook);
+      float pitch = PositionUtils.getLookPitch(dxLook, dyLook, dzLook);
+
+      Vec move = new Vec(speedX, 0.0, speedZ);
+      PhysicsResult ground = CollisionUtils.handlePhysics(this.entity, move);
+      Pos newPosition = ground.newPosition();
+
+      // Vanilla auto-step: if we hit a wall while on the ground, try climbing a low ledge.
+      Instance instance = this.entity.getInstance();
+      if (instance != null && this.entity.isOnGround() && (ground.collisionX() || ground.collisionZ())) {
+         BoundingBox boundingBox = this.entity.getBoundingBox();
+         Pos raised = position.withY(position.y() + STEP_HEIGHT);
+         PhysicsResult stepped = CollisionUtils.handlePhysics(instance, boundingBox, raised, move, null, false);
+         if (horizontalProgress(stepped.newPosition(), position) > horizontalProgress(ground.newPosition(), position) + 1.0E-4) {
+            // Cleared the ledge raised; settle back onto its top so we don't float.
+            PhysicsResult settle = CollisionUtils.handlePhysics(instance, boundingBox, stepped.newPosition(), new Vec(0.0, -STEP_HEIGHT, 0.0), null, false);
+            newPosition = settle.newPosition();
+         }
+      }
+
+      this.entity.refreshPosition(newPosition.withView(yaw, pitch));
+   }
+
+   private static double horizontalProgress(Point moved, Point origin) {
+      double dx = moved.x() - origin.x();
+      double dz = moved.z() - origin.z();
+      return dx * dx + dz * dz;
+   }
+
+   @Override
+   public void jump(@Nullable Point from, @Nullable Point to) {
+      if (this.entity.isOnGround()) {
+         this.entity.setVelocity(new Vec(0.0, JUMP_VELOCITY, 0.0));
+      }
+   }
+
+   @Override
+   public boolean isAtPoint(Point point) {
+      Pos position = this.entity.getPosition();
+      double dx = position.x() - point.x();
+      double dz = position.z() - point.z();
+      return dx * dx + dz * dz <= AT_POINT_RADIUS * AT_POINT_RADIUS;
+   }
+
+   @Override
+   public double movementSpeed() {
+      return this.entity instanceof LivingEntity living ? living.getAttribute(Attribute.MOVEMENT_SPEED).getValue() : 0.1;
+   }
+}