core
/
testserver
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
testserver/Spigot-Server-Patches/0296-Duplicate-UUID-Resolve...

224 lines
12 KiB
Diff
Raw Normal View History

Updated Upstream (Bukkit/CraftBukkit/Spigot) Developers!: You will need to clean up your work/Minecraft/1.13.2 folder for this Upstream has released updates that appears to apply and compile correctly. This update has not been tested by PaperMC and as with ANY update, please do your own testing Bukkit Changes: b850a822 SPIGOT-4526: Add conversion time API for Zombie & subclasses CraftBukkit Changes: 38cf676e SPIGOT-4534: CreatureSpawnEvent not being called for CHUNK_GEN b446cb5d SPIGOT-4527: Fix sponges with waterlogged blocks 6ec8ea5c SPIGOT-4526: Add conversion time API for Zombie & subclasses c64fe508 Mappings Update a3c2ec03 Fix missing ServerListPingEvent call for legacy pings Spigot Changes: 1dc156ce Rebuild patches 140f654d Mappings Update
2018-12-17 05:18:06 +00:00
From 3d3653b83b8c5299747f3636891adf061080ac5e Mon Sep 17 00:00:00 2001
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
From: Aikar <aikar@aikar.co>
Date: Sat, 21 Jul 2018 14:27:34 -0400
Subject: [PATCH] Duplicate UUID Resolve Option
Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24
which was added all the way back in March of 2016, it was unknown (potentially not at the time)
that an entity might actually change the seed of the random object.
At some point, EntitySquid did start setting the seed. Due to this shared random, this caused
every entity to use a Random object with a predictable seed.
This has caused entities to potentially generate with the same UUID....
Over the years, servers have had entities disappear, but no sign of trouble
because CraftBukkit removed the log lines indicating that something was wrong.
We have fixed the root issue causing duplicate UUID's, however we now have chunk
files full of entities that have the same UUID as another entity!
When these chunks load, the 2nd entity will not be added to the world correctly.
If that chunk loads in a different order in the future, then it will reverse and the
missing one is now the one added to the world and not the other. This results in very
inconsistent entity behavior.
This change allows you to recover any duplicate entity by generating a new UUID for it.
This also lets you delete them instead if you don't want to risk having new entities added to
the world that you previously did not see.
But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options.
It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
Modified Configurable Chunk Inhabited Timer Patch Replaces the "use-chunk-inhabited-timer" config option with the options "use-fixed-chunk-inhabited-time" and "fixed-chunk-inhabited-time". When using "use-fixed-chunk-inhabited-time=false" everything will be the same like it was with "use-chunk-inhabited-timer=true". When using "use-fixed-chunk-inhabited-time=true" and "fixed-chunk-inhabited-time=0" everything will be the same like it was with "use-chunk-inhabited-timer=false". Instead of just using 0 when all chunks should be treated equally this allows to fine-tune vanilla gameplay.
2018-12-13 00:40:29 +00:00
index 92acfa6fb..05509e4fd 100644
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
--- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
Modified Configurable Chunk Inhabited Timer Patch Replaces the "use-chunk-inhabited-timer" config option with the options "use-fixed-chunk-inhabited-time" and "fixed-chunk-inhabited-time". When using "use-fixed-chunk-inhabited-time=false" everything will be the same like it was with "use-chunk-inhabited-timer=true". When using "use-fixed-chunk-inhabited-time=true" and "fixed-chunk-inhabited-time=0" everything will be the same like it was with "use-chunk-inhabited-timer=false". Instead of just using 0 when all chunks should be treated equally this allows to fine-tune vanilla gameplay.
2018-12-13 00:40:29 +00:00
@@ -454,4 +454,43 @@ public class PaperWorldConfig {
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
log("Bed Search Radius: " + bedSearchRadius);
}
}
+
+ public enum DuplicateUUIDMode {
Improvements to Logging Warnings/Dupe Entities - Resolves #1544 1) Removed "Regen" mode of Dupe UUID resolver, forced safe. Some servers who updated before we had safe mode added still had this value. There's really no reason to keep this mode, as we've seen that vanilla triggers this often and 99.9999999% of cases will be an actual duplicate that needs to be deleted. 2) Made Vanilla Debug messages about dupe UUIDs and dupe uuid resolve messages only show up if the debug.entities flag is on. This will stop server owners from panicing from seeing these logs, and stop opening bug reports on this, only for us to tell you "don't worry about it". 3) Avoid adding entities to world that are already added to world. This can be triggered by anything that causes an entity to be added to the world during the chunk load process, such as chunk conversions. Issue #1544 was a case of this. 4) Removed debug warning about ExpiringMap. Nothing more I know to do about this anyways. We recover from it, stop warning to reduce noise of issues to us.
2018-10-07 18:58:53 +00:00
+ SAFE_REGEN, DELETE, NOTHING, WARN
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
+ }
Add "Safe Regen" Duplicate UUID resolver and make default After witnessing behavior of the regeneration logs, its clear that Vanilla has had bugs with saving duplicate entities for a while.... Some entities are saved in multiple chunks, and now we are bringing those duplicates out that use to never surface. This mode will analyze if the entity appears to be a duplicate (near the other dupe uuid) and delete the entity instead. This should reduce regenerations to entities that are nowhere near each other, and therefore more likely to be subject to real UUID collisions due to our previous bug, and therefor should survive the chunk load.
2018-08-03 03:06:03 +00:00
+ public DuplicateUUIDMode duplicateUUIDMode = DuplicateUUIDMode.SAFE_REGEN;
make dupe uuid saferegen delete range configurable also ensure we never process already valid entities. this shouldnt be possible as of recent commits as we made the entity slice array safer, but doesn't hurt for this logic to be safe too incase that patch got dropped in a future version by accident/necessarily
2018-08-04 04:23:00 +00:00
+ public int duplicateUUIDDeleteRange = 32;
Fix Dupe UUID logic triggering when the duplicate is pending unload Vanilla logic checks unload queue and overwrites if its in it. we're triggering this if a chunk unloads, and reloads immediately in same tick. Added check for unload queue to not treat as duplicate Also fixed the config setting not even loading
2018-07-28 05:20:06 +00:00
+ private void repairDuplicateUUID() {
Add "Safe Regen" Duplicate UUID resolver and make default After witnessing behavior of the regeneration logs, its clear that Vanilla has had bugs with saving duplicate entities for a while.... Some entities are saved in multiple chunks, and now we are bringing those duplicates out that use to never surface. This mode will analyze if the entity appears to be a duplicate (near the other dupe uuid) and delete the entity instead. This should reduce regenerations to entities that are nowhere near each other, and therefore more likely to be subject to real UUID collisions due to our previous bug, and therefor should survive the chunk load.
2018-08-03 03:06:03 +00:00
+ String desiredMode = getString("duplicate-uuid-resolver", "saferegen").toLowerCase().trim();
make dupe uuid saferegen delete range configurable also ensure we never process already valid entities. this shouldnt be possible as of recent commits as we made the entity slice array safer, but doesn't hurt for this logic to be safe too incase that patch got dropped in a future version by accident/necessarily
2018-08-04 04:23:00 +00:00
+ duplicateUUIDDeleteRange = getInt("duplicate-uuid-saferegen-delete-range", duplicateUUIDDeleteRange);
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
+ switch (desiredMode.toLowerCase()) {
Improvements to Logging Warnings/Dupe Entities - Resolves #1544 1) Removed "Regen" mode of Dupe UUID resolver, forced safe. Some servers who updated before we had safe mode added still had this value. There's really no reason to keep this mode, as we've seen that vanilla triggers this often and 99.9999999% of cases will be an actual duplicate that needs to be deleted. 2) Made Vanilla Debug messages about dupe UUIDs and dupe uuid resolve messages only show up if the debug.entities flag is on. This will stop server owners from panicing from seeing these logs, and stop opening bug reports on this, only for us to tell you "don't worry about it". 3) Avoid adding entities to world that are already added to world. This can be triggered by anything that causes an entity to be added to the world during the chunk load process, such as chunk conversions. Issue #1544 was a case of this. 4) Removed debug warning about ExpiringMap. Nothing more I know to do about this anyways. We recover from it, stop warning to reduce noise of issues to us.
2018-10-07 18:58:53 +00:00
+ case "regen":
+ case "regenerate":
Add "Safe Regen" Duplicate UUID resolver and make default After witnessing behavior of the regeneration logs, its clear that Vanilla has had bugs with saving duplicate entities for a while.... Some entities are saved in multiple chunks, and now we are bringing those duplicates out that use to never surface. This mode will analyze if the entity appears to be a duplicate (near the other dupe uuid) and delete the entity instead. This should reduce regenerations to entities that are nowhere near each other, and therefore more likely to be subject to real UUID collisions due to our previous bug, and therefor should survive the chunk load.
2018-08-03 03:06:03 +00:00
+ case "saferegen":
+ case "saferegenerate":
+ duplicateUUIDMode = DuplicateUUIDMode.SAFE_REGEN;
Improvements to Logging Warnings/Dupe Entities - Resolves #1544 1) Removed "Regen" mode of Dupe UUID resolver, forced safe. Some servers who updated before we had safe mode added still had this value. There's really no reason to keep this mode, as we've seen that vanilla triggers this often and 99.9999999% of cases will be an actual duplicate that needs to be deleted. 2) Made Vanilla Debug messages about dupe UUIDs and dupe uuid resolve messages only show up if the debug.entities flag is on. This will stop server owners from panicing from seeing these logs, and stop opening bug reports on this, only for us to tell you "don't worry about it". 3) Avoid adding entities to world that are already added to world. This can be triggered by anything that causes an entity to be added to the world during the chunk load process, such as chunk conversions. Issue #1544 was a case of this. 4) Removed debug warning about ExpiringMap. Nothing more I know to do about this anyways. We recover from it, stop warning to reduce noise of issues to us.
2018-10-07 18:58:53 +00:00
+ log("Duplicate UUID Resolve: Regenerate New UUID if distant (Delete likely duplicates within " + duplicateUUIDDeleteRange + " blocks)");
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
+ break;
+ case "remove":
+ case "delete":
+ duplicateUUIDMode = DuplicateUUIDMode.DELETE;
+ log("Duplicate UUID Resolve: Delete Entity");
+ break;
+ case "silent":
+ case "nothing":
+ duplicateUUIDMode = DuplicateUUIDMode.NOTHING;
+ logError("Duplicate UUID Resolve: Do Nothing (no logs) - Warning, may lose indication of bad things happening");
+ break;
+ case "log":
+ case "warn":
+ duplicateUUIDMode = DuplicateUUIDMode.WARN;
+ log("Duplicate UUID Resolve: Warn (do nothing but log it happened, may be spammy)");
+ break;
+ default:
+ duplicateUUIDMode = DuplicateUUIDMode.WARN;
Improvements to Logging Warnings/Dupe Entities - Resolves #1544 1) Removed "Regen" mode of Dupe UUID resolver, forced safe. Some servers who updated before we had safe mode added still had this value. There's really no reason to keep this mode, as we've seen that vanilla triggers this often and 99.9999999% of cases will be an actual duplicate that needs to be deleted. 2) Made Vanilla Debug messages about dupe UUIDs and dupe uuid resolve messages only show up if the debug.entities flag is on. This will stop server owners from panicing from seeing these logs, and stop opening bug reports on this, only for us to tell you "don't worry about it". 3) Avoid adding entities to world that are already added to world. This can be triggered by anything that causes an entity to be added to the world during the chunk load process, such as chunk conversions. Issue #1544 was a case of this. 4) Removed debug warning about ExpiringMap. Nothing more I know to do about this anyways. We recover from it, stop warning to reduce noise of issues to us.
2018-10-07 18:58:53 +00:00
+ logError("Warning: Invalid duplicate-uuid-resolver config " + desiredMode + " - must be one of: regen, delete, nothing, warn");
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
+ log("Duplicate UUID Resolve: Warn (do nothing but log it happened, may be spammy)");
+ break;
+ }
+ }
}
diff --git a/src/main/java/net/minecraft/server/Chunk.java b/src/main/java/net/minecraft/server/Chunk.java
Updated Upstream (Bukkit/CraftBukkit/Spigot) Developers!: You will need to clean up your work/Minecraft/1.13.2 folder for this Upstream has released updates that appears to apply and compile correctly. This update has not been tested by PaperMC and as with ANY update, please do your own testing Bukkit Changes: b850a822 SPIGOT-4526: Add conversion time API for Zombie & subclasses CraftBukkit Changes: 38cf676e SPIGOT-4534: CreatureSpawnEvent not being called for CHUNK_GEN b446cb5d SPIGOT-4527: Fix sponges with waterlogged blocks 6ec8ea5c SPIGOT-4526: Add conversion time API for Zombie & subclasses c64fe508 Mappings Update a3c2ec03 Fix missing ServerListPingEvent call for legacy pings Spigot Changes: 1dc156ce Rebuild patches 140f654d Mappings Update
2018-12-17 05:18:06 +00:00
index 6c9d7df20..55cb7b88e 100644
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
--- a/src/main/java/net/minecraft/server/Chunk.java
+++ b/src/main/java/net/minecraft/server/Chunk.java
@@ -1,5 +1,10 @@
package net.minecraft.server;
+// Paper start
+import com.destroystokyo.paper.PaperWorldConfig.DuplicateUUIDMode;
+import java.util.HashMap;
+import java.util.UUID;
+// Paper end
import com.destroystokyo.paper.exception.ServerInternalException;
import com.google.common.collect.Maps;
Rebuild patches for upstream merge
2018-07-21 20:43:00 +00:00
import com.google.common.collect.Queues;
Updated Upstream (Bukkit/CraftBukkit/Spigot) Developers!: You will need to clean up your work/Minecraft/1.13.2 folder for this Upstream has released updates that appears to apply and compile correctly. This update has not been tested by PaperMC and as with ANY update, please do your own testing Bukkit Changes: b850a822 SPIGOT-4526: Add conversion time API for Zombie & subclasses CraftBukkit Changes: 38cf676e SPIGOT-4534: CreatureSpawnEvent not being called for CHUNK_GEN b446cb5d SPIGOT-4527: Fix sponges with waterlogged blocks 6ec8ea5c SPIGOT-4526: Add conversion time API for Zombie & subclasses c64fe508 Mappings Update a3c2ec03 Fix missing ServerListPingEvent call for legacy pings Spigot Changes: 1dc156ce Rebuild patches 140f654d Mappings Update
2018-12-17 05:18:06 +00:00
@@ -42,6 +47,7 @@ public class Chunk implements IChunkAccess {
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
public final World world;
Rebuild patches for upstream merge
2018-07-21 20:43:00 +00:00
public final Map<HeightMap.Type, HeightMap> heightMap;
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
public Long scheduledForUnload; // Paper - delay chunk unloads
+ private static final Logger logger = LogManager.getLogger(); // Paper
public final int locX;
public final int locZ;
Fix many light bugs by removing recheckGaps change Fixes #1539 Fixes #1483
2018-10-06 04:56:20 +00:00
private boolean l;
Updated Upstream (Bukkit/CraftBukkit/Spigot) Developers!: You will need to clean up your work/Minecraft/1.13.2 folder for this Upstream has released updates that appears to apply and compile correctly. This update has not been tested by PaperMC and as with ANY update, please do your own testing Bukkit Changes: b850a822 SPIGOT-4526: Add conversion time API for Zombie & subclasses CraftBukkit Changes: 38cf676e SPIGOT-4534: CreatureSpawnEvent not being called for CHUNK_GEN b446cb5d SPIGOT-4527: Fix sponges with waterlogged blocks 6ec8ea5c SPIGOT-4526: Add conversion time API for Zombie & subclasses c64fe508 Mappings Update a3c2ec03 Fix missing ServerListPingEvent call for legacy pings Spigot Changes: 1dc156ce Rebuild patches 140f654d Mappings Update
2018-12-17 05:18:06 +00:00
@@ -692,6 +698,7 @@ public class Chunk implements IChunkAccess {
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
if (i != this.locX || j != this.locZ) {
Update upstream BD/B/CB/S Note to other developers: This commit may require you to wipe your workspace as a result of the changes to BD. --- work/BuildData Submodule work/BuildData f527a8ff..d56672db: > Mappings Update --- work/Bukkit Submodule work/Bukkit 0c1d258bb..db06c80d7: > Add list of entities to EntityTransformEvent > SPIGOT-4347: Add API to allow storing arbitrary values on ItemStacks ---work/CraftBukkit Submodule work/CraftBukkit 6a398ac44..068dab5be: > Enable optional source JAR shading via profile shadeSourcesJar > Use ImmutableList rather than AbstractList for CraftMetaBook > Fix setRecipes(List) not setting Knowledge Book recipes. > Mappings Update > Add list of entities to EntityTransformEvent & move die calls > SPIGOT-4347: Add API to allow storing arbitrary values on ItemStacks > Add Vanilla help to default permissions --- work/Spigot Submodule work/Spigot a1f2566f6..e769fe4d9: > Mappings Update > Rebuild patches
2018-12-08 10:09:55 +00:00
Chunk.d.warn("Wrong location! ({}, {}) should be ({}, {}), {}", i, j, this.locX, this.locZ, entity);
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
entity.die();
+ return; // Paper
}
int k = MathHelper.floor(entity.locY / 16.0D);
Updated Upstream (Bukkit/CraftBukkit/Spigot) Developers!: You will need to clean up your work/Minecraft/1.13.2 folder for this Upstream has released updates that appears to apply and compile correctly. This update has not been tested by PaperMC and as with ANY update, please do your own testing Bukkit Changes: b850a822 SPIGOT-4526: Add conversion time API for Zombie & subclasses CraftBukkit Changes: 38cf676e SPIGOT-4534: CreatureSpawnEvent not being called for CHUNK_GEN b446cb5d SPIGOT-4527: Fix sponges with waterlogged blocks 6ec8ea5c SPIGOT-4526: Add conversion time API for Zombie & subclasses c64fe508 Mappings Update a3c2ec03 Fix missing ServerListPingEvent call for legacy pings Spigot Changes: 1dc156ce Rebuild patches 140f654d Mappings Update
2018-12-17 05:18:06 +00:00
@@ -881,6 +888,50 @@ public class Chunk implements IChunkAccess {
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
for (int j = 0; j < i; ++j) {
Updated Upstream (Bukkit/CraftBukkit/Spigot) Developers!: You will need to clean up your work/Minecraft/1.13.2 folder for this Upstream has released updates that appears to apply and compile correctly. This update has not been tested by PaperMC and as with ANY update, please do your own testing Bukkit Changes: b850a822 SPIGOT-4526: Add conversion time API for Zombie & subclasses CraftBukkit Changes: 38cf676e SPIGOT-4534: CreatureSpawnEvent not being called for CHUNK_GEN b446cb5d SPIGOT-4527: Fix sponges with waterlogged blocks 6ec8ea5c SPIGOT-4526: Add conversion time API for Zombie & subclasses c64fe508 Mappings Update a3c2ec03 Fix missing ServerListPingEvent call for legacy pings Spigot Changes: 1dc156ce Rebuild patches 140f654d Mappings Update
2018-12-17 05:18:06 +00:00
// CraftBukkit start
List<Entity> entityslice = aentityslice[j]; // Spigot
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
+ // Paper start
+ DuplicateUUIDMode mode = world.paperConfig.duplicateUUIDMode;
Improvements to Logging Warnings/Dupe Entities - Resolves #1544 1) Removed "Regen" mode of Dupe UUID resolver, forced safe. Some servers who updated before we had safe mode added still had this value. There's really no reason to keep this mode, as we've seen that vanilla triggers this often and 99.9999999% of cases will be an actual duplicate that needs to be deleted. 2) Made Vanilla Debug messages about dupe UUIDs and dupe uuid resolve messages only show up if the debug.entities flag is on. This will stop server owners from panicing from seeing these logs, and stop opening bug reports on this, only for us to tell you "don't worry about it". 3) Avoid adding entities to world that are already added to world. This can be triggered by anything that causes an entity to be added to the world during the chunk load process, such as chunk conversions. Issue #1544 was a case of this. 4) Removed debug warning about ExpiringMap. Nothing more I know to do about this anyways. We recover from it, stop warning to reduce noise of issues to us.
2018-10-07 18:58:53 +00:00
+ if (mode == DuplicateUUIDMode.WARN || mode == DuplicateUUIDMode.DELETE || mode == DuplicateUUIDMode.SAFE_REGEN) {
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
+ Map<UUID, Entity> thisChunk = new HashMap<>();
+ for (Iterator<Entity> iterator = ((List<Entity>) entityslice).iterator(); iterator.hasNext(); ) {
+ Entity entity = iterator.next();
make dupe uuid saferegen delete range configurable also ensure we never process already valid entities. this shouldnt be possible as of recent commits as we made the entity slice array safer, but doesn't hurt for this logic to be safe too incase that patch got dropped in a future version by accident/necessarily
2018-08-04 04:23:00 +00:00
+ if (entity.dead || entity.valid) continue;
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
+ Entity other = ((WorldServer) world).entitiesByUUID.get(entity.uniqueID);
Fix Dupe UUID logic triggering when the duplicate is pending unload Vanilla logic checks unload queue and overwrites if its in it. we're triggering this if a chunk unloads, and reloads immediately in same tick. Added check for unload queue to not treat as duplicate Also fixed the config setting not even loading
2018-07-28 05:20:06 +00:00
+ if (other == null || other.dead || world.getEntityUnloadQueue().contains(other)) {
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
+ other = thisChunk.get(entity.uniqueID);
+ }
Add "Safe Regen" Duplicate UUID resolver and make default After witnessing behavior of the regeneration logs, its clear that Vanilla has had bugs with saving duplicate entities for a while.... Some entities are saved in multiple chunks, and now we are bringing those duplicates out that use to never surface. This mode will analyze if the entity appears to be a duplicate (near the other dupe uuid) and delete the entity instead. This should reduce regenerations to entities that are nowhere near each other, and therefore more likely to be subject to real UUID collisions due to our previous bug, and therefor should survive the chunk load.
2018-08-03 03:06:03 +00:00
+
+ if (mode == DuplicateUUIDMode.SAFE_REGEN && other != null && !other.dead &&
+ !world.getEntityUnloadQueue().contains(other)
+ && java.util.Objects.equals(other.getSaveID(), entity.getSaveID())
make dupe uuid saferegen delete range configurable also ensure we never process already valid entities. this shouldnt be possible as of recent commits as we made the entity slice array safer, but doesn't hurt for this logic to be safe too incase that patch got dropped in a future version by accident/necessarily
2018-08-04 04:23:00 +00:00
+ && entity.getBukkitEntity().getLocation().distance(other.getBukkitEntity().getLocation()) < world.paperConfig.duplicateUUIDDeleteRange
Add "Safe Regen" Duplicate UUID resolver and make default After witnessing behavior of the regeneration logs, its clear that Vanilla has had bugs with saving duplicate entities for a while.... Some entities are saved in multiple chunks, and now we are bringing those duplicates out that use to never surface. This mode will analyze if the entity appears to be a duplicate (near the other dupe uuid) and delete the entity instead. This should reduce regenerations to entities that are nowhere near each other, and therefore more likely to be subject to real UUID collisions due to our previous bug, and therefor should survive the chunk load.
2018-08-03 03:06:03 +00:00
+ ) {
Improvements to Logging Warnings/Dupe Entities - Resolves #1544 1) Removed "Regen" mode of Dupe UUID resolver, forced safe. Some servers who updated before we had safe mode added still had this value. There's really no reason to keep this mode, as we've seen that vanilla triggers this often and 99.9999999% of cases will be an actual duplicate that needs to be deleted. 2) Made Vanilla Debug messages about dupe UUIDs and dupe uuid resolve messages only show up if the debug.entities flag is on. This will stop server owners from panicing from seeing these logs, and stop opening bug reports on this, only for us to tell you "don't worry about it". 3) Avoid adding entities to world that are already added to world. This can be triggered by anything that causes an entity to be added to the world during the chunk load process, such as chunk conversions. Issue #1544 was a case of this. 4) Removed debug warning about ExpiringMap. Nothing more I know to do about this anyways. We recover from it, stop warning to reduce noise of issues to us.
2018-10-07 18:58:53 +00:00
+ if (World.DEBUG_ENTITIES) logger.warn("[DUPE-UUID] Duplicate UUID found used by " + other + ", deleted entity " + entity + " because it was near the duplicate and likely an actual duplicate. See https://github.com/PaperMC/Paper/issues/1223 for discussion on what this is about.");
Add "Safe Regen" Duplicate UUID resolver and make default After witnessing behavior of the regeneration logs, its clear that Vanilla has had bugs with saving duplicate entities for a while.... Some entities are saved in multiple chunks, and now we are bringing those duplicates out that use to never surface. This mode will analyze if the entity appears to be a duplicate (near the other dupe uuid) and delete the entity instead. This should reduce regenerations to entities that are nowhere near each other, and therefore more likely to be subject to real UUID collisions due to our previous bug, and therefor should survive the chunk load.
2018-08-03 03:06:03 +00:00
+ entity.die();
Fix some false positive warnings printing that shouldnt be reduces some log spam
2018-08-21 00:20:40 +00:00
+ iterator.remove();
Add "Safe Regen" Duplicate UUID resolver and make default After witnessing behavior of the regeneration logs, its clear that Vanilla has had bugs with saving duplicate entities for a while.... Some entities are saved in multiple chunks, and now we are bringing those duplicates out that use to never surface. This mode will analyze if the entity appears to be a duplicate (near the other dupe uuid) and delete the entity instead. This should reduce regenerations to entities that are nowhere near each other, and therefore more likely to be subject to real UUID collisions due to our previous bug, and therefor should survive the chunk load.
2018-08-03 03:06:03 +00:00
+ continue;
+ }
Fix Dupe UUID logic triggering when the duplicate is pending unload Vanilla logic checks unload queue and overwrites if its in it. we're triggering this if a chunk unloads, and reloads immediately in same tick. Added check for unload queue to not treat as duplicate Also fixed the config setting not even loading
2018-07-28 05:20:06 +00:00
+ if (other != null && !other.dead) {
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
+ switch (mode) {
Improvements to Logging Warnings/Dupe Entities - Resolves #1544 1) Removed "Regen" mode of Dupe UUID resolver, forced safe. Some servers who updated before we had safe mode added still had this value. There's really no reason to keep this mode, as we've seen that vanilla triggers this often and 99.9999999% of cases will be an actual duplicate that needs to be deleted. 2) Made Vanilla Debug messages about dupe UUIDs and dupe uuid resolve messages only show up if the debug.entities flag is on. This will stop server owners from panicing from seeing these logs, and stop opening bug reports on this, only for us to tell you "don't worry about it". 3) Avoid adding entities to world that are already added to world. This can be triggered by anything that causes an entity to be added to the world during the chunk load process, such as chunk conversions. Issue #1544 was a case of this. 4) Removed debug warning about ExpiringMap. Nothing more I know to do about this anyways. We recover from it, stop warning to reduce noise of issues to us.
2018-10-07 18:58:53 +00:00
+ case SAFE_REGEN: {
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
+ entity.setUUID(UUID.randomUUID());
Improvements to Logging Warnings/Dupe Entities - Resolves #1544 1) Removed "Regen" mode of Dupe UUID resolver, forced safe. Some servers who updated before we had safe mode added still had this value. There's really no reason to keep this mode, as we've seen that vanilla triggers this often and 99.9999999% of cases will be an actual duplicate that needs to be deleted. 2) Made Vanilla Debug messages about dupe UUIDs and dupe uuid resolve messages only show up if the debug.entities flag is on. This will stop server owners from panicing from seeing these logs, and stop opening bug reports on this, only for us to tell you "don't worry about it". 3) Avoid adding entities to world that are already added to world. This can be triggered by anything that causes an entity to be added to the world during the chunk load process, such as chunk conversions. Issue #1544 was a case of this. 4) Removed debug warning about ExpiringMap. Nothing more I know to do about this anyways. We recover from it, stop warning to reduce noise of issues to us.
2018-10-07 18:58:53 +00:00
+ if (World.DEBUG_ENTITIES) logger.warn("[DUPE-UUID] Duplicate UUID found used by " + other + ", regenerated UUID for " + entity + ". See https://github.com/PaperMC/Paper/issues/1223 for discussion on what this is about.");
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
+ break;
+ }
+ case DELETE: {
Improvements to Logging Warnings/Dupe Entities - Resolves #1544 1) Removed "Regen" mode of Dupe UUID resolver, forced safe. Some servers who updated before we had safe mode added still had this value. There's really no reason to keep this mode, as we've seen that vanilla triggers this often and 99.9999999% of cases will be an actual duplicate that needs to be deleted. 2) Made Vanilla Debug messages about dupe UUIDs and dupe uuid resolve messages only show up if the debug.entities flag is on. This will stop server owners from panicing from seeing these logs, and stop opening bug reports on this, only for us to tell you "don't worry about it". 3) Avoid adding entities to world that are already added to world. This can be triggered by anything that causes an entity to be added to the world during the chunk load process, such as chunk conversions. Issue #1544 was a case of this. 4) Removed debug warning about ExpiringMap. Nothing more I know to do about this anyways. We recover from it, stop warning to reduce noise of issues to us.
2018-10-07 18:58:53 +00:00
+ if (World.DEBUG_ENTITIES) logger.warn("[DUPE-UUID] Duplicate UUID found used by " + other + ", deleted entity " + entity + ". See https://github.com/PaperMC/Paper/issues/1223 for discussion on what this is about.");
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
+ entity.die();
+ iterator.remove();
+ break;
+ }
Fix Dupe UUID logic triggering when the duplicate is pending unload Vanilla logic checks unload queue and overwrites if its in it. we're triggering this if a chunk unloads, and reloads immediately in same tick. Added check for unload queue to not treat as duplicate Also fixed the config setting not even loading
2018-07-28 05:20:06 +00:00
+ default:
Improvements to Logging Warnings/Dupe Entities - Resolves #1544 1) Removed "Regen" mode of Dupe UUID resolver, forced safe. Some servers who updated before we had safe mode added still had this value. There's really no reason to keep this mode, as we've seen that vanilla triggers this often and 99.9999999% of cases will be an actual duplicate that needs to be deleted. 2) Made Vanilla Debug messages about dupe UUIDs and dupe uuid resolve messages only show up if the debug.entities flag is on. This will stop server owners from panicing from seeing these logs, and stop opening bug reports on this, only for us to tell you "don't worry about it". 3) Avoid adding entities to world that are already added to world. This can be triggered by anything that causes an entity to be added to the world during the chunk load process, such as chunk conversions. Issue #1544 was a case of this. 4) Removed debug warning about ExpiringMap. Nothing more I know to do about this anyways. We recover from it, stop warning to reduce noise of issues to us.
2018-10-07 18:58:53 +00:00
+ if (World.DEBUG_ENTITIES) logger.warn("[DUPE-UUID] Duplicate UUID found used by " + other + ", doing nothing to " + entity + ". See https://github.com/PaperMC/Paper/issues/1223 for discussion on what this is about.");
Fix Dupe UUID logic triggering when the duplicate is pending unload Vanilla logic checks unload queue and overwrites if its in it. we're triggering this if a chunk unloads, and reloads immediately in same tick. Added check for unload queue to not treat as duplicate Also fixed the config setting not even loading
2018-07-28 05:20:06 +00:00
+ break;
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
+ }
+ }
+ thisChunk.put(entity.uniqueID, entity);
+ }
+ }
+ // Paper end
Updated Upstream (Bukkit/CraftBukkit/Spigot) Developers!: You will need to clean up your work/Minecraft/1.13.2 folder for this Upstream has released updates that appears to apply and compile correctly. This update has not been tested by PaperMC and as with ANY update, please do your own testing Bukkit Changes: b850a822 SPIGOT-4526: Add conversion time API for Zombie & subclasses CraftBukkit Changes: 38cf676e SPIGOT-4534: CreatureSpawnEvent not being called for CHUNK_GEN b446cb5d SPIGOT-4527: Fix sponges with waterlogged blocks 6ec8ea5c SPIGOT-4526: Add conversion time API for Zombie & subclasses c64fe508 Mappings Update a3c2ec03 Fix missing ServerListPingEvent call for legacy pings Spigot Changes: 1dc156ce Rebuild patches 140f654d Mappings Update
2018-12-17 05:18:06 +00:00
List<Entity> toRemove = new LinkedList<>();
Paper 1.13.1 Update Updated Upstream (Bukkit/CraftBukkit/Spigot) Bukkit Changes: 2dcc44dc SPIGOT-4307: Fix hacky API for banners on shields e0fc6572 SPIGOT-4309: Add "forced" display of particles efeeab2f Add index to README.md for easier navigation f502bc6f Update to Minecraft 1.13.1 CraftBukkit Changes: d0bb0a1d Fix some tests randomly failing 997d378d Fix client stall in specific teleportation scenarios b3dc2366 SPIGOT-4307: Fix hacky API for banners on shields 2a271162 SPIGOT-4301: Fix more invalid enchants 5d0d83bb SPIGOT-4309: Add "forced" display of particles a6772578 Add additional tests for CraftBlockData ce1af0c3 Update to Minecraft 1.13.1 Spigot Changes: 2440e189 Rebuild patches 4ecffced Update to Minecraft 1.13.1
2018-08-26 18:11:49 +00:00
this.world.a(entityslice.stream().filter((entity) -> {
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
diff --git a/src/main/java/net/minecraft/server/Entity.java b/src/main/java/net/minecraft/server/Entity.java
Updated Upstream (Bukkit/CraftBukkit/Spigot) Developers!: You will need to clean up your work/Minecraft/1.13.2 folder for this Upstream has released updates that appears to apply and compile correctly. This update has not been tested by PaperMC and as with ANY update, please do your own testing Bukkit Changes: b850a822 SPIGOT-4526: Add conversion time API for Zombie & subclasses CraftBukkit Changes: 38cf676e SPIGOT-4534: CreatureSpawnEvent not being called for CHUNK_GEN b446cb5d SPIGOT-4527: Fix sponges with waterlogged blocks 6ec8ea5c SPIGOT-4526: Add conversion time API for Zombie & subclasses c64fe508 Mappings Update a3c2ec03 Fix missing ServerListPingEvent call for legacy pings Spigot Changes: 1dc156ce Rebuild patches 140f654d Mappings Update
2018-12-17 05:18:06 +00:00
index 1581edc4a..07cd5aa28 100644
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
--- a/src/main/java/net/minecraft/server/Entity.java
+++ b/src/main/java/net/minecraft/server/Entity.java
Updated Upstream (Bukkit/CraftBukkit/Spigot) Developers!: You will need to clean up your work/Minecraft/1.13.2 folder for this Upstream has released updates that appears to apply and compile correctly. This update has not been tested by PaperMC and as with ANY update, please do your own testing Bukkit Changes: b850a822 SPIGOT-4526: Add conversion time API for Zombie & subclasses CraftBukkit Changes: 38cf676e SPIGOT-4534: CreatureSpawnEvent not being called for CHUNK_GEN b446cb5d SPIGOT-4527: Fix sponges with waterlogged blocks 6ec8ea5c SPIGOT-4526: Add conversion time API for Zombie & subclasses c64fe508 Mappings Update a3c2ec03 Fix missing ServerListPingEvent call for legacy pings Spigot Changes: 1dc156ce Rebuild patches 140f654d Mappings Update
2018-12-17 05:18:06 +00:00
@@ -2722,6 +2722,7 @@ public abstract class Entity implements INamableTileEntity, ICommandListener, Ke
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
});
}
+ public void setUUID(UUID uuid) { a(uuid); } // Paper - OBFHELPER
public void a(UUID uuid) {
this.uniqueID = uuid;
Rebuild patches for upstream merge
2018-07-21 20:43:00 +00:00
this.au = this.uniqueID.toString();
Fix Dupe UUID logic triggering when the duplicate is pending unload Vanilla logic checks unload queue and overwrites if its in it. we're triggering this if a chunk unloads, and reloads immediately in same tick. Added check for unload queue to not treat as duplicate Also fixed the config setting not even loading
2018-07-28 05:20:06 +00:00
diff --git a/src/main/java/net/minecraft/server/World.java b/src/main/java/net/minecraft/server/World.java
Updated Upstream (Bukkit/CraftBukkit/Spigot) Developers!: You will need to clean up your work/Minecraft/1.13.2 folder for this Upstream has released updates that appears to apply and compile correctly. This update has not been tested by PaperMC and as with ANY update, please do your own testing Bukkit Changes: b850a822 SPIGOT-4526: Add conversion time API for Zombie & subclasses CraftBukkit Changes: 38cf676e SPIGOT-4534: CreatureSpawnEvent not being called for CHUNK_GEN b446cb5d SPIGOT-4527: Fix sponges with waterlogged blocks 6ec8ea5c SPIGOT-4526: Add conversion time API for Zombie & subclasses c64fe508 Mappings Update a3c2ec03 Fix missing ServerListPingEvent call for legacy pings Spigot Changes: 1dc156ce Rebuild patches 140f654d Mappings Update
2018-12-17 05:18:06 +00:00
index 67ef109a5..66d2026d0 100644
Fix Dupe UUID logic triggering when the duplicate is pending unload Vanilla logic checks unload queue and overwrites if its in it. we're triggering this if a chunk unloads, and reloads immediately in same tick. Added check for unload queue to not treat as duplicate Also fixed the config setting not even loading
2018-07-28 05:20:06 +00:00
--- a/src/main/java/net/minecraft/server/World.java
+++ b/src/main/java/net/minecraft/server/World.java
Paper 1.13.1 Update Updated Upstream (Bukkit/CraftBukkit/Spigot) Bukkit Changes: 2dcc44dc SPIGOT-4307: Fix hacky API for banners on shields e0fc6572 SPIGOT-4309: Add "forced" display of particles efeeab2f Add index to README.md for easier navigation f502bc6f Update to Minecraft 1.13.1 CraftBukkit Changes: d0bb0a1d Fix some tests randomly failing 997d378d Fix client stall in specific teleportation scenarios b3dc2366 SPIGOT-4307: Fix hacky API for banners on shields 2a271162 SPIGOT-4301: Fix more invalid enchants 5d0d83bb SPIGOT-4309: Add "forced" display of particles a6772578 Add additional tests for CraftBlockData ce1af0c3 Update to Minecraft 1.13.1 Spigot Changes: 2440e189 Rebuild patches 4ecffced Update to Minecraft 1.13.1
2018-08-26 18:11:49 +00:00
@@ -75,7 +75,7 @@ public abstract class World implements IEntityAccess, GeneratorAccess, IIBlockAc
Fix Dupe UUID logic triggering when the duplicate is pending unload Vanilla logic checks unload queue and overwrites if its in it. we're triggering this if a chunk unloads, and reloads immediately in same tick. Added check for unload queue to not treat as duplicate Also fixed the config setting not even loading
2018-07-28 05:20:06 +00:00
}
};
// Spigot end
Paper 1.13.1 Update Updated Upstream (Bukkit/CraftBukkit/Spigot) Bukkit Changes: 2dcc44dc SPIGOT-4307: Fix hacky API for banners on shields e0fc6572 SPIGOT-4309: Add "forced" display of particles efeeab2f Add index to README.md for easier navigation f502bc6f Update to Minecraft 1.13.1 CraftBukkit Changes: d0bb0a1d Fix some tests randomly failing 997d378d Fix client stall in specific teleportation scenarios b3dc2366 SPIGOT-4307: Fix hacky API for banners on shields 2a271162 SPIGOT-4301: Fix more invalid enchants 5d0d83bb SPIGOT-4309: Add "forced" display of particles a6772578 Add additional tests for CraftBlockData ce1af0c3 Update to Minecraft 1.13.1 Spigot Changes: 2440e189 Rebuild patches 4ecffced Update to Minecraft 1.13.1
2018-08-26 18:11:49 +00:00
- protected final Set<Entity> g = com.google.common.collect.Sets.newHashSet(); // Paper
+ protected final Set<Entity> g = com.google.common.collect.Sets.newHashSet(); public Set<Entity> getEntityUnloadQueue() { return g; };// Paper - OBFHELPER
Fix Dupe UUID logic triggering when the duplicate is pending unload Vanilla logic checks unload queue and overwrites if its in it. we're triggering this if a chunk unloads, and reloads immediately in same tick. Added check for unload queue to not treat as duplicate Also fixed the config setting not even loading
2018-07-28 05:20:06 +00:00
//public final List<TileEntity> tileEntityList = Lists.newArrayList(); // Paper - remove unused list
public final List<TileEntity> tileEntityListTick = Lists.newArrayList();
Merge branch 'master' into pre/1.13 * master: Fix Dupe UUID logic triggering when the duplicate is pending unload
2018-07-28 05:59:20 +00:00
private final List<TileEntity> c = Lists.newArrayList();
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
diff --git a/src/main/java/net/minecraft/server/WorldServer.java b/src/main/java/net/minecraft/server/WorldServer.java
Updated Upstream (Bukkit/CraftBukkit/Spigot) Developers!: You will need to clean up your work/Minecraft/1.13.2 folder for this Upstream has released updates that appears to apply and compile correctly. This update has not been tested by PaperMC and as with ANY update, please do your own testing Bukkit Changes: b850a822 SPIGOT-4526: Add conversion time API for Zombie & subclasses CraftBukkit Changes: 38cf676e SPIGOT-4534: CreatureSpawnEvent not being called for CHUNK_GEN b446cb5d SPIGOT-4527: Fix sponges with waterlogged blocks 6ec8ea5c SPIGOT-4526: Add conversion time API for Zombie & subclasses c64fe508 Mappings Update a3c2ec03 Fix missing ServerListPingEvent call for legacy pings Spigot Changes: 1dc156ce Rebuild patches 140f654d Mappings Update
2018-12-17 05:18:06 +00:00
index f37e85eb0..af9cdd9dc 100644
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
--- a/src/main/java/net/minecraft/server/WorldServer.java
+++ b/src/main/java/net/minecraft/server/WorldServer.java
Paper 1.13.1 Update Updated Upstream (Bukkit/CraftBukkit/Spigot) Bukkit Changes: 2dcc44dc SPIGOT-4307: Fix hacky API for banners on shields e0fc6572 SPIGOT-4309: Add "forced" display of particles efeeab2f Add index to README.md for easier navigation f502bc6f Update to Minecraft 1.13.1 CraftBukkit Changes: d0bb0a1d Fix some tests randomly failing 997d378d Fix client stall in specific teleportation scenarios b3dc2366 SPIGOT-4307: Fix hacky API for banners on shields 2a271162 SPIGOT-4301: Fix more invalid enchants 5d0d83bb SPIGOT-4309: Add "forced" display of particles a6772578 Add additional tests for CraftBlockData ce1af0c3 Update to Minecraft 1.13.1 Spigot Changes: 2440e189 Rebuild patches 4ecffced Update to Minecraft 1.13.1
2018-08-26 18:11:49 +00:00
@@ -41,7 +41,7 @@ public class WorldServer extends World implements IAsyncTaskHandler {
Rebuild patches for upstream merge
2018-07-21 20:43:00 +00:00
private final MinecraftServer server;
public EntityTracker tracker;
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
private final PlayerChunkMap manager;
- private final Map<UUID, Entity> entitiesByUUID = Maps.newHashMap();
+ public final Map<UUID, Entity> entitiesByUUID = Maps.newHashMap(); // Paper
public boolean savingDisabled;
Paper 1.13.1 Update Updated Upstream (Bukkit/CraftBukkit/Spigot) Bukkit Changes: 2dcc44dc SPIGOT-4307: Fix hacky API for banners on shields e0fc6572 SPIGOT-4309: Add "forced" display of particles efeeab2f Add index to README.md for easier navigation f502bc6f Update to Minecraft 1.13.1 CraftBukkit Changes: d0bb0a1d Fix some tests randomly failing 997d378d Fix client stall in specific teleportation scenarios b3dc2366 SPIGOT-4307: Fix hacky API for banners on shields 2a271162 SPIGOT-4301: Fix more invalid enchants 5d0d83bb SPIGOT-4309: Add "forced" display of particles a6772578 Add additional tests for CraftBlockData ce1af0c3 Update to Minecraft 1.13.1 Spigot Changes: 2440e189 Rebuild patches 4ecffced Update to Minecraft 1.13.1
2018-08-26 18:11:49 +00:00
private boolean J;
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
private int emptyTime;
Updated Upstream (Bukkit/CraftBukkit/Spigot) Developers!: You will need to clean up your work/Minecraft/1.13.2 folder for this Upstream has released updates that appears to apply and compile correctly. This update has not been tested by PaperMC and as with ANY update, please do your own testing Bukkit Changes: b850a822 SPIGOT-4526: Add conversion time API for Zombie & subclasses CraftBukkit Changes: 38cf676e SPIGOT-4534: CreatureSpawnEvent not being called for CHUNK_GEN b446cb5d SPIGOT-4527: Fix sponges with waterlogged blocks 6ec8ea5c SPIGOT-4526: Add conversion time API for Zombie & subclasses c64fe508 Mappings Update a3c2ec03 Fix missing ServerListPingEvent call for legacy pings Spigot Changes: 1dc156ce Rebuild patches 140f654d Mappings Update
2018-12-17 05:18:06 +00:00
@@ -995,7 +995,7 @@ public class WorldServer extends World implements IAsyncTaskHandler {
Rebuild patches for upstream merge
2018-07-21 20:43:00 +00:00
this.g.remove(entity1);
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
} else {
if (!(entity instanceof EntityHuman)) {
- if (DEBUG_ENTITIES) {
Improvements to Logging Warnings/Dupe Entities - Resolves #1544 1) Removed "Regen" mode of Dupe UUID resolver, forced safe. Some servers who updated before we had safe mode added still had this value. There's really no reason to keep this mode, as we've seen that vanilla triggers this often and 99.9999999% of cases will be an actual duplicate that needs to be deleted. 2) Made Vanilla Debug messages about dupe UUIDs and dupe uuid resolve messages only show up if the debug.entities flag is on. This will stop server owners from panicing from seeing these logs, and stop opening bug reports on this, only for us to tell you "don't worry about it". 3) Avoid adding entities to world that are already added to world. This can be triggered by anything that causes an entity to be added to the world during the chunk load process, such as chunk conversions. Issue #1544 was a case of this. 4) Removed debug warning about ExpiringMap. Nothing more I know to do about this anyways. We recover from it, stop warning to reduce noise of issues to us.
2018-10-07 18:58:53 +00:00
+ if (DEBUG_ENTITIES && entity.world.paperConfig.duplicateUUIDMode != com.destroystokyo.paper.PaperWorldConfig.DuplicateUUIDMode.NOTHING) {
WorldServer.a.error("Keeping entity {} that already exists with UUID {}", entity1, uuid.toString()); // CraftBukkit // Paper
WorldServer.a.error("Deleting duplicate entity {}", entity); // Paper
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
Updated Upstream (Bukkit/CraftBukkit/Spigot) Developers!: You will need to clean up your work/Minecraft/1.13.2 folder for this Upstream has released updates that appears to apply and compile correctly. This update has not been tested by PaperMC and as with ANY update, please do your own testing Bukkit Changes: b850a822 SPIGOT-4526: Add conversion time API for Zombie & subclasses CraftBukkit Changes: 38cf676e SPIGOT-4534: CreatureSpawnEvent not being called for CHUNK_GEN b446cb5d SPIGOT-4527: Fix sponges with waterlogged blocks 6ec8ea5c SPIGOT-4526: Add conversion time API for Zombie & subclasses c64fe508 Mappings Update a3c2ec03 Fix missing ServerListPingEvent call for legacy pings Spigot Changes: 1dc156ce Rebuild patches 140f654d Mappings Update
2018-12-17 05:18:06 +00:00
@@ -1026,7 +1026,7 @@ public class WorldServer extends World implements IAsyncTaskHandler {
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
}
Rebuild patches for upstream merge
2018-07-21 20:43:00 +00:00
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00
Entity old = this.entitiesByUUID.put(entity.getUniqueID(), entity);
- if (old != null && old.getId() != entity.getId() && old.valid) {
+ if (old != null && old.getId() != entity.getId() && old.valid && entity.world.paperConfig.duplicateUUIDMode != com.destroystokyo.paper.PaperWorldConfig.DuplicateUUIDMode.NOTHING) {
Logger logger = LogManager.getLogger();
logger.error("Overwrote an existing entity " + old + " with " + entity);
if (DEBUG_ENTITIES) {
--
Modified Configurable Chunk Inhabited Timer Patch Replaces the "use-chunk-inhabited-timer" config option with the options "use-fixed-chunk-inhabited-time" and "fixed-chunk-inhabited-time". When using "use-fixed-chunk-inhabited-time=false" everything will be the same like it was with "use-chunk-inhabited-timer=true". When using "use-fixed-chunk-inhabited-time=true" and "fixed-chunk-inhabited-time=0" everything will be the same like it was with "use-chunk-inhabited-timer=false". Instead of just using 0 when all chunks should be treated equally this allows to fine-tune vanilla gameplay.
2018-12-13 00:40:29 +00:00
2.20.0
Duplicate UUID Resolve Option Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24 which was added all the way back in March of 2016, it was unknown (potentially not at the time) that an entity might actually change the seed of the random object. At some point, EntitySquid did start setting the seed. Due to this shared random, this caused every entity to use a Random object with a predictable seed. This has caused entities to potentially generate with the same UUID.... Over the years, servers have had entities disappear, but no sign of trouble because CraftBukkit removed the log lines indicating that something was wrong. We have fixed the root issue causing duplicate UUID's, however we now have chunk files full of entities that have the same UUID as another entity! When these chunks load, the 2nd entity will not be added to the world correctly. If that chunk loads in a different order in the future, then it will reverse and the missing one is now the one added to the world and not the other. This results in very inconsistent entity behavior. This change allows you to recover any duplicate entity by generating a new UUID for it. This also lets you delete them instead if you don't want to risk having new entities added to the world that you previously did not see. But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options. It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
2018-07-21 18:47:05 +00:00