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

From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: violetc <58360096+s-yh-china@users.noreply.github.com>
Date: Wed, 22 Mar 2023 17:18:23 +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 32c6d55851c1ef74476bfa570405e5205af21b35..b8fd91fc1ebaafad28cfa08d5af71aa3b1c54da4 100644
--- a/src/main/java/net/minecraft/server/MinecraftServer.java
+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
@@ -1609,6 +1609,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
 
         top.leavesmc.leaves.protocol.BBORProtocol.tick(); // Leaves - bbor
         top.leavesmc.leaves.protocol.AppleSkinProtocol.tick(); // Leaves - appleskin
+        top.leavesmc.leaves.util.BreakBedrockList.endTick(); // Leaves - break bedrock list
 
         MinecraftTimings.tickablesTimer.startTiming(); // Spigot // Paper
         for (int i = 0; i < this.tickables.size(); ++i) {
diff --git a/src/main/java/net/minecraft/server/ServerScoreboard.java b/src/main/java/net/minecraft/server/ServerScoreboard.java
index 3a4a0727ad44322e3ba85512cd077808dab080b7..4a1a5f5c4672262875caa17bc7da8aa221b82742 100644
--- a/src/main/java/net/minecraft/server/ServerScoreboard.java
+++ b/src/main/java/net/minecraft/server/ServerScoreboard.java
@@ -132,6 +132,7 @@ public class ServerScoreboard extends Scoreboard {
     @Override
     public void onObjectiveAdded(Objective objective) {
         super.onObjectiveAdded(objective);
+        top.leavesmc.leaves.util.BreakBedrockList.onScoreboardAdd(objective); // Leaves - break bedrock list
         this.setDirty();
     }
 
@@ -148,6 +149,7 @@ public class ServerScoreboard extends Scoreboard {
     @Override
     public void onObjectiveRemoved(Objective objective) {
         super.onObjectiveRemoved(objective);
+        top.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 ee316f2474e43c1e644632772e9eb9cc181756c6..7931f202793e04dcde5a317f06b2a8c403240216 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
@@ -92,6 +92,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) {
+                top.leavesmc.leaves.util.BreakBedrockList.onPlayerPlacePiston(world, player, pos);
+            }
+            // Leaves end - break bedrock list
             this.checkIfExtend(world, pos, state);
         }
 
@@ -277,13 +282,24 @@ public class PistonBaseBlock extends DirectionalBlock {
                             }
                         }
                         // Paper end
-                        world.removeBlock(pos.relative(enumdirection), false);
+                        // Leaves start - break bedrock list
+                        BlockPos pos1 = pos.relative(enumdirection);
+                        if (world.getBlockState(pos1).getBlock() == Blocks.BEDROCK) {
+                            top.leavesmc.leaves.util.BreakBedrockList.onPistonBreakBedrock(world, pos1);
+                        }
+                        world.removeBlock(pos1, false);
+                        // Leaves end - break bedrock list
                     }
                 }
             } else {
                 // Paper start - 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) {
+                        top.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/top/leavesmc/leaves/util/BreakBedrockList.java b/src/main/java/top/leavesmc/leaves/util/BreakBedrockList.java
new file mode 100644
index 0000000000000000000000000000000000000000..a1194aca9f70a44472d1f2ce0cbd6a3e0463eba9
--- /dev/null
+++ b/src/main/java/top/leavesmc/leaves/util/BreakBedrockList.java
@@ -0,0 +1,114 @@
+package top.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.criteria.ObjectiveCriteria;
+import org.jetbrains.annotations.NotNull;
+import top.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()) {
+                    String player = map.get(bedrock).getScoreboardName();
+                    for (Objective objective : BBL) {
+                        level.getScoreboard().getOrCreatePlayerScore(player, objective).increment();
+                    }
+                }
+            } else {
+                if (!MBB.isEmpty()) {
+                    String world = "$" + level.dimension().location();
+                    for (Objective objective : MBB) {
+                        level.getScoreboard().getOrCreatePlayerScore(world, objective).increment();
+                        level.getScoreboard().getOrCreatePlayerScore("$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) {
+                    String player = closestPlayer.getScoreboardName();
+                    for (Objective objective : LBL) {
+                        level.getScoreboard().getOrCreatePlayerScore(player, 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);
+                    }
+                }
+            }
+        }
+    }
+}