package me.fridtjof.minecarttrains.managers; import me.fridtjof.minecarttrains.MinecartTrains; import org.bukkit.Bukkit; import org.bukkit.NamespacedKey; import org.bukkit.entity.Entity; import org.bukkit.entity.Minecart; import org.bukkit.entity.minecart.PoweredMinecart; import org.bukkit.persistence.PersistentDataType; import org.bukkit.util.Vector; import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import java.util.UUID; public class LinkageManager { public enum CoupleResult { SUCCESS, SELF, SAME_TRAIN, NOT_AN_END, INVALID } static MinecartTrains plugin = MinecartTrains.getInstance(); private final NamespacedKey key = new NamespacedKey(plugin, "coupler"); private final Map childByParent = new HashMap<>(); private final Map headByCart = new HashMap<>(); private final Map> trainByHead = new HashMap<>(); private final Map leaderByHead = new HashMap<>(); private final Set solvedTrains = new HashSet<>(); private int cacheTick = Integer.MIN_VALUE; public void removeLink(Minecart cart) { if (hasLink(cart)) { childByParent.remove(getLinkUniqueId(cart), cart.getUniqueId()); } cart.getPersistentDataContainer().remove(key); invalidateTrainCache(); } public String getLinkString(Minecart cart) { return cart.getPersistentDataContainer().get(key, PersistentDataType.STRING); } public UUID getLinkUniqueId(Minecart cart) { return UUID.fromString(getLinkString(cart)); } public void setLink(Minecart cart, String linkedCartUniqueId) { if (hasLink(cart)) { childByParent.remove(getLinkUniqueId(cart), cart.getUniqueId()); } cart.getPersistentDataContainer().set(key, PersistentDataType.STRING, linkedCartUniqueId); childByParent.put(UUID.fromString(linkedCartUniqueId), cart.getUniqueId()); invalidateTrainCache(); } public boolean hasLink(Minecart cart) { return cart.getPersistentDataContainer().has(key, PersistentDataType.STRING); } public Map snapshotLinks() { return Map.copyOf(childByParent); } public void remember(Minecart cart) { if (hasLink(cart)) { childByParent.put(getLinkUniqueId(cart), cart.getUniqueId()); } } public Minecart getParent(Minecart cart) { if (!hasLink(cart)) { return null; } Entity parent = Bukkit.getEntity(getLinkUniqueId(cart)); return parent instanceof Minecart minecart ? minecart : null; } public Minecart getChild(Minecart parent) { UUID childId = childByParent.get(parent.getUniqueId()); if (childId != null) { Entity child = Bukkit.getEntity(childId); if (child instanceof Minecart minecart) { return minecart; } } for (Entity entity : parent.getNearbyEntities(24, 6, 24)) { if (entity instanceof Minecart cart && hasLink(cart) && getLinkUniqueId(cart).equals(parent.getUniqueId())) { childByParent.put(parent.getUniqueId(), cart.getUniqueId()); return cart; } } return null; } public Minecart findHead(Minecart cart) { refreshTickCache(); UUID cachedHeadId = headByCart.get(cart.getUniqueId()); if (cachedHeadId != null) { Entity cachedHead = Bukkit.getEntity(cachedHeadId); if (cachedHead instanceof Minecart minecart) { return minecart; } } List walked = new ArrayList<>(); Minecart current = cart; Set seen = new HashSet<>(); while (hasLink(current) && seen.add(current.getUniqueId())) { walked.add(current); Minecart parent = getParent(current); if (parent == null) { break; } current = parent; } UUID headId = current.getUniqueId(); headByCart.put(headId, headId); for (Minecart walkedCart : walked) { headByCart.put(walkedCart.getUniqueId(), headId); } return current; } public boolean isSameTrain(Minecart first, Minecart second) { return findHead(first).getUniqueId().equals(findHead(second).getUniqueId()); } public List getTrain(Minecart cart) { refreshTickCache(); Minecart head = findHead(cart); List cached = trainByHead.get(head.getUniqueId()); if (cached != null) { return cached; } List chain = new ArrayList<>(); Minecart current = head; Set seen = new HashSet<>(); while (current != null && seen.add(current.getUniqueId())) { chain.add(current); headByCart.put(current.getUniqueId(), head.getUniqueId()); current = getChild(current); } trainByHead.put(head.getUniqueId(), chain); return chain; } public CoupleResult couple(Minecart first, Minecart second) { remember(first); remember(second); if (first.getUniqueId().equals(second.getUniqueId())) { return CoupleResult.SELF; } if (isSameTrain(first, second)) { return CoupleResult.SAME_TRAIN; } boolean firstIsHead = !hasLink(first); boolean secondIsHead = !hasLink(second); boolean firstIsTail = getChild(first) == null; boolean secondIsTail = getChild(second) == null; if (!(firstIsHead || firstIsTail) || !(secondIsHead || secondIsTail)) { return CoupleResult.NOT_AN_END; } if (firstIsHead && firstIsTail && secondIsHead && secondIsTail) { Minecart parent = preferredParent(first, second); Minecart child = parent.getUniqueId().equals(first.getUniqueId()) ? second : first; setLink(child, parent.getUniqueId().toString()); return CoupleResult.SUCCESS; } if (firstIsHead && firstIsTail) { attachSingleToEnd(first, second, secondIsHead, secondIsTail); return CoupleResult.SUCCESS; } if (secondIsHead && secondIsTail) { attachSingleToEnd(second, first, firstIsHead, firstIsTail); return CoupleResult.SUCCESS; } if (firstIsTail && secondIsHead) { setLink(second, first.getUniqueId().toString()); return CoupleResult.SUCCESS; } if (secondIsTail && firstIsHead) { setLink(first, second.getUniqueId().toString()); return CoupleResult.SUCCESS; } if (firstIsHead && secondIsHead) { reverseTrain(first); setLink(second, first.getUniqueId().toString()); return CoupleResult.SUCCESS; } if (firstIsTail && secondIsTail) { reverseTrain(second); setLink(second, first.getUniqueId().toString()); return CoupleResult.SUCCESS; } return CoupleResult.INVALID; } private void attachSingleToEnd(Minecart single, Minecart end, boolean endIsHead, boolean endIsTail) { if (endIsTail && !endIsHead) { setLink(single, end.getUniqueId().toString()); return; } if (endIsHead && !endIsTail) { setLink(end, single.getUniqueId().toString()); return; } setLink(single, end.getUniqueId().toString()); } private Minecart preferredParent(Minecart first, Minecart second) { if (first instanceof PoweredMinecart && !(second instanceof PoweredMinecart)) { return first; } if (second instanceof PoweredMinecart && !(first instanceof PoweredMinecart)) { return second; } return first; } public Minecart findLeader(Minecart cart) { refreshTickCache(); Minecart head = findHead(cart); Minecart cachedLeader = leaderByHead.get(head.getUniqueId()); if (cachedLeader != null && cachedLeader.isValid()) { return cachedLeader; } Minecart bestEngine = null; int bestFuel = -1; for (Minecart candidate : getTrain(cart)) { if (candidate instanceof PoweredMinecart powered && powered.getFuel() > 0) { if (powered.getFuel() > bestFuel) { bestFuel = powered.getFuel(); bestEngine = candidate; } } } if (bestEngine != null) { leaderByHead.put(head.getUniqueId(), bestEngine); } return bestEngine; } public Minecart findMotionFront(Minecart cart) { Minecart engine = findLeader(cart); if (engine != null) { return engine; } List train = getTrain(cart); for (Minecart member : train) { if (member instanceof PoweredMinecart) { return member; } } if (train.size() < 2) { return train.get(0); } Vector motion = new Vector(); for (Minecart member : train) { motion.add(member.getVelocity()); } if (motion.lengthSquared() < 1.0E-6) { return train.get(0); } Minecart head = train.get(0); Minecart tail = train.get(train.size() - 1); Vector headOut = head.getLocation().toVector().subtract(train.get(1).getLocation().toVector()); Vector tailOut = tail.getLocation().toVector().subtract(train.get(train.size() - 2).getLocation().toVector()); return headOut.dot(motion) >= tailOut.dot(motion) ? head : tail; } private void refreshTickCache() { int currentTick = Bukkit.getCurrentTick(); if (currentTick == cacheTick) { return; } cacheTick = currentTick; headByCart.clear(); trainByHead.clear(); leaderByHead.clear(); solvedTrains.clear(); } public boolean markTrainSolved(Minecart cart) { refreshTickCache(); return solvedTrains.add(findHead(cart).getUniqueId()); } private void invalidateTrainCache() { cacheTick = Integer.MIN_VALUE; headByCart.clear(); trainByHead.clear(); leaderByHead.clear(); solvedTrains.clear(); } public boolean isCloserToLeader(Minecart candidate, Minecart other, Minecart leader) { if (leader == null) { return false; } if (candidate.getUniqueId().equals(leader.getUniqueId())) { return true; } if (other.getUniqueId().equals(leader.getUniqueId())) { return false; } for (Minecart trainCart : getTrain(leader)) { if (trainCart.getUniqueId().equals(candidate.getUniqueId())) { return true; } if (trainCart.getUniqueId().equals(other.getUniqueId())) { return false; } } return false; } public void reverseTrain(Minecart cart) { List chain = getTrain(cart); for (Minecart linked : chain) { removeLink(linked); } for (int i = 0; i < chain.size() - 1; i++) { setLink(chain.get(i), chain.get(i + 1).getUniqueId().toString()); } } }