LeavesMC/patches/server/0055-Bedrock-break-list.patch

From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: MC_XiaoHei <xiaohei.xor7studio@foxmail.com>
Date: Wed, 8 May 2024 22:19:25 +0800
Subject: [PATCH] Bedrock break list


diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
index aa7f001a3f75f7981e8aa27d24041d9a2e0493db..658ac73c319683cf8d74d4af8e2a3fca418bd71c 100644
--- a/src/main/java/net/minecraft/server/MinecraftServer.java
+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
@@ -1793,6 +1793,8 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
 
         org.leavesmc.leaves.protocol.core.LeavesProtocolManager.handleTick(); // Leaves - protocol
 
+        org.leavesmc.leaves.util.BreakBedrockList.endTick(); // Leaves - break bedrock list
+
         for (int i = 0; i < this.tickables.size(); ++i) {
             ((Runnable) this.tickables.get(i)).run();
         }
diff --git a/src/main/java/net/minecraft/server/ServerScoreboard.java b/src/main/java/net/minecraft/server/ServerScoreboard.java
index f180001493146ef0d54079a8b2b47ad7decc24ca..fa63d9d13505794742721ca5fa673ff25acde463 100644
--- a/src/main/java/net/minecraft/server/ServerScoreboard.java
+++ b/src/main/java/net/minecraft/server/ServerScoreboard.java
@@ -146,6 +146,7 @@ public class ServerScoreboard extends Scoreboard {
     @Override
     public void onObjectiveAdded(Objective objective) {
         super.onObjectiveAdded(objective);
+        org.leavesmc.leaves.util.BreakBedrockList.onScoreboardAdd(objective); // Leaves - break bedrock list
         this.setDirty();
     }
 
@@ -162,6 +163,7 @@ public class ServerScoreboard extends Scoreboard {
     @Override
     public void onObjectiveRemoved(Objective objective) {
         super.onObjectiveRemoved(objective);
+        org.leavesmc.leaves.util.BreakBedrockList.onScoreboardRemove(objective); // Leaves - break bedrock list
         if (this.trackedObjectives.contains(objective)) {
             this.stopTrackingObjective(objective);
         }
diff --git a/src/main/java/net/minecraft/world/level/block/piston/PistonBaseBlock.java b/src/main/java/net/minecraft/world/level/block/piston/PistonBaseBlock.java
index e0c62227b279a5fe0f3868fbf9ce8c78c515a09c..933d7a7fcf2520fc81d465bc346e461e1ab9b74e 100644
--- a/src/main/java/net/minecraft/world/level/block/piston/PistonBaseBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/piston/PistonBaseBlock.java
@@ -106,6 +106,11 @@ public class PistonBaseBlock extends DirectionalBlock {
     @Override
     public void setPlacedBy(Level world, BlockPos pos, BlockState state, LivingEntity placer, ItemStack itemStack) {
         if (!world.isClientSide) {
+            // Leaves start - break bedrock list
+            if (placer instanceof Player player) {
+                org.leavesmc.leaves.util.BreakBedrockList.onPlayerPlacePiston(world, player, pos);
+            }
+            // Leaves end - break bedrock list
             this.checkIfExtend(world, pos, state);
         }
 
@@ -291,13 +296,24 @@ public class PistonBaseBlock extends DirectionalBlock {
                             }
                         }
                         // Paper end - Fix sticky pistons and BlockPistonRetractEvent
-                        world.removeBlock(pos.relative(enumdirection), false);
+                        // Leaves start - break bedrock list
+                        BlockPos pos1 = pos.relative(enumdirection);
+                        if (world.getBlockState(pos1).getBlock() == Blocks.BEDROCK) {
+                            org.leavesmc.leaves.util.BreakBedrockList.onPistonBreakBedrock(world, pos1);
+                        }
+                        world.removeBlock(pos1, false);
+                        // Leaves end - break bedrock list
                     }
                 }
             } else {
                 // Paper start - Protect Bedrock and End Portal/Frames from being destroyed; fix headless pistons breaking blocks
                 BlockPos headPos = pos.relative(enumdirection);
                 if (io.papermc.paper.configuration.GlobalConfiguration.get().unsupportedSettings.allowPermanentBlockBreakExploits || world.getBlockState(headPos) == Blocks.PISTON_HEAD.defaultBlockState().setValue(FACING, enumdirection)) { // double check to make sure we're not a headless piston.
+                    // Leaves start - break bedrock list
+                    if (world.getBlockState(headPos).getBlock() == Blocks.BEDROCK) {
+                        org.leavesmc.leaves.util.BreakBedrockList.onPistonBreakBedrock(world, headPos);
+                    }
+                    // Leaves end - break bedrock list
                     world.removeBlock(headPos, false);
                 } else {
                     ((ServerLevel) world).getChunkSource().blockChanged(headPos); // ... fix client desync
diff --git a/src/main/java/org/leavesmc/leaves/util/BreakBedrockList.java b/src/main/java/org/leavesmc/leaves/util/BreakBedrockList.java
new file mode 100644
index 0000000000000000000000000000000000000000..1c5992f1480a25dbd5967218be2a3a2185d0279e
--- /dev/null
+++ b/src/main/java/org/leavesmc/leaves/util/BreakBedrockList.java
@@ -0,0 +1,114 @@
+package org.leavesmc.leaves.util;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.DirectionalBlock;
+import net.minecraft.world.scores.Objective;
+import net.minecraft.world.scores.ScoreHolder;
+import net.minecraft.world.scores.criteria.ObjectiveCriteria;
+import org.jetbrains.annotations.NotNull;
+import org.leavesmc.leaves.LeavesConfig;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class BreakBedrockList {
+
+    private static final Map<Level, Map<BlockPos, Player>> pistonCache = new HashMap<>();
+    private static final List<Objective> BBL = new ArrayList<>();
+    private static final List<Objective> MBB = new ArrayList<>();
+    private static final List<Objective> LBL = new ArrayList<>();
+
+    public static void endTick() {
+        for (var map : pistonCache.values()) {
+            if (!map.isEmpty()) {
+                map.clear();
+            }
+        }
+    }
+
+    public static void onPlayerPlacePiston(Level level, Player player, BlockPos pos) {
+        if (LeavesConfig.bedrockBreakList) {
+            Direction pistonFacing = level.getBlockState(pos).getValue(DirectionalBlock.FACING);
+            BlockPos bedrockPos = pos.relative(pistonFacing);
+            if (level.getBlockState(bedrockPos).getBlock() == Blocks.BEDROCK) {
+                pistonCache.computeIfAbsent(level, k -> new HashMap<>()).put(bedrockPos, player);
+            }
+        }
+    }
+
+    public static void onPistonBreakBedrock(Level level, BlockPos bedrock) {
+        if (LeavesConfig.bedrockBreakList) {
+            Map<BlockPos, Player> map = pistonCache.get(level);
+
+            boolean flag = map != null && map.get(bedrock) != null;
+
+            if (flag) {
+                if (!BBL.isEmpty()) {
+                    Player player = map.get(bedrock);
+                    for (Objective objective : BBL) {
+                        level.getScoreboard().getOrCreatePlayerScore(player, objective).increment();
+                    }
+                }
+            } else {
+                if (!MBB.isEmpty()) {
+                    ScoreHolder world = ScoreHolder.forNameOnly("$" + level.dimension().location());
+                    for (Objective objective : MBB) {
+                        level.getScoreboard().getOrCreatePlayerScore(world, objective).increment();
+                        level.getScoreboard().getOrCreatePlayerScore(ScoreHolder.forNameOnly("$total"), objective).increment();
+                    }
+                }
+            }
+
+            if (!LBL.isEmpty() && !level.players().isEmpty()) {
+                Player closestPlayer = level.getNearestPlayer(bedrock.getX(), bedrock.getY(), bedrock.getZ(), 10.5, null);
+                if (closestPlayer != null) {
+                    for (Objective objective : LBL) {
+                        level.getScoreboard().getOrCreatePlayerScore(closestPlayer, objective).increment();
+                    }
+                }
+            }
+        }
+    }
+
+    public static void onScoreboardAdd(@NotNull Objective objective) {
+        if (LeavesConfig.bedrockBreakList) {
+            if (objective.getCriteria() == ObjectiveCriteria.DUMMY) {
+                String name = objective.getName();
+
+                int i = name.length() - 4;
+                if (i >= 0) {
+                    String suffix = name.substring(i);
+                    switch (suffix) {
+                        case ".bbl" -> BBL.add(objective);
+                        case ".mbb" -> MBB.add(objective);
+                        case ".lbl" -> LBL.add(objective);
+                    }
+                }
+            }
+        }
+    }
+
+    public static void onScoreboardRemove(@NotNull Objective objective) {
+        if (LeavesConfig.bedrockBreakList) {
+            if (objective.getCriteria() == ObjectiveCriteria.DUMMY) {
+                String name = objective.getName();
+
+                int i = name.length() - 4;
+                if (i >= 0) {
+                    String suffix = name.substring(i);
+                    switch (suffix) {
+                        case ".bbl" -> BBL.remove(objective);
+                        case ".mbb" -> MBB.remove(objective);
+                        case ".lbl" -> LBL.remove(objective);
+                    }
+                }
+            }
+        }
+    }
+}