LeavesMC/patches/server/0103-Force-peaceful-mode-switch.patch

From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: violetc <58360096+s-yh-china@users.noreply.github.com>
Date: Thu, 3 Aug 2023 14:21:47 +0800
Subject: [PATCH] Force peaceful mode switch


diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
index db41ee04b5dd3e162830342e4b1f2b457ffb7fed..c402a51a0951ad775cd7829f442edb8cf779d5ee 100644
--- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java
+++ b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
@@ -75,6 +75,12 @@ public class ServerChunkCache extends ChunkSource {
     private final LevelChunk[] lastLoadedChunks = new LevelChunk[4 * 4];
     // Paper end
 
+    // Leaves start - peaceful mode switch
+    public int peacefulModeSwitchTick = org.leavesmc.leaves.LeavesConfig.forcePeacefulMode;
+    public int peacefulModeSwitchCount = -1;
+    private final List<Class<? extends Entity>> peacefulModeSwitchEntityTypes = List.of(net.minecraft.world.entity.boss.wither.WitherBoss.class, net.minecraft.world.entity.monster.Shulker.class, net.minecraft.world.entity.monster.warden.Warden.class);
+    // Leaves end - peaceful mode switch
+
     public ServerChunkCache(ServerLevel world, LevelStorageSource.LevelStorageAccess session, DataFixer dataFixer, StructureTemplateManager structureTemplateManager, Executor workerExecutor, ChunkGenerator chunkGenerator, int viewDistance, int simulationDistance, boolean dsync, ChunkProgressListener worldGenerationProgressListener, ChunkStatusUpdateListener chunkStatusChangeListener, Supplier<DimensionDataStorage> persistentStateManagerFactory) {
         this.level = world;
         this.mainThreadProcessor = new ServerChunkCache.MainThreadExecutor(world);
@@ -500,7 +506,21 @@ public class ServerChunkCache extends ChunkSource {
             }
             // Leaves end - reset ice & snow tick random
             gameprofilerfiller.push("filteringLoadedChunks");
-            // Paper - optimise chunk tick iteration
+
+            // Leaves start - peaceful mode switch
+            if (peacefulModeSwitchTick > 0) {
+                if (this.level.getLevelData().getGameTime() % peacefulModeSwitchTick == 0) {
+                    peacefulModeSwitchCount = 0;
+                    this.level.getAllEntities().forEach(entity -> {
+                        if (peacefulModeSwitchEntityTypes.contains(entity.getClass())) {
+                            peacefulModeSwitchCount++;
+                        }
+                    });
+                }
+            } else {
+                peacefulModeSwitchCount = -1;
+            }
+            // Leaves end - peaceful mode switch
 
             // Paper - optimise chunk tick iteration
 
@@ -588,10 +608,20 @@ public class ServerChunkCache extends ChunkSource {
                     }
                     Util.shuffle(shuffled, this.level.random);
                     chunkIterator = shuffled.iterator();
+            }
+
+            // Leaves start - peaceful mode switch
+            boolean peacefulModeSwitch = false;
+            if (lastSpawnState != null && peacefulModeSwitchCount != -1) {
+                if (peacefulModeSwitchCount >= NaturalSpawner.globalLimitForCategory(level, net.minecraft.world.entity.MobCategory.MONSTER, lastSpawnState.getSpawnableChunkCount())) {
+                    peacefulModeSwitch = true;
                 }
-                try {
-                // Paper end - optimise chunk tick iteration
-                while (chunkIterator.hasNext()) {
+            }
+            // Leaves end - peaceful mode switch
+
+            try {
+            // Paper end - optimise chunk tick iteration
+            while (chunkIterator.hasNext()) {
                     LevelChunk chunk1 = chunkIterator.next();
                     // Paper end - optimise chunk tick iteration
                     ChunkPos chunkcoordintpair = chunk1.getPos();
@@ -622,7 +652,7 @@ public class ServerChunkCache extends ChunkSource {
                         // Paper end - optimise chunk tick iteration
                         chunk1.incrementInhabitedTime(j);
                         if (spawn && flag && (this.spawnEnemies || this.spawnFriendlies) && this.level.getWorldBorder().isWithinBounds(chunkcoordintpair)) { // Spigot // Paper - optimise chunk tick iteration
-                            NaturalSpawner.spawnForChunk(this.level, chunk1, spawnercreature_d, this.spawnFriendlies, this.spawnEnemies, flag1);
+                            NaturalSpawner.spawnForChunk(this.level, chunk1, spawnercreature_d, this.spawnFriendlies, this.spawnEnemies, flag1, peacefulModeSwitch); // Leaves - peaceful mode switch
                         }
 
                         if (true || this.level.shouldTickBlocksAt(chunkcoordintpair.toLong())) { // Paper - optimise chunk tick iteration
diff --git a/src/main/java/net/minecraft/world/level/NaturalSpawner.java b/src/main/java/net/minecraft/world/level/NaturalSpawner.java
index 083a8a7dd99e447904dbac161dd3a1de663d6011..27f064812fd7b8f3feedc9966c9dfc78bfdcc85f 100644
--- a/src/main/java/net/minecraft/world/level/NaturalSpawner.java
+++ b/src/main/java/net/minecraft/world/level/NaturalSpawner.java
@@ -128,6 +128,12 @@ public final class NaturalSpawner {
     }
 
     public static void spawnForChunk(ServerLevel world, LevelChunk chunk, NaturalSpawner.SpawnState info, boolean spawnAnimals, boolean spawnMonsters, boolean rareSpawn) {
+        // Leaves start - peaceful mode switch
+        spawnForChunk(world, chunk, info, spawnAnimals, spawnMonsters, rareSpawn, false);
+    }
+
+    public static void spawnForChunk(ServerLevel world, LevelChunk chunk, NaturalSpawner.SpawnState info, boolean spawnAnimals, boolean spawnMonsters, boolean rareSpawn, boolean peacefulModeSwitch) {
+        // Leaves end - peaceful mode switch
         world.getProfiler().push("spawner");
         MobCategory[] aenumcreaturetype = NaturalSpawner.SPAWNING_CATEGORIES;
         int i = aenumcreaturetype.length;
@@ -136,6 +142,11 @@ public final class NaturalSpawner {
 
         for (int j = 0; j < i; ++j) {
             MobCategory enumcreaturetype = aenumcreaturetype[j];
+            // Leaves start - peaceful mode switch
+            if (enumcreaturetype == MobCategory.MONSTER && peacefulModeSwitch) {
+                continue;
+            }
+            // Leaves end - peaceful mode switch
             // CraftBukkit start - Use per-world spawn limits
             boolean spawnThisTick = true;
             int limit = enumcreaturetype.getMaxInstancesPerChunk();
diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
index f2b20ed5063a293f0b464548f590d652170cd1d8..ab4510eb9e5eaca46e3278c73e208757292a9f90 100644
--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
@@ -2458,6 +2458,18 @@ public class CraftWorld extends CraftRegionAccessor implements World {
         return CraftFeatureFlag.getFromNMS(this.getHandle().enabledFeatures()).stream().map(FeatureFlag.class::cast).collect(Collectors.toUnmodifiableSet());
     }
 
+    // Leaves start - unsupported settings
+    @Override
+    public void setPeacefulModeSwitchTick(int tick) {
+        this.getHandle().chunkSource.peacefulModeSwitchTick = tick;
+    }
+
+    @Override
+    public int getPeacefulModeSwitchTick() {
+        return this.getHandle().chunkSource.peacefulModeSwitchTick;
+    }
+    // Leaves end - unsupported settings
+
     public void storeBukkitValues(CompoundTag c) {
         if (!this.persistentDataContainer.isEmpty()) {
             c.put("BukkitValues", this.persistentDataContainer.toTagCompound());
diff --git a/src/main/java/org/leavesmc/leaves/command/LeavesCommand.java b/src/main/java/org/leavesmc/leaves/command/LeavesCommand.java
index facd180da9b7025cf7ae192cbe91317ff4b70472..2d871fafff90e2dbc8c4141f92cdb1544ccdce43 100644
--- a/src/main/java/org/leavesmc/leaves/command/LeavesCommand.java
+++ b/src/main/java/org/leavesmc/leaves/command/LeavesCommand.java
@@ -13,6 +13,7 @@ import org.bukkit.plugin.PluginManager;
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.jetbrains.annotations.NotNull;
 import org.leavesmc.leaves.command.subcommands.ConfigCommand;
+import org.leavesmc.leaves.command.subcommands.PeacefulModeSwitchCommand;
 import org.leavesmc.leaves.command.subcommands.UpdateCommand;
 
 import java.util.ArrayList;
@@ -35,6 +36,7 @@ public final class LeavesCommand extends Command {
         final Map<Set<String>, LeavesSubcommand> commands = new HashMap<>();
         commands.put(Set.of("config"), new ConfigCommand());
         commands.put(Set.of("update"), new UpdateCommand());
+        commands.put(Set.of("peaceful"), new PeacefulModeSwitchCommand());
 
         return commands.entrySet().stream()
             .flatMap(entry -> entry.getKey().stream().map(s -> Map.entry(s, entry.getValue())))
diff --git a/src/main/java/org/leavesmc/leaves/command/subcommands/PeacefulModeSwitchCommand.java b/src/main/java/org/leavesmc/leaves/command/subcommands/PeacefulModeSwitchCommand.java
new file mode 100644
index 0000000000000000000000000000000000000000..4c7895c94f7adaf0a7fb7c31327786b14768632e
--- /dev/null
+++ b/src/main/java/org/leavesmc/leaves/command/subcommands/PeacefulModeSwitchCommand.java
@@ -0,0 +1,87 @@
+package org.leavesmc.leaves.command.subcommands;
+
+import io.papermc.paper.command.CommandUtil;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.JoinConfiguration;
+import net.kyori.adventure.text.format.NamedTextColor;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.entity.MobCategory;
+import net.minecraft.world.level.NaturalSpawner;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.command.CommandSender;
+import org.bukkit.craftbukkit.CraftWorld;
+import org.bukkit.entity.Player;
+import org.leavesmc.leaves.command.LeavesSubcommand;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class PeacefulModeSwitchCommand implements LeavesSubcommand {
+
+    @Override
+    public boolean execute(CommandSender sender, String subCommand, String[] args) {
+        World world;
+        if (args.length == 0) {
+            if (sender instanceof Player player) {
+                world = player.getWorld();
+            } else {
+                sender.sendMessage(Component.text("Must specify a world! ex: '/leaves peaceful world'", NamedTextColor.RED));
+                return true;
+            }
+        } else {
+            final String input = args[0];
+            final World inputWorld = Bukkit.getWorld(input);
+            if (inputWorld == null) {
+                sender.sendMessage(Component.text("'" + input + "' is not a valid world!", NamedTextColor.RED));
+                return true;
+            } else {
+                world = inputWorld;
+            }
+        }
+
+        final ServerLevel level = ((CraftWorld) world).getHandle();
+        int chunks = 0;
+        if (level.chunkSource.getLastSpawnState() != null) {
+            chunks = level.chunkSource.getLastSpawnState().getSpawnableChunkCount();
+        }
+
+        sender.sendMessage(Component.join(JoinConfiguration.noSeparators(),
+            Component.text("Peaceful Mode Switch for world: "),
+            Component.text(world.getName(), NamedTextColor.AQUA)
+        ));
+
+        sender.sendMessage(Component.join(JoinConfiguration.noSeparators(),
+            Component.text("Refuses per "),
+            Component.text(level.chunkSource.peacefulModeSwitchTick, level.chunkSource.peacefulModeSwitchTick > 0 ? NamedTextColor.AQUA : NamedTextColor.GRAY),
+            Component.text(" tick")
+        ));
+
+        int count = level.chunkSource.peacefulModeSwitchCount;
+        int limit = NaturalSpawner.globalLimitForCategory(level, MobCategory.MONSTER, chunks);
+        NamedTextColor color = count >= limit ? NamedTextColor.AQUA : NamedTextColor.GRAY;
+
+        sender.sendMessage(Component.join(JoinConfiguration.noSeparators(),
+            Component.text("Now count "),
+            Component.text(count, color),
+            Component.text("/", color),
+            Component.text(limit, color)
+        ));
+
+        return true;
+    }
+
+    @Override
+    public List<String> tabComplete(final CommandSender sender, final String subCommand, final String[] args) {
+        return CommandUtil.getListMatchingLast(sender, args, this.suggestPeacefulModeSwitch(args));
+    }
+
+    private List<String> suggestPeacefulModeSwitch(final String[] args) {
+        if (args.length == 1) {
+            return new ArrayList<>(Bukkit.getWorlds().stream().map(World::getName).toList());
+        }
+
+        return Collections.emptyList();
+    }
+}