Haruhi Osako

In Minecraft PvP, when I attack, I'd like you to display the distance between me and my opponent—in meters or something. I want to know the PvP range, so please put that information on the right side. version 1.21.11

Kodari AI
KodariAug 31 at 10:22 am 1
PvPDistanceDisplay
Displays the real-time distance between a player and their opponent during PvP combat on the right side of the screen. When a player attacks another entity, an action bar message shows the distance in meters, updating continuously while combat persists. Supports configurable distance formatting, toggle commands, and optional boss bar display for enhanced readability. Built for Minecraft 1.21.11 with Paper API, ensuring lightweight performance and seamless integration with existing PvP gameplay.
  1. Create the Gradle project and plugin metadata for Paper 1.21.x.

  2. Add the PvP hit listener and a sidebar updater that tracks the opponent’s live distance in meters.

Created the Paper 1.21.11 PvP range plugin.

  • Displays a sidebar on the right after attacking a player.

  • Shows the target’s name and distance in meters.

  • Updates every tick for accurate live distance.

  • Supports melee attacks and player-fired projectiles.

  • Sidebar disappears after 10 seconds, when the target leaves, or when players enter different worlds.

  • Restores the player’s previous scoreboard afterward.

Kodari can make mistakes. Review important code before using.
Files
src
build.gradle
settings.gradle
Code
5 193
src/main/java/com/kodari/pvprange/PvPRangePlugin.java
package com.kodari.pvprange;

import net.kyori.adventure.text.Component;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.scoreboard.Criteria;
import org.bukkit.scoreboard.DisplaySlot;
import org.bukkit.scoreboard.Objective;
import org.bukkit.scoreboard.Scoreboard;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.UUID;

public final class PvPRangePlugin extends JavaPlugin {
    private static final long DISPLAY_DURATION_MILLIS = 10_000L;

    private final Map<UUID, UUID> targets = new HashMap<>();
    private final Map<UUID, Long> expiryTimes = new HashMap<>();
    private final Map<UUID, Scoreboard> rangeScoreboards = new HashMap<>();
    private final Map<UUID, Scoreboard> previousScoreboards = new HashMap<>();
    private final Map<UUID, Set<String>> displayedLines = new HashMap<>();

    @Override
    public void onEnable() {
        getServer().getPluginManager().registerEvents(new PvPRangeListener(this), this);
        getServer().getScheduler().runTaskTimer(this, this::updateDisplays, 1L, 1L);
    }

    @Override
    public void onDisable() {
        for (UUID playerId : new HashSet<>(rangeScoreboards.keySet())) {
            hideDisplay(playerId);
        }
        targets.clear();
        expiryTimes.clear();
    }

    public void recordHit(Player attacker, Player target) {
        UUID attackerId = attacker.getUniqueId();
        targets.put(attackerId, target.getUniqueId());
        expiryTimes.put(attackerId, System.currentTimeMillis() + DISPLAY_DURATION_MILLIS);
        updateDisplay(attacker, target);
    }

    private void updateDisplays() {
        long now = System.currentTimeMillis();
        Iterator<Map.Entry<UUID, UUID>> iterator = targets.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<UUID, UUID> entry = iterator.next();
            UUID attackerId = entry.getKey();
            Player attacker = Bukkit.getPlayer(attackerId);
            Player target = Bukkit.getPlayer(entry.getValue());

            if (now >= expiryTimes.getOrDefault(attackerId, 0L)
                    || attacker == null
                    || !attacker.isOnline()
                    || target == null
                    || !target.isOnline()
                    || attacker.getWorld() != target.getWorld()) {
                iterator.remove();
                expiryTimes.remove(attackerId);
                hideDisplay(attackerId);
                continue;
            }

            updateDisplay(attacker, target);
        }
    }

    private void updateDisplay(Player attacker, Player target) {
        UUID playerId = attacker.getUniqueId();
        Scoreboard scoreboard = rangeScoreboards.get(playerId);
        if (scoreboard == null) {
            scoreboard = Bukkit.getScoreboardManager().getNewScoreboard();
            Objective objective = scoreboard.registerNewObjective(
                    "pvprange", Criteria.DUMMY, Component.text("§bPvP Range"));
            objective.setDisplaySlot(DisplaySlot.SIDEBAR);
            previousScoreboards.put(playerId, attacker.getScoreboard());
            rangeScoreboards.put(playerId, scoreboard);
            displayedLines.put(playerId, new HashSet<>());
            attacker.setScoreboard(scoreboard);
        }

        Set<String> oldLines = displayedLines.get(playerId);
        for (String oldLine : oldLines) {
            scoreboard.resetScores(oldLine);
        }

        String targetLine = "§fTarget: §e" + target.getName();
        String distanceLine = String.format(
                Locale.ROOT, "§fDistance: §b%.2f m", attacker.getLocation().distance(target.getLocation()));
        Objective objective = scoreboard.getObjective("pvprange");
        objective.getScore(targetLine).setScore(2);
        objective.getScore(distanceLine).setScore(1);
        oldLines.clear();
        oldLines.add(targetLine);
        oldLines.add(distanceLine);
    }

    private void hideDisplay(UUID playerId) {
        Scoreboard rangeScoreboard = rangeScoreboards.remove(playerId);
        Scoreboard previousScoreboard = previousScoreboards.remove(playerId);
        displayedLines.remove(playerId);
        Player player = Bukkit.getPlayer(playerId);

        if (player != null && rangeScoreboard != null && player.getScoreboard() == rangeScoreboard) {
            player.setScoreboard(previousScoreboard);
        }
    }
}