package me.fridtjof.minecarttrains.managers; import me.fridtjof.minecarttrains.utils.FurnaceCarts; import me.fridtjof.minecarttrains.utils.Rails; import org.bukkit.Bukkit; import org.bukkit.Location; import org.bukkit.World; import org.bukkit.entity.Minecart; import org.bukkit.entity.minecart.PoweredMinecart; import org.bukkit.util.Vector; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.UUID; public class LinkPhysics { private static final double STILL = 1.0E-4; private final LinkageManager linkageManager; private final double aimedDistanceLow; private final double aimedDistanceHigh; private final double highSpeedGateSquared; private final double sampleDistance; private final double maxPathLength; private final double snapEpsilonSquared; private final Map trails = new HashMap<>(); public LinkPhysics(LinkageManager linkageManager, ConfigManager configManager) { this.linkageManager = linkageManager; this.aimedDistanceLow = configManager.physicsConfig.getConfig().getDouble("link.low_speed.distance.aimed"); this.aimedDistanceHigh = configManager.physicsConfig.getConfig().getDouble("link.high_speed.distance.aimed"); double highSpeedGate = configManager.physicsConfig.getConfig().getDouble("link.high_speed.gate_speed"); this.highSpeedGateSquared = highSpeedGate * highSpeedGate; this.sampleDistance = configManager.physicsConfig.getConfig().getDouble("link.kinematic.sample_distance"); this.maxPathLength = configManager.physicsConfig.getConfig().getDouble("link.kinematic.max_path_length"); double snapEpsilon = configManager.physicsConfig.getConfig().getDouble("link.kinematic.snap_epsilon"); this.snapEpsilonSquared = snapEpsilon * snapEpsilon; } public void updateTrain(Minecart cart) { if (!linkageManager.markTrainSolved(cart)) { return; } List train = linkageManager.getTrain(cart); if (train.size() < 2) { return; } Minecart reference = linkageManager.findMotionFront(cart); int referenceIndex = indexOf(train, reference); if (referenceIndex < 0) { return; } Vector heading = headingOf(reference); boolean lowerIsAhead = lowerIsAhead(train, referenceIndex, heading); UUID trainId = linkageManager.findHead(cart).getUniqueId(); Trail trail = trails.get(trainId); if (trail != null && !reference.getUniqueId().equals(trail.ownerId)) { trails.remove(trainId); } recordTrail(trainId, reference, heading); double spacing = aimedDistance(reference); for (int i = referenceIndex + 1; i < train.size(); i++) { place(train.get(i), reference, heading, (i - referenceIndex) * spacing, !lowerIsAhead, trainId); } for (int i = referenceIndex - 1; i >= 0; i--) { place(train.get(i), reference, heading, (referenceIndex - i) * spacing, lowerIsAhead, trainId); } pruneTrails(); } private void place(Minecart follower, Minecart reference, Vector heading, double distance, boolean ahead, UUID trainId) { Rails.Pose pose = ahead ? Rails.walk(reference.getLocation(), heading, distance) : poseBehind(trainId, reference, heading, distance); if (pose == null) { return; } Rails.Pose onRail = Rails.snap(pose.location(), pose.tangent()); if (onRail != null) { pose = onRail; } Vector tangent = pose.tangent().clone(); if (tangent.lengthSquared() < STILL) { tangent = heading.clone(); } else { tangent.normalize(); } if (tangent.dot(heading) < 0) { tangent.multiply(-1); } Location target = pose.location(); target.setYaw(Rails.yaw(tangent)); target.setPitch(0f); if (follower.getLocation().distanceSquared(target) > snapEpsilonSquared) { follower.teleport(target); follower.setRotation(target.getYaw(), 0f); } follower.setVelocity(tangent.multiply(reference.getVelocity().length())); follower.setMaxSpeed(reference.getMaxSpeed()); } private Rails.Pose poseBehind(UUID trainId, Minecart reference, Vector heading, double distance) { Trail trail = trails.get(trainId); Rails.Pose fromTrail = trail == null ? null : trail.behind(reference.getWorld(), distance); if (fromTrail != null) { return fromTrail; } return Rails.walk(reference.getLocation(), heading.clone().multiply(-1), distance); } private void recordTrail(UUID trainId, Minecart reference, Vector heading) { Rails.Pose snapped = Rails.snap(reference.getLocation(), heading); Location sample = snapped == null ? reference.getLocation() : snapped.location(); Trail trail = trails.computeIfAbsent(trainId, id -> new Trail()); trail.ownerId = reference.getUniqueId(); trail.record(sample, heading, sampleDistance, maxPathLength); } private void pruneTrails() { if (trails.size() < 16) { return; } trails.keySet().removeIf(id -> Bukkit.getEntity(id) == null); } private Vector headingOf(Minecart cart) { Vector velocity = cart.getVelocity(); if (velocity.lengthSquared() >= STILL) { return velocity.clone().normalize(); } if (cart instanceof PoweredMinecart powered && FurnaceCarts.hasDrive(powered)) { return new Vector(powered.getPushX(), 0, powered.getPushZ()).normalize(); } Vector rail = Rails.tangent(cart.getLocation(), new Vector(0, 0, 1)); if (rail.lengthSquared() >= STILL) { return rail; } return new Vector(0, 0, 1); } private boolean lowerIsAhead(List train, int referenceIndex, Vector heading) { if (referenceIndex > 0) { Vector toLower = train.get(referenceIndex - 1).getLocation().toVector() .subtract(train.get(referenceIndex).getLocation().toVector()); if (toLower.lengthSquared() >= STILL) { return toLower.dot(heading) > 0; } } if (referenceIndex < train.size() - 1) { Vector toHigher = train.get(referenceIndex + 1).getLocation().toVector() .subtract(train.get(referenceIndex).getLocation().toVector()); if (toHigher.lengthSquared() >= STILL) { return toHigher.dot(heading) < 0; } } return true; } private double aimedDistance(Minecart reference) { if (reference.getVelocity().lengthSquared() > highSpeedGateSquared) { return aimedDistanceHigh; } return aimedDistanceLow; } private int indexOf(List train, Minecart cart) { for (int i = 0; i < train.size(); i++) { if (train.get(i).getUniqueId().equals(cart.getUniqueId())) { return i; } } return -1; } private static final class Trail { private UUID ownerId; private final List points = new ArrayList<>(); private Vector lastHeading; private void record(Location location, Vector heading, double sampleDistance, double maxLength) { if (lastHeading != null && heading.lengthSquared() >= STILL && lastHeading.dot(heading) < -0.15) { points.clear(); } if (heading.lengthSquared() >= STILL) { lastHeading = heading.clone().normalize(); } if (points.isEmpty()) { points.add(coords(location)); return; } double[] last = points.get(points.size() - 1); double dx = location.getX() - last[0]; double dy = location.getY() - last[1]; double dz = location.getZ() - last[2]; double gapSquared = dx * dx + dy * dy + dz * dz; if (gapSquared < sampleDistance * sampleDistance) { last[0] = location.getX(); last[1] = location.getY(); last[2] = location.getZ(); return; } Location cursor = new Location(location.getWorld(), last[0], last[1], last[2]); Vector alongRails = new Vector(dx, dy, dz); double gap = Math.sqrt(gapSquared); double walked = 0; while (walked + sampleDistance < gap) { Rails.Pose step = Rails.walk(cursor, alongRails, sampleDistance); if (step == null) { break; } cursor = step.location(); alongRails = step.tangent(); points.add(coords(cursor)); walked += sampleDistance; } points.add(coords(location)); trim(maxLength); } private Rails.Pose behind(World world, double distance) { if (points.size() < 2) { return null; } double remaining = distance; for (int i = points.size() - 1; i > 0; i--) { double[] newer = points.get(i); double[] older = points.get(i - 1); double dx = older[0] - newer[0]; double dy = older[1] - newer[1]; double dz = older[2] - newer[2]; double length = Math.sqrt(dx * dx + dy * dy + dz * dz); if (length < 1.0E-8) { continue; } if (remaining <= length) { double t = remaining / length; Location location = new Location(world, newer[0] + dx * t, newer[1] + dy * t, newer[2] + dz * t); return new Rails.Pose(location, new Vector(-dx, -dy, -dz).normalize()); } remaining -= length; } return null; } private static double[] coords(Location location) { return new double[] {location.getX(), location.getY(), location.getZ()}; } private void trim(double maxLength) { double length = 0; for (int i = points.size() - 1; i > 0; i--) { double[] newer = points.get(i); double[] older = points.get(i - 1); double dx = older[0] - newer[0]; double dy = older[1] - newer[1]; double dz = older[2] - newer[2]; length += Math.sqrt(dx * dx + dy * dy + dz * dz); if (length > maxLength) { points.subList(0, i).clear(); return; } } } } }