merge impl under PaperTrackableStats and update scoreboard for offline players

Author: Lulu13022002

paper-server/patches/sources/net/minecraft/stats/ServerStatsCounter.java.patch

@@ -42,12 +42,12 @@
 +                player.getBukkitEntity(),
 +                map.object2IntEntrySet()
 +                    .stream()
-+                    .collect(Object2IntOpenHashMap::new, (map1, entry) -> map1.put(io.papermc.paper.statistic.PaperStatistics.getPaperStatistic(entry.getKey()), entry.getIntValue()), Object2IntOpenHashMap::putAll)
++                    .collect(Object2IntOpenHashMap::new, (map1, entry) -> map1.put(io.papermc.paper.statistic.PaperStatistic.getPaperStatistic(entry.getKey()), entry.getIntValue()), Object2IntOpenHashMap::putAll)
 +            );
 +            if (!statEvent.callEvent()) {
 +                return;
 +            }
-+            map = statEvent.getStatisticMap().object2IntEntrySet().stream().collect(Object2IntOpenHashMap::new, (map1, entry) -> map1.put(io.papermc.paper.statistic.PaperStatistics.getNMSStatistic(entry.getKey()), entry.getIntValue()), Object2IntOpenHashMap::putAll);
++            map = statEvent.getStatisticMap().object2IntEntrySet().stream().collect(Object2IntOpenHashMap::new, (map1, entry) -> map1.put(io.papermc.paper.statistic.PaperStatistic.getNMSStatistic(entry.getKey()), entry.getIntValue()), Object2IntOpenHashMap::putAll);
 +        }
 +        // Paper end
 

paper-server/patches/sources/net/minecraft/stats/StatsCounter.java.patch

@@ -5,7 +5,7 @@
      public void increment(Player player, Stat<?> stat, int amount) {
          int i = (int)Math.min((long)this.getValue(stat) + amount, 2147483647L);
 +        // CraftBukkit start - fire Statistic events
-+        if (!org.bukkit.craftbukkit.event.CraftEventFactory.callStatisticIncreaseEvent(player, stat, this.getValue(stat), i)) {
++        if (!org.bukkit.craftbukkit.event.CraftEventFactory.callStatisticIncrementEvent(player, stat, this.getValue(stat), i)) {
 +            return;
 +        }
 +        // CraftBukkit end

paper-server/src/main/java/io/papermc/paper/statistic/PaperStatistic.java

@@ -4,11 +4,11 @@
 import org.bukkit.craftbukkit.scoreboard.CraftScoreboardTranslations;
 import org.bukkit.scoreboard.RenderType;
 
-public record PaperStatistic<S, M>(Stat<M> handle, S owner, M nmsValue, StatisticType<S> type) implements Statistic<S> {
+public record PaperStatistic<S, M>(Stat<M> handle, S owner, StatisticType<S> type) implements Statistic<S> {
 
     @Override
     public String getName() {
-        return Stat.buildName(this.handle.getType(), this.nmsValue);
+        return this.handle.getName();
     }
 
     @Override
@@ -20,4 +20,12 @@ public boolean isReadOnly() {
     public RenderType getDefaultRenderType() {
         return CraftScoreboardTranslations.toBukkitRender(this.handle.getDefaultRenderType());
     }
+
+    public static <M> Statistic<?> getPaperStatistic(final Stat<M> stat) {
+        return PaperStatisticType.minecraftToBukkit(stat.getType()).convertStat(stat);
+    }
+
+    public static Stat<?> getNMSStatistic(final Statistic<?> statistic) {
+        return ((PaperStatistic<?, ?>) statistic).handle();
+    }
 }

paper-server/src/main/java/io/papermc/paper/statistic/PaperStatisticType.java

@@ -32,7 +32,7 @@ public class PaperStatisticType<S extends Keyed, M> extends HolderableBase<StatT
     private final BiFunction<M, ResourceKey<? extends Registry<M>>, S> minecraftToBukkit;
 
     private PaperStatisticType(final Holder<StatType<M>> holder) {
-        this(holder, s -> true, CraftRegistry::bukkitToMinecraft, CraftRegistry::minecraftToBukkit);
+        this(holder, $ -> true, CraftRegistry::bukkitToMinecraft, CraftRegistry::minecraftToBukkit);
     }
 
     private PaperStatisticType(final Holder<StatType<M>> holder, final Predicate<S> typeCheck, final Function<S, M> bukkitToMinecraft, final BiFunction<M, ResourceKey<? extends Registry<M>>, S> minecraftToBukkit) {
@@ -52,7 +52,7 @@ public static <M> StatisticType<?> create(final Holder<?> holder) {
                 (Holder<StatType<net.minecraft.world.entity.EntityType<?>>>) holder,
                 t -> t != EntityType.UNKNOWN,
                 CraftEntityType::bukkitToMinecraft,
-                (entityType, ignored) -> CraftEntityType.minecraftToBukkit(entityType)
+                (entityType, $) -> CraftEntityType.minecraftToBukkit(entityType)
             );
         } else {
             return new PaperStatisticType<>((Holder<StatType<M>>) holder);
@@ -67,22 +67,20 @@ public static <S, M> StatType<M> bukkitToMinecraft(final StatisticType<S> bukkit
         return CraftRegistry.bukkitToMinecraft(bukkit);
     }
 
-    public Statistic<S> convertStat(final Stat<? extends M> nmsStat) {
-        return this.forValue(this.minecraftToBukkit.apply(nmsStat.getValue(), this.getHandle().getRegistry().key()));
+    public Statistic<S> convertStat(final Stat<M> stat) {
+        return this.forValue(this.minecraftToBukkit.apply(stat.getValue(), this.getHandle().getRegistry().key()));
     }
 
     @Override
     public Statistic<S> forValue(final S value) {
         if (!this.typeCheck.test(value)) {
             throw new IllegalArgumentException(value + " is not valid for stat type " + this.getKey());
         }
-        return this.statCacheMap.computeIfAbsent(
-            value, newValue -> {
-                final M nmsValue = this.bukkitToMinecraft.apply(newValue);
-                final Stat<M> nmsStat = this.getHandle().get(nmsValue);
-                return new PaperStatistic<>(nmsStat, newValue, nmsValue, this);
-            }
-        );
+        return this.statCacheMap.computeIfAbsent(value, newValue -> {
+            final M nmsValue = this.bukkitToMinecraft.apply(newValue);
+            final Stat<M> stat = this.getHandle().get(nmsValue);
+            return new PaperStatistic<>(stat, newValue, this);
+        });
     }
 
     @Override

paper-server/src/main/java/io/papermc/paper/statistic/PaperStatistics.java

@@ -0,0 +1,88 @@
+package io.papermc.paper.statistic;
+
+import com.google.common.base.Preconditions;
+import java.util.function.IntUnaryOperator;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.stats.ServerStatsCounter;
+import net.minecraft.stats.Stat;
+import net.minecraft.world.scores.ScoreHolder;
+import org.bukkit.Bukkit;
+import org.bukkit.craftbukkit.scoreboard.CraftScoreboardManager;
+import org.jspecify.annotations.Nullable;
+
+public interface PaperTrackableStats {
+
+    ServerStatsCounter getStatCounter();
+
+    @Nullable ScoreHolder getScoreHolder();
+
+    private ServerStatsCounter getUsableCounter() {
+        return this.getUsableCounter(this.getScoreHolder());
+    }
+
+    private ServerStatsCounter getUsableCounter(final @Nullable ScoreHolder from) {
+        return from instanceof ServerPlayer player ? player.getStats() : this.getStatCounter();
+    }
+
+    default void decrementStatistic(final Statistic<?> statistic, final int amount) {
+        Preconditions.checkArgument(statistic != null, "Statistic cannot be null");
+        Preconditions.checkArgument(amount > 0, "Amount must be greater than 0");
+
+        this.updateStatistic(PaperStatistic.getNMSStatistic(statistic), originalAmount -> {
+            final int newAmount = originalAmount - amount;
+            Preconditions.checkArgument(newAmount >= 0, "New amount must be greater than or equal to 0");
+            return newAmount;
+        });
+    }
+
+    default void incrementStatistic(final Statistic<?> statistic, final int amount) {
+        Preconditions.checkArgument(statistic != null, "Statistic cannot be null");
+        Preconditions.checkArgument(amount > 0, "Amount must be greater than 0");
+
+        this.updateStatistic(PaperStatistic.getNMSStatistic(statistic), originalAmount -> (int) Math.min((long) originalAmount + amount, Integer.MAX_VALUE)); // clamp from StatsCounter
+    }
+
+    default void setStatistic(final Statistic<?> statistic, final int newAmount) {
+        Preconditions.checkArgument(statistic != null, "Statistic cannot be null");
+        Preconditions.checkArgument(newAmount >= 0, "New amount must be greater than or equal to 0");
+
+        this.setStatistic(PaperStatistic.getNMSStatistic(statistic), newAmount);
+    }
+
+    private void updateStatistic(final Stat<?> stat, final IntUnaryOperator operation) {
+        final ScoreHolder holder = this.getScoreHolder();
+        final ServerStatsCounter counter = this.getUsableCounter(holder);
+        final int newAmount = operation.applyAsInt(counter.getValue(stat));
+        setStatistic(counter, stat, newAmount, holder);
+    }
+
+    private void setStatistic(final Stat<?> stat, final int newAmount) {
+        final ScoreHolder holder = this.getScoreHolder();
+        setStatistic(this.getUsableCounter(holder), stat, newAmount, holder);
+    }
+
+    @SuppressWarnings("ConstantConditions")
+    private static void setStatistic(final ServerStatsCounter counter, final Stat<?> stat, final int newAmount, final @Nullable ScoreHolder holder) {
+        final ServerPlayer player = holder instanceof ServerPlayer p ? p : null;
+        counter.setValue(player, stat, newAmount);
+        if (holder != null) {
+            ((CraftScoreboardManager) Bukkit.getScoreboardManager()).forAllObjectives(stat, holder, score -> {
+                score.set(newAmount);
+            });
+        }
+        if (player == null) { // offline
+            counter.save();
+        }
+    }
+
+    default int getStatistic(final Statistic<?> statistic) {
+        Preconditions.checkArgument(statistic != null, "Statistic cannot be null");
+        return this.getUsableCounter().getValue(PaperStatistic.getNMSStatistic(statistic));
+    }
+
+    default String getFormattedValue(final Statistic<?> statistic) {
+        Preconditions.checkArgument(statistic != null, "Statistic cannot be null");
+        final Stat<?> stat = PaperStatistic.getNMSStatistic(statistic);
+        return stat.format(this.getUsableCounter().getValue(stat));
+    }
+}