V2

-- Comment
     + This Plugin doesnt work really well
     + Idk if i should fix thi

     -- File Updates
     + Fmpp.kt
     + FMPPCommand.kt

src/main/kotlin/org/fmpp/fmpp/FMPPCommand.kt

@@ -1,12 +1,18 @@
 package org.fmpp.fmpp
 
 import org.bukkit.ChatColor
+import org.bukkit.Material
 import org.bukkit.command.Command
 import org.bukkit.command.CommandExecutor
 import org.bukkit.command.CommandSender
+import org.bukkit.entity.Minecart
 import org.bukkit.entity.Player
 import org.bukkit.entity.minecart.PoweredMinecart
+import org.bukkit.inventory.ItemStack
+import org.bukkit.metadata.FixedMetadataValue
+import org.bukkit.util.Vector
 
+@Suppress("DEPRECATION")
 class FMPPCommand(private val plugin: Fmpp) : CommandExecutor {
 
     override fun onCommand(sender: CommandSender, command: Command, label: String, args: Array<out String>): Boolean {
@@ -24,6 +30,8 @@ class FMPPCommand(private val plugin: Fmpp) : CommandExecutor {
             "boost" -> boostMinecart(sender)
             "fuel" -> refuelMinecart(sender)
             "stop" -> stopMinecart(sender)
+            "link" -> linkNearestMinecarts(sender)
+            "unlink" -> unlinkMinecart(sender)
             "help" -> showHelp(sender)
             else -> {
                 sender.sendMessage("${ChatColor.RED}Unknown command. Use /fmpp help for a list of commands.")
@@ -37,43 +45,211 @@ class FMPPCommand(private val plugin: Fmpp) : CommandExecutor {
     private fun boostMinecart(player: Player) {
         val vehicle = player.vehicle
 
-        if (vehicle is PoweredMinecart) {
+        if (vehicle is Minecart) {
-            // Boost the minecart in the direction it's facing
+            // Get powered minecart if this is a linked regular minecart
-            val direction = vehicle.location.direction.setY(0).normalize()
+            val poweredMinecart = if (vehicle is PoweredMinecart) {
-            vehicle.velocity = vehicle.velocity.add(direction.multiply(0.5))
+                vehicle
-            player.sendMessage("${ChatColor.GREEN}Minecart boosted!")
+            } else if (vehicle.hasMetadata("fmpp_linked")) {
+                // Find linked powered minecart
+                vehicle.getNearbyEntities(5.0, 5.0, 5.0)
+                    .filterIsInstance<PoweredMinecart>()
+                    .firstOrNull { it.hasMetadata("fmpp_linked_to") &&
+                            it.getMetadata("fmpp_linked_to").firstOrNull()?.asString() == vehicle.uniqueId.toString() }
+            } else {
+                null
+            }
+
+            if (poweredMinecart != null) {
+                // Boost the powered minecart in the direction it's facing
+                val direction = vehicle.location.direction.setY(0).normalize()
+                poweredMinecart.velocity = poweredMinecart.velocity.add(direction.multiply(0.5))
+
+                // Also boost the player's minecart if different
+                if (vehicle != poweredMinecart) {
+                    vehicle.velocity = vehicle.velocity.add(direction.multiply(0.5))
+                }
+
+                player.sendMessage("${ChatColor.GREEN}Minecart boosted!")
+            } else {
+                player.sendMessage("${ChatColor.RED}You must be in a minecart linked to a powered minecart to use this command.")
+            }
         } else {
-            player.sendMessage("${ChatColor.RED}You must be in a furnace minecart to use this command.")
+            player.sendMessage("${ChatColor.RED}You must be in a minecart to use this command.")
         }
     }
 
     private fun refuelMinecart(player: Player) {
         val vehicle = player.vehicle
 
-        if (vehicle is PoweredMinecart) {
+        if (vehicle is Minecart) {
-            vehicle.fuel = 3600 // Set to max fuel
+            // Get powered minecart if this is a linked regular minecart
-            player.sendMessage("${ChatColor.GREEN}Minecart refueled!")
+            val poweredMinecart = if (vehicle is PoweredMinecart) {
+                vehicle
+            } else if (vehicle.hasMetadata("fmpp_linked")) {
+                // Find linked powered minecart
+                vehicle.getNearbyEntities(5.0, 5.0, 5.0)
+                    .filterIsInstance<PoweredMinecart>()
+                    .firstOrNull { it.hasMetadata("fmpp_linked_to") &&
+                            it.getMetadata("fmpp_linked_to").firstOrNull()?.asString() == vehicle.uniqueId.toString() }
+            } else {
+                null
+            }
+
+            if (poweredMinecart != null) {
+                // Set fuel via metadata as backup
+                poweredMinecart.setMetadata("fmpp_fuel", FixedMetadataValue(plugin, 3600))
+
+                // Try setting fuel via reflection if possible
+                try {
+                    val fuelField = PoweredMinecart::class.java.getDeclaredField("fuel")
+                    fuelField.isAccessible = true
+                    fuelField.setInt(poweredMinecart, 3600)
+                } catch (e: Exception) {
+                    plugin.logger.warning("Could not set fuel field directly, using metadata instead.")
+                }
+
+                player.sendMessage("${ChatColor.GREEN}Powered minecart refueled!")
+            } else {
+                player.sendMessage("${ChatColor.RED}You must be in a minecart linked to a powered minecart to use this command.")
+            }
         } else {
-            player.sendMessage("${ChatColor.RED}You must be in a furnace minecart to use this command.")
+            player.sendMessage("${ChatColor.RED}You must be in a minecart to use this command.")
         }
     }
 
     private fun stopMinecart(player: Player) {
         val vehicle = player.vehicle
 
-        if (vehicle is PoweredMinecart) {
+        if (vehicle is Minecart) {
-            vehicle.velocity = vehicle.velocity.multiply(0.1)
+            // Get powered minecart if this is a linked regular minecart
-            player.sendMessage("${ChatColor.YELLOW}Minecart slowed down!")
+            val poweredMinecart = if (vehicle is PoweredMinecart) {
+                vehicle
+            } else if (vehicle.hasMetadata("fmpp_linked")) {
+                // Find linked powered minecart
+                vehicle.getNearbyEntities(5.0, 5.0, 5.0)
+                    .filterIsInstance<PoweredMinecart>()
+                    .firstOrNull { it.hasMetadata("fmpp_linked_to") &&
+                            it.getMetadata("fmpp_linked_to").firstOrNull()?.asString() == vehicle.uniqueId.toString() }
+            } else {
+                null
+            }
+
+            if (poweredMinecart != null) {
+                poweredMinecart.velocity = Vector(0, 0, 0)
+                vehicle.velocity = Vector(0, 0, 0)
+                player.sendMessage("${ChatColor.YELLOW}Minecarts stopped!")
+            } else {
+                player.sendMessage("${ChatColor.RED}You must be in a minecart linked to a powered minecart to use this command.")
+            }
         } else {
-            player.sendMessage("${ChatColor.RED}You must be in a furnace minecart to use this command.")
+            player.sendMessage("${ChatColor.RED}You must be in a minecart to use this command.")
+        }
+    }
+
+    private fun linkNearestMinecarts(player: Player) {
+        // Find the nearest regular minecart and powered minecart
+        val nearbyEntities = player.getNearbyEntities(5.0, 5.0, 5.0)
+        val regularMinecarts = nearbyEntities.filterIsInstance<Minecart>().filter { it !is PoweredMinecart }
+        val poweredMinecarts = nearbyEntities.filterIsInstance<PoweredMinecart>()
+
+        if (regularMinecarts.isEmpty()) {
+            player.sendMessage("${ChatColor.RED}No regular minecart found nearby.")
+            return
+        }
+
+        if (poweredMinecarts.isEmpty()) {
+            player.sendMessage("${ChatColor.RED}No powered minecart found nearby.")
+            return
+        }
+
+        // Get the closest minecarts
+        val closestRegular = regularMinecarts.minByOrNull { it.location.distanceSquared(player.location) }!!
+        val closestPowered = poweredMinecarts.minByOrNull { it.location.distanceSquared(player.location) }!!
+
+        // Check if the minecart is already linked
+        if (closestRegular.hasMetadata("fmpp_linked")) {
+            player.sendMessage("${ChatColor.RED}This regular minecart is already linked to a powered minecart.")
+            return
+        }
+
+        // Link the minecarts
+        linkMinecarts(closestRegular, closestPowered, player)
+    }
+
+    private fun unlinkMinecart(player: Player) {
+        val vehicle = player.vehicle
+
+        if (vehicle is Minecart && vehicle !is PoweredMinecart && vehicle.hasMetadata("fmpp_linked")) {
+            // Find linked powered minecart
+            val poweredMinecart = vehicle.getNearbyEntities(5.0, 5.0, 5.0)
+                .filterIsInstance<PoweredMinecart>()
+                .firstOrNull { it.hasMetadata("fmpp_linked_to") &&
+                        it.getMetadata("fmpp_linked_to").firstOrNull()?.asString() == vehicle.uniqueId.toString() }
+
+            if (poweredMinecart != null) {
+                // Unlink
+                vehicle.removeMetadata("fmpp_linked", plugin)
+                poweredMinecart.removeMetadata("fmpp_linked_to", plugin)
+
+                player.sendMessage("${ChatColor.GREEN}Successfully unlinked from powered minecart!")
+
+                // Give player a lead
+                if (player.gameMode.name != "CREATIVE") {
+                    player.inventory.addItem(ItemStack(Material.LEAD, 1))
+                }
+            } else {
+                player.sendMessage("${ChatColor.RED}Could not find the linked powered minecart nearby.")
+            }
+        } else {
+            player.sendMessage("${ChatColor.RED}You must be riding a linked regular minecart to unlink it.")
+        }
+    }
+
+    private fun linkMinecarts(minecart: Minecart, poweredMinecart: PoweredMinecart, player: Player) {
+        // Store the link using metadata
+        minecart.setMetadata("fmpp_linked", FixedMetadataValue(plugin, true))
+        poweredMinecart.setMetadata("fmpp_linked_to", FixedMetadataValue(plugin, minecart.uniqueId.toString()))
+
+        // Ensure the powered minecart is enhanced
+        poweredMinecart.maxSpeed = 0.6
+        poweredMinecart.setMetadata("fmpp_fuel", FixedMetadataValue(plugin, 3600))
+
+        // Try setting fuel via reflection if possible
+        try {
+            val fuelField = PoweredMinecart::class.java.getDeclaredField("fuel")
+            fuelField.isAccessible = true
+            fuelField.setInt(poweredMinecart, 3600)
+        } catch (e: Exception) {
+            plugin.logger.warning("Could not set fuel field directly, using metadata instead.")
+        }
+
+        player.sendMessage("${ChatColor.GREEN}Successfully linked minecart to powered minecart!")
+
+        // Take a lead from the player if they have one and not in creative mode
+        if (player.gameMode.name != "CREATIVE") {
+            val inventory = player.inventory
+            val leadIndex = inventory.first(Material.LEAD)
+
+            if (leadIndex != -1) {
+                val leadItem = inventory.getItem(leadIndex)
+                if (leadItem != null && leadItem.amount > 1) {
+                    leadItem.amount = leadItem.amount - 1
+                } else {
+                    inventory.clear(leadIndex)
+                }
+            } else {
+                player.sendMessage("${ChatColor.YELLOW}You don't have a lead item, but the minecarts were linked anyway.")
+            }
         }
     }
 
     private fun showHelp(player: Player) {
         player.sendMessage("${ChatColor.GOLD}===== FurnaceMinecart++ Commands =====")
-        player.sendMessage("${ChatColor.YELLOW}/fmpp boost ${ChatColor.WHITE}- Gives your minecart a speed boost")
+        player.sendMessage("${ChatColor.YELLOW}/fmpp boost ${ChatColor.WHITE}- Gives your linked minecarts a speed boost")
-        player.sendMessage("${ChatColor.YELLOW}/fmpp fuel ${ChatColor.WHITE}- Refills your minecart's fuel")
+        player.sendMessage("${ChatColor.YELLOW}/fmpp fuel ${ChatColor.WHITE}- Refills your powered minecart's fuel")
-        player.sendMessage("${ChatColor.YELLOW}/fmpp stop ${ChatColor.WHITE}- Slows down your minecart")
+        player.sendMessage("${ChatColor.YELLOW}/fmpp stop ${ChatColor.WHITE}- Slows down your linked minecarts")
+        player.sendMessage("${ChatColor.YELLOW}/fmpp link ${ChatColor.WHITE}- Links the nearest regular and powered minecarts")
+        player.sendMessage("${ChatColor.YELLOW}/fmpp unlink ${ChatColor.WHITE}- Unlinks your minecart from its powered minecart")
         player.sendMessage("${ChatColor.YELLOW}/fmpp help ${ChatColor.WHITE}- Shows this help message")
         player.sendMessage("${ChatColor.GOLD}==================================")
     }

src/main/kotlin/org/fmpp/fmpp/Fmpp.kt

@@ -2,7 +2,6 @@ package org.fmpp.fmpp
 
 import org.bukkit.ChatColor
 import org.bukkit.Material
-import org.bukkit.entity.EntityType
 import org.bukkit.entity.Minecart
 import org.bukkit.entity.Player
 import org.bukkit.entity.minecart.PoweredMinecart
@@ -14,6 +13,10 @@ import org.bukkit.event.vehicle.VehicleMoveEvent
 import org.bukkit.plugin.java.JavaPlugin
 import org.bukkit.util.Vector
 import kotlin.math.abs
+import org.bukkit.entity.Entity
+import org.bukkit.event.player.PlayerInteractEntityEvent
+import org.bukkit.inventory.ItemStack
+import org.bukkit.metadata.FixedMetadataValue
 
 class Fmpp : JavaPlugin() {
 
@@ -31,15 +34,78 @@ class Fmpp : JavaPlugin() {
 
     class FMPPListener(private val plugin: Fmpp) : Listener {
 
-        // Track enhanced minecarts
+        // Used to track linked minecarts
-        private val enhancedMinecarts = mutableSetOf<PoweredMinecart>()
+        private val linkedMinecarts = HashMap<Minecart, PoweredMinecart>()
+        private val enhancedPoweredMinecarts = mutableSetOf<PoweredMinecart>()
 
         @EventHandler
         fun onVehicleCreate(event: VehicleCreateEvent) {
             val vehicle = event.vehicle
             if (vehicle is PoweredMinecart) {
-                enhanceMinecart(vehicle)
+                enhancePoweredMinecart(vehicle)
-                plugin.logger.info("Enhanced a new furnace minecart!")
+                plugin.logger.info("Enhanced a new powered minecart!")
+            }
+        }
+
+        @EventHandler
+        fun onPlayerInteractEntity(event: PlayerInteractEntityEvent) {
+            val player = event.player
+            val entity = event.rightClicked
+
+            // Check if player right-clicked a powered minecart while holding a lead
+            if (entity is PoweredMinecart && player.inventory.itemInMainHand.type == Material.LEAD) {
+                // Find the nearest regular minecart within 3 blocks
+                val nearbyMinecarts = entity.getNearbyEntities(3.0, 3.0, 3.0)
+                    .filterIsInstance<Minecart>()
+                    .filter { it !is PoweredMinecart }
+
+                if (nearbyMinecarts.isNotEmpty()) {
+                    val nearestMinecart = nearbyMinecarts.minByOrNull {
+                        it.location.distanceSquared(entity.location)
+                    }
+
+                    if (nearestMinecart != null) {
+                        // Link the minecarts
+                        linkMinecarts(nearestMinecart, entity)
+
+                        // Take one lead item from the player
+                        if (player.gameMode.name != "CREATIVE") {
+                            val leadItem = player.inventory.itemInMainHand
+                            if (leadItem.amount > 1) {
+                                leadItem.amount = leadItem.amount - 1
+                            } else {
+                                player.inventory.setItemInMainHand(null)
+                            }
+                        }
+
+                        player.sendMessage("${ChatColor.GREEN}Successfully linked minecart to powered minecart!")
+                        event.isCancelled = true
+                    } else {
+                        player.sendMessage("${ChatColor.RED}No regular minecart found nearby to link.")
+                    }
+                } else {
+                    player.sendMessage("${ChatColor.RED}No regular minecart found nearby to link.")
+                }
+            }
+
+            // Check if player right-clicked a minecart that is linked to a powered minecart
+            if (entity is Minecart && entity !is PoweredMinecart && linkedMinecarts.containsKey(entity)) {
+                if (player.inventory.itemInMainHand.type == Material.SHEARS) {
+                    // Unlink the minecarts
+                    val poweredMinecart = linkedMinecarts[entity]
+                    unlinkMinecarts(entity)
+
+                    player.sendMessage("${ChatColor.YELLOW}Unlinked minecart from powered minecart.")
+                    event.isCancelled = true
+
+                    // Give the player a lead
+                    if (player.gameMode.name != "CREATIVE") {
+                        player.inventory.addItem(ItemStack(Material.LEAD, 1))
+                    }
+                } else {
+                    player.sendMessage("${ChatColor.GOLD}This minecart is linked to a powered minecart.")
+                    player.sendMessage("${ChatColor.GOLD}Use shears to unlink them.")
+                }
             }
         }
 
@@ -48,12 +114,23 @@ class Fmpp : JavaPlugin() {
             val vehicle = event.vehicle
             val entity = event.entered
 
-            if (vehicle is PoweredMinecart && entity is Player) {
+            if (entity is Player) {
-                entity.sendMessage("${ChatColor.GOLD}This is an enhanced FurnaceMinecart++!")
+                if (vehicle is Minecart && vehicle !is PoweredMinecart) {
-                entity.sendMessage("${ChatColor.YELLOW}Use WASD to control direction and speed.")
+                    // Check if this minecart is linked to a powered minecart
+                    val poweredMinecart = linkedMinecarts[vehicle]
 
-                if (!enhancedMinecarts.contains(vehicle)) {
+                    if (poweredMinecart != null) {
-                    enhanceMinecart(vehicle)
+                        entity.sendMessage("${ChatColor.GOLD}This minecart is linked to an enhanced powered minecart!")
+                        entity.sendMessage("${ChatColor.YELLOW}Use WASD to control movement.")
+                    }
+                } else if (vehicle is PoweredMinecart) {
+                    // Player is somehow riding a powered minecart (maybe another plugin allows this)
+                    entity.sendMessage("${ChatColor.GOLD}This is an enhanced powered minecart!")
+                    entity.sendMessage("${ChatColor.YELLOW}You typically cannot ride these directly.")
+
+                    if (!enhancedPoweredMinecarts.contains(vehicle)) {
+                        enhancePoweredMinecart(vehicle)
+                    }
                 }
             }
         }
@@ -62,25 +139,56 @@ class Fmpp : JavaPlugin() {
         fun onVehicleMove(event: VehicleMoveEvent) {
             val vehicle = event.vehicle
 
-            if (vehicle is PoweredMinecart && enhancedMinecarts.contains(vehicle)) {
+            // If this is a regular minecart linked to a powered minecart
-                val passenger = vehicle.passengers.firstOrNull()
+            if (vehicle is Minecart && vehicle !is PoweredMinecart && linkedMinecarts.containsKey(vehicle)) {
+                val poweredMinecart = linkedMinecarts[vehicle]
 
-                if (passenger is Player) {
+                if (poweredMinecart != null && !poweredMinecart.isDead) {
-                    handlePlayerControl(vehicle, passenger)
+                    // Check if the powered minecart is too far away
+                    if (vehicle.location.distanceSquared(poweredMinecart.location) > 25.0) { // 5 blocks squared
+                        // Pull the powered minecart closer
+                        val direction = vehicle.location.toVector().subtract(poweredMinecart.location.toVector()).normalize()
+                        poweredMinecart.velocity = direction.multiply(vehicle.velocity.length() * 1.1)
+                    }
+
+                    // Check if player is riding the minecart
+                    val passenger = vehicle.passengers.firstOrNull()
+                    if (passenger is Player) {
+                        handlePlayerControl(vehicle, poweredMinecart, passenger)
+                    }
                 } else {
-                    // Maintain momentum for empty carts
+                    // Powered minecart is gone, unlink
-                    if (vehicle.velocity.lengthSquared() > 0.01) {
+                    unlinkMinecarts(vehicle)
-                        // Reduce slowdown factor
+                }
-                        val currentVelocity = vehicle.velocity
+            }
-                        if (currentVelocity.lengthSquared() > 0.01) {
+
-                            vehicle.velocity = currentVelocity.multiply(0.99)
+            // Enhanced behavior for powered minecarts (even when not linked)
-                        }
+            if (vehicle is PoweredMinecart && enhancedPoweredMinecarts.contains(vehicle)) {
+                // Improved momentum maintenance
+                if (vehicle.velocity.lengthSquared() > 0.01) {
+                    // Reduce slowdown factor
+                    val currentVelocity = vehicle.velocity
+                    vehicle.velocity = currentVelocity.multiply(0.99)
+                }
+
+                // Set fuel to keep it running
+                try {
+                    // Using reflection to access the fuel field if available
+                    val fuelField = PoweredMinecart::class.java.getDeclaredField("fuel")
+                    fuelField.isAccessible = true
+                    if ((fuelField.getInt(vehicle)) < 100) {
+                        fuelField.setInt(vehicle, 3600)
+                    }
+                } catch (e: Exception) {
+                    // Fallback if reflection doesn't work - store fuel in metadata
+                    if (!vehicle.hasMetadata("fmpp_fuel") || vehicle.getMetadata("fmpp_fuel").firstOrNull()?.asInt() ?: 0 < 100) {
+                        vehicle.setMetadata("fmpp_fuel", FixedMetadataValue(plugin, 3600))
                     }
                 }
             }
         }
 
-        private fun handlePlayerControl(minecart: PoweredMinecart, player: Player) {
+        private fun handlePlayerControl(minecart: Minecart, poweredMinecart: PoweredMinecart, player: Player) {
             // Get player's looking direction as a reference
             val direction = player.location.direction.setY(0).normalize()
             val rightVector = Vector(-direction.z, 0.0, direction.x).normalize()
@@ -91,7 +199,8 @@ class Fmpp : JavaPlugin() {
             // Forward/backward
             if (player.isSneaking) {
                 // Brake
-                minecart.velocity = minecart.velocity.multiply(0.9)
+                poweredMinecart.velocity = poweredMinecart.velocity.multiply(0.8)
+                minecart.velocity = minecart.velocity.multiply(0.8)
                 return
             } else {
                 // Check if player is pressing movement keys
@@ -121,49 +230,95 @@ class Fmpp : JavaPlugin() {
 
             // Only change velocity if we have input
             if (velocity.lengthSquared() > 0.001) {
-                // Set new velocity, preserving some of the existing momentum
+                // Set new velocity for powered minecart, preserving some of the existing momentum
-                val currentVel = minecart.velocity
+                val currentVel = poweredMinecart.velocity
-                minecart.velocity = currentVel.multiply(0.8).add(velocity)
+                poweredMinecart.velocity = currentVel.multiply(0.8).add(velocity)
+
+                // Also adjust the player's minecart velocity to match
+                minecart.velocity = minecart.velocity.multiply(0.8).add(velocity)
 
                 // Set fuel level to ensure minecart stays active
-                minecart.fuel = 3600 // Max fuel
+                try {
+                    // Try using reflection to set fuel
+                    val fuelField = PoweredMinecart::class.java.getDeclaredField("fuel")
+                    fuelField.isAccessible = true
+                    fuelField.setInt(poweredMinecart, 3600)
+                } catch (e: Exception) {
+                    // Fallback to metadata
+                    poweredMinecart.setMetadata("fmpp_fuel", FixedMetadataValue(plugin, 3600))
+                }
             }
         }
 
-        private fun enhanceMinecart(minecart: PoweredMinecart) {
+        private fun enhancePoweredMinecart(minecart: PoweredMinecart) {
             // Increase base speed
             minecart.maxSpeed = 0.6 // Default is 0.4
 
             // Add to tracked minecarts
-            enhancedMinecarts.add(minecart)
+            enhancedPoweredMinecarts.add(minecart)
 
-            // Set initial fuel
+            // Set initial fuel via metadata as backup
-            minecart.fuel = 3600
+            minecart.setMetadata("fmpp_fuel", FixedMetadataValue(plugin, 3600))
+
+            // Try setting fuel via reflection if possible
+            try {
+                val fuelField = PoweredMinecart::class.java.getDeclaredField("fuel")
+                fuelField.isAccessible = true
+                fuelField.setInt(minecart, 3600)
+            } catch (e: Exception) {
+                plugin.logger.warning("Could not set fuel field directly, using metadata instead.")
+            }
+        }
+
+        private fun linkMinecarts(minecart: Minecart, poweredMinecart: PoweredMinecart) {
+            // Store the link
+            linkedMinecarts[minecart] = poweredMinecart
+
+            // Add metadata to both minecarts to remember the link
+            minecart.setMetadata("fmpp_linked", FixedMetadataValue(plugin, true))
+            poweredMinecart.setMetadata("fmpp_linked_to", FixedMetadataValue(plugin, minecart.uniqueId.toString()))
+
+            // Ensure the powered minecart is enhanced
+            if (!enhancedPoweredMinecarts.contains(poweredMinecart)) {
+                enhancePoweredMinecart(poweredMinecart)
+            }
+
+            // Visually connect them with a leash effect if possible
+            // This would typically require a custom implementation with armorstands or similar
+        }
+
+        private fun unlinkMinecarts(minecart: Minecart) {
+            // Remove from the linked minecarts map
+            val poweredMinecart = linkedMinecarts.remove(minecart)
+
+            // Remove metadata
+            minecart.removeMetadata("fmpp_linked", plugin)
+            poweredMinecart?.removeMetadata("fmpp_linked_to", plugin)
         }
 
         // Helper methods to detect player movement
         private fun isMovingForward(player: Player): Boolean {
             return player.velocity.length() > 0.01 &&
-                   abs(player.location.direction.dot(player.velocity.clone().setY(0).normalize())) > 0.7
+                    abs(player.location.direction.dot(player.velocity.clone().setY(0).normalize())) > 0.7
         }
 
         private fun isMovingBackward(player: Player): Boolean {
             return player.velocity.length() > 0.01 &&
-                   player.location.direction.dot(player.velocity.clone().setY(0).normalize()) < -0.7
+                    player.location.direction.dot(player.velocity.clone().setY(0).normalize()) < -0.7
         }
 
         private fun isMovingLeft(player: Player): Boolean {
             val direction = player.location.direction.setY(0).normalize()
             val rightVector = Vector(-direction.z, 0.0, direction.x).normalize()
             return player.velocity.length() > 0.01 &&
-                   rightVector.dot(player.velocity.clone().setY(0).normalize()) < -0.7
+                    rightVector.dot(player.velocity.clone().setY(0).normalize()) < -0.7
         }
 
         private fun isMovingRight(player: Player): Boolean {
             val direction = player.location.direction.setY(0).normalize()
             val rightVector = Vector(-direction.z, 0.0, direction.x).normalize()
             return player.velocity.length() > 0.01 &&
-                   rightVector.dot(player.velocity.clone().setY(0).normalize()) > 0.7
+                    rightVector.dot(player.velocity.clone().setY(0).normalize()) > 0.7
         }
     }
 }

src/main/resources/plugin.yml

@@ -2,14 +2,12 @@ name: FurnaceMinecartPP
 version: 1.0-SNAPSHOT
 main: org.fmpp.fmpp.Fmpp
 api-version: 1.21
-description: Enhances Furnace Minecart functionality with better control and performance
+description: Enhances Powered Minecart functionality with better control and performance
-author: YourName
+author: rattatwinko
-website: https://example.com
-
 commands:
   fmpp:
-    description: Control your enhanced Furnace Minecart
+    description: Control your enhanced Powered Minecart
-    usage: /fmpp [boost|fuel|stop|help]
+    usage: /fmpp [boost|fuel|stop|link|unlink|help]
     permission: fmpp.use
 
 permissions: