aboutsummaryrefslogtreecommitdiffhomepage
path: root/patches/server/0625-Entity-load-save-limit-per-chunk.patch
blob: e9f4fbe4c290580e4b32f9ac70b80e0cc89c3039 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Jason Penilla <11360596+jpenilla@users.noreply.github.com>
Date: Wed, 18 Nov 2020 20:52:25 -0800
Subject: [PATCH] Entity load/save limit per chunk

Adds a config option to limit the number of entities saved and loaded
to a chunk. The default values of -1 disable the limit. Although
defaults are only included for certain entites, this allows setting
limits for any entity type.

diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
index 716747f86cb7b4ee811c5e128c00b5319959cb64..3db7a4ad81db0475ce975c02c435a069abf2ad7e 100644
--- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
@@ -8,6 +8,8 @@ import it.unimi.dsi.fastutil.objects.Reference2IntMap;
 import it.unimi.dsi.fastutil.objects.Reference2IntOpenHashMap;
 import net.minecraft.world.entity.MobCategory;
 import com.destroystokyo.paper.antixray.ChunkPacketBlockControllerAntiXray.EngineMode;
+import java.util.HashMap;
+import java.util.Map;
 import org.bukkit.Bukkit;
 import org.bukkit.configuration.file.YamlConfiguration;
 import org.spigotmc.SpigotWorldConfig;
@@ -140,6 +142,38 @@ public class PaperWorldConfig {
         );
     }
 
+    public Map<net.minecraft.world.entity.EntityType<?>, Integer> entityPerChunkSaveLimits = new HashMap<>();
+    private void entityPerChunkSaveLimits() {
+        getInt("entity-per-chunk-save-limit.experience_orb", -1);
+        getInt("entity-per-chunk-save-limit.snowball", -1);
+        getInt("entity-per-chunk-save-limit.ender_pearl", -1);
+        getInt("entity-per-chunk-save-limit.arrow", -1);
+        getInt("entity-per-chunk-save-limit.fireball", -1);
+        getInt("entity-per-chunk-save-limit.small_fireball", -1);
+
+        addEntityPerChunkSaveLimitsFromSection(config.getConfigurationSection("world-settings.default.entity-per-chunk-save-limit"), entityPerChunkSaveLimits);
+        addEntityPerChunkSaveLimitsFromSection(config.getConfigurationSection("world-settings." + worldName + ".entity-per-chunk-save-limit"), entityPerChunkSaveLimits);
+    }
+
+    private static void addEntityPerChunkSaveLimitsFromSection(final org.bukkit.configuration.ConfigurationSection section, final Map<net.minecraft.world.entity.EntityType<?>, Integer> limitMap) {
+        if (section == null) {
+            return;
+        }
+        for (final String key : section.getKeys(false)) {
+            final int value = section.getInt(key);
+            final net.minecraft.world.entity.EntityType<?> type = net.minecraft.world.entity.EntityType.byString(key).orElse(null);
+            if (type == null) {
+                logError("Invalid entity-per-chunk-save-limit config, '" + key+ "' is not a valid entity type. Correct this in paper.yml.");
+                continue;
+            }
+            if (value >= 0) {
+                limitMap.put(type, value);
+            } else {
+                limitMap.remove(type);
+            }
+        }
+    }
+
     public short keepLoadedRange;
     private void keepLoadedRange() {
         keepLoadedRange = (short) (getInt("keep-spawn-loaded-range", Math.min(spigotConfig.viewDistance, 10)) * 16);
diff --git a/src/main/java/net/minecraft/world/entity/EntityType.java b/src/main/java/net/minecraft/world/entity/EntityType.java
index d17bde781ff574799054d9696e4d4480fe04a52c..419a7e9614af2328ed401fc954196056243a984c 100644
--- a/src/main/java/net/minecraft/world/entity/EntityType.java
+++ b/src/main/java/net/minecraft/world/entity/EntityType.java
@@ -560,9 +560,20 @@ public class EntityType<T extends Entity> implements EntityTypeTest<Entity, T> {
         final Spliterator<? extends net.minecraft.nbt.Tag> spliterator = entityNbtList.spliterator();
 
         return StreamSupport.stream(new Spliterator<Entity>() {
+            final java.util.Map<EntityType<?>, Integer> loadedEntityCounts = new java.util.HashMap<>(); // Paper
             public boolean tryAdvance(Consumer<? super Entity> consumer) {
                 return spliterator.tryAdvance((nbtbase) -> {
                     EntityType.loadEntityRecursive((CompoundTag) nbtbase, world, (entity) -> {
+                        // Paper start
+                        final EntityType<?> entityType = entity.getType();
+                        final int saveLimit = world.paperConfig.entityPerChunkSaveLimits.getOrDefault(entityType, -1);
+                        if (saveLimit > -1) {
+                            if (this.loadedEntityCounts.getOrDefault(entityType, 0) >= saveLimit) {
+                                return null;
+                            }
+                            this.loadedEntityCounts.merge(entityType, 1, Integer::sum);
+                        }
+                        // Paper end
                         consumer.accept(entity);
                         return entity;
                     });
diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/EntityStorage.java b/src/main/java/net/minecraft/world/level/chunk/storage/EntityStorage.java
index ac1e1a56698bda3a02d76c843562d4f66ad9ffa3..bc46fdff45b174d9c266d1b6b546061a39b4997d 100644
--- a/src/main/java/net/minecraft/world/level/chunk/storage/EntityStorage.java
+++ b/src/main/java/net/minecraft/world/level/chunk/storage/EntityStorage.java
@@ -90,7 +90,18 @@ public class EntityStorage implements EntityPersistentStorage<Entity> {
 
         } else {
             ListTag listTag = new ListTag();
+            final java.util.Map<net.minecraft.world.entity.EntityType<?>, Integer> savedEntityCounts = new java.util.HashMap<>(); // Paper
             dataList.getEntities().forEach((entity) -> {
+                // Paper start
+                final EntityType<?> entityType = entity.getType();
+                final int saveLimit = this.level.paperConfig.entityPerChunkSaveLimits.getOrDefault(entityType, -1);
+                if (saveLimit > -1) {
+                    if (savedEntityCounts.getOrDefault(entityType, 0) >= saveLimit) {
+                        return;
+                    }
+                    savedEntityCounts.merge(entityType, 1, Integer::sum);
+                }
+                // Paper end
                 CompoundTag compoundTag = new CompoundTag();
                 if (entity.save(compoundTag)) {
                     listTag.add(compoundTag);