SteamWar/Paper
13
0
Fork 0
geforkt von Mirrors/Paper
Code Issues Pull-Requests 1 Projekte Releases Wiki Aktivität
550e5f8eaf
Paper/removed/1.14/0293-Duplicate-UUID-Resolve-Option.patch

224 Zeilen
12 KiB
Diff
Originalformat Normale Ansicht Verlauf

Updated Upstream (Bukkit/CraftBukkit) 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: da08d022 SPIGOT-4700: Add PlayerFishEvent.State.REEL_IN 0cef14e4 Remove draft API from selectEntities CraftBukkit Changes: a46fdbc6 Remove outdated build delay. 3697519b SPIGOT-4708: Fix ExactChoice recipes neglecting material 9ead7009 SPIGOT-4677: Add minecraft.admin.command_feedback permission c3749a23 Remove the Damage tag from items when it is 0. f74c7b95 SPIGOT-4706: Can't interact with active item 494eef45 Mention requirement of JIRA ticket for bug fixes 51d62dec SPIGOT-4702: Exception when middle clicking certain slots be557e69 SPIGOT-4700: Add PlayerFishEvent.State.REEL_IN
2019-04-22 23:36:14 +02:00
From d4952e11a8163210b2a750f4c22b03b57a118632 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 20:47:05 +02: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
Updated Upstream (Bukkit/CraftBukkit) 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: da08d022 SPIGOT-4700: Add PlayerFishEvent.State.REEL_IN 0cef14e4 Remove draft API from selectEntities CraftBukkit Changes: a46fdbc6 Remove outdated build delay. 3697519b SPIGOT-4708: Fix ExactChoice recipes neglecting material 9ead7009 SPIGOT-4677: Add minecraft.admin.command_feedback permission c3749a23 Remove the Damage tag from items when it is 0. f74c7b95 SPIGOT-4706: Can't interact with active item 494eef45 Mention requirement of JIRA ticket for bug fixes 51d62dec SPIGOT-4702: Exception when middle clicking certain slots be557e69 SPIGOT-4700: Add PlayerFishEvent.State.REEL_IN
2019-04-22 23:36:14 +02:00
index f5b2e88f3b..8c4ff18868 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 20:47:05 +02:00
--- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
Default nether void damage to off and allow that
2019-04-05 07:27:37 +02:00
@@ -463,4 +463,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 20:47:05 +02: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 20:58:53 +02: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 20:47:05 +02: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 05:06:03 +02: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 06:23:00 +02: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 07:20:06 +02: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 05:06:03 +02: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 06:23:00 +02: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 20:47:05 +02: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 20:58:53 +02: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 05:06:03 +02: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 20:58:53 +02: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 20:47:05 +02: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 20:58:53 +02: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 20:47:05 +02: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) 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: da08d022 SPIGOT-4700: Add PlayerFishEvent.State.REEL_IN 0cef14e4 Remove draft API from selectEntities CraftBukkit Changes: a46fdbc6 Remove outdated build delay. 3697519b SPIGOT-4708: Fix ExactChoice recipes neglecting material 9ead7009 SPIGOT-4677: Add minecraft.admin.command_feedback permission c3749a23 Remove the Damage tag from items when it is 0. f74c7b95 SPIGOT-4706: Can't interact with active item 494eef45 Mention requirement of JIRA ticket for bug fixes 51d62dec SPIGOT-4702: Exception when middle clicking certain slots be557e69 SPIGOT-4700: Add PlayerFishEvent.State.REEL_IN
2019-04-22 23:36:14 +02:00
index c2f12f92b0..e8c06e01b4 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 20:47:05 +02: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 22:43:00 +02:00
import com.google.common.collect.Queues;
Updated Upstream (Bukkit/CraftBukkit/Spigot) 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 Warning: this commit contains more mapping changes from upstream, As always, ensure that you have working backups and test this build before deployment; Developers working on paper will, yet again, need to delete their work/Minecraft/1.13.2 folder Bukkit Changes: 7fca5fd4 SPIGOT-4558: Preserve user order in the face of copied defaults in configurations 15c9b1eb Ignore spurious slot IDs sent by client, e.g. in enchanting tables 5d2a10c5 SPIGOT-3747: Add API for force loaded chunks d6dd2bb3 SPIGOT-3538: Add getHitBlockFace for ProjectileHitEvent 771db4aa SPIGOT-794: Call EntityPlaceEvent for Minecart placement 55462509 Add InventoryView#getSlotType 2f3ce5b6 Remove EntityTransformEvent and CustomItemTagContainer from draft API f04ad7b6 Make ProjectileLaunchEvent extend EntitySpawnEvent ccb85808 Define EntitySpawnEvent b8cc3ebe Add PlayerItemDamageEvent 184a495d Ease ClassLoader Deadlocks Where Possible 11ac4728 Expand Boolean Prompt Values in Conversation API aae62d51 Added getAllSessionData() to the Conversation API. 9290ff91 Add InventoryView#getInventory API 995e530f Add API to get / set base arrow damage CraftBukkit Changes: c4a67eed SPIGOT-4556: Fix plugins closing inventory during drop events 5be2ddcb Replace version constants with methods to prevent compiler inlining a5b9c7b3 Use API method to create offset command completions 2bc7d1df SPIGOT-3747: Add API for force loaded chunks a408f375 SPIGOT-3538: Add getHitBlockFace for ProjectileHitEvent b54b9409 SPIGOT-2864: Make Arrow / Item setTicksLived behave like FallingBlock 79ded7a8 SPIGOT-1811: Death message not shown on respawn screen b4a4f15d SPIGOT-943: InventoryCloseEvent called on death regardless of open inventory 0afed592 SPIGOT-794: Call EntityPlaceEvent for Minecart placement 2b2d084a Add InventoryView#getSlotType 01a9959a Do not use deprecated ItemSpawnEvent constructor 9642498d SPIGOT-4547: Call EntitySpawnEvent as general spawn fallback event 963f4a5f Add PlayerItemDamageEvent 63db0445 Add API to get / set base arrow damage 531c25d7 Add CraftMagicNumbers.MAPPINGS_VERSION for use by NMS plugins d05c8b14 Mappings Update bd36e200 SPIGOT-4551: Ignore invalid attribute modifier slots Spigot Changes: 518206a1 Remove redundant trove depend 1959ad21 MC-11211,SPIGOT-4552: Fix placing double slabs at y = 255 29ab5e43 SPIGOT-3661: Allow arguments in restart-script 7cc46316 SPIGOT-852: Growth modifiers for beetroots, potatoes, carrots 82e117e1 Squelch "fatal: Resolve operation not in progress" message 0a1a68e7 Mappings Update & Patch Rebuild
2019-01-01 04:15:55 +01:00
@@ -41,6 +46,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 20:47:05 +02:00
public final World world;
Rebuild patches for upstream merge
2018-07-21 22:43:00 +02: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 20:47:05 +02: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 06:56:20 +02:00
private boolean l;
Updated Upstream (Bukkit/CraftBukkit/Spigot) 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 Warning: this commit contains more mapping changes from upstream, As always, ensure that you have working backups and test this build before deployment; Developers working on paper will, yet again, need to delete their work/Minecraft/1.13.2 folder Bukkit Changes: 7fca5fd4 SPIGOT-4558: Preserve user order in the face of copied defaults in configurations 15c9b1eb Ignore spurious slot IDs sent by client, e.g. in enchanting tables 5d2a10c5 SPIGOT-3747: Add API for force loaded chunks d6dd2bb3 SPIGOT-3538: Add getHitBlockFace for ProjectileHitEvent 771db4aa SPIGOT-794: Call EntityPlaceEvent for Minecart placement 55462509 Add InventoryView#getSlotType 2f3ce5b6 Remove EntityTransformEvent and CustomItemTagContainer from draft API f04ad7b6 Make ProjectileLaunchEvent extend EntitySpawnEvent ccb85808 Define EntitySpawnEvent b8cc3ebe Add PlayerItemDamageEvent 184a495d Ease ClassLoader Deadlocks Where Possible 11ac4728 Expand Boolean Prompt Values in Conversation API aae62d51 Added getAllSessionData() to the Conversation API. 9290ff91 Add InventoryView#getInventory API 995e530f Add API to get / set base arrow damage CraftBukkit Changes: c4a67eed SPIGOT-4556: Fix plugins closing inventory during drop events 5be2ddcb Replace version constants with methods to prevent compiler inlining a5b9c7b3 Use API method to create offset command completions 2bc7d1df SPIGOT-3747: Add API for force loaded chunks a408f375 SPIGOT-3538: Add getHitBlockFace for ProjectileHitEvent b54b9409 SPIGOT-2864: Make Arrow / Item setTicksLived behave like FallingBlock 79ded7a8 SPIGOT-1811: Death message not shown on respawn screen b4a4f15d SPIGOT-943: InventoryCloseEvent called on death regardless of open inventory 0afed592 SPIGOT-794: Call EntityPlaceEvent for Minecart placement 2b2d084a Add InventoryView#getSlotType 01a9959a Do not use deprecated ItemSpawnEvent constructor 9642498d SPIGOT-4547: Call EntitySpawnEvent as general spawn fallback event 963f4a5f Add PlayerItemDamageEvent 63db0445 Add API to get / set base arrow damage 531c25d7 Add CraftMagicNumbers.MAPPINGS_VERSION for use by NMS plugins d05c8b14 Mappings Update bd36e200 SPIGOT-4551: Ignore invalid attribute modifier slots Spigot Changes: 518206a1 Remove redundant trove depend 1959ad21 MC-11211,SPIGOT-4552: Fix placing double slabs at y = 255 29ab5e43 SPIGOT-3661: Allow arguments in restart-script 7cc46316 SPIGOT-852: Growth modifiers for beetroots, potatoes, carrots 82e117e1 Squelch "fatal: Resolve operation not in progress" message 0a1a68e7 Mappings Update & Patch Rebuild
2019-01-01 04:15:55 +01:00
@@ -691,6 +697,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 20:47:05 +02: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 11:09:55 +01: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 20:47:05 +02:00
entity.die();
+ return; // Paper
}
int k = MathHelper.floor(entity.locY / 16.0D);
Updated Upstream (Bukkit/CraftBukkit/Spigot) 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 Warning: this commit contains more mapping changes from upstream, As always, ensure that you have working backups and test this build before deployment; Developers working on paper will, yet again, need to delete their work/Minecraft/1.13.2 folder Bukkit Changes: 7fca5fd4 SPIGOT-4558: Preserve user order in the face of copied defaults in configurations 15c9b1eb Ignore spurious slot IDs sent by client, e.g. in enchanting tables 5d2a10c5 SPIGOT-3747: Add API for force loaded chunks d6dd2bb3 SPIGOT-3538: Add getHitBlockFace for ProjectileHitEvent 771db4aa SPIGOT-794: Call EntityPlaceEvent for Minecart placement 55462509 Add InventoryView#getSlotType 2f3ce5b6 Remove EntityTransformEvent and CustomItemTagContainer from draft API f04ad7b6 Make ProjectileLaunchEvent extend EntitySpawnEvent ccb85808 Define EntitySpawnEvent b8cc3ebe Add PlayerItemDamageEvent 184a495d Ease ClassLoader Deadlocks Where Possible 11ac4728 Expand Boolean Prompt Values in Conversation API aae62d51 Added getAllSessionData() to the Conversation API. 9290ff91 Add InventoryView#getInventory API 995e530f Add API to get / set base arrow damage CraftBukkit Changes: c4a67eed SPIGOT-4556: Fix plugins closing inventory during drop events 5be2ddcb Replace version constants with methods to prevent compiler inlining a5b9c7b3 Use API method to create offset command completions 2bc7d1df SPIGOT-3747: Add API for force loaded chunks a408f375 SPIGOT-3538: Add getHitBlockFace for ProjectileHitEvent b54b9409 SPIGOT-2864: Make Arrow / Item setTicksLived behave like FallingBlock 79ded7a8 SPIGOT-1811: Death message not shown on respawn screen b4a4f15d SPIGOT-943: InventoryCloseEvent called on death regardless of open inventory 0afed592 SPIGOT-794: Call EntityPlaceEvent for Minecart placement 2b2d084a Add InventoryView#getSlotType 01a9959a Do not use deprecated ItemSpawnEvent constructor 9642498d SPIGOT-4547: Call EntitySpawnEvent as general spawn fallback event 963f4a5f Add PlayerItemDamageEvent 63db0445 Add API to get / set base arrow damage 531c25d7 Add CraftMagicNumbers.MAPPINGS_VERSION for use by NMS plugins d05c8b14 Mappings Update bd36e200 SPIGOT-4551: Ignore invalid attribute modifier slots Spigot Changes: 518206a1 Remove redundant trove depend 1959ad21 MC-11211,SPIGOT-4552: Fix placing double slabs at y = 255 29ab5e43 SPIGOT-3661: Allow arguments in restart-script 7cc46316 SPIGOT-852: Growth modifiers for beetroots, potatoes, carrots 82e117e1 Squelch "fatal: Resolve operation not in progress" message 0a1a68e7 Mappings Update & Patch Rebuild
2019-01-01 04:15:55 +01:00
@@ -879,6 +886,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 20:47:05 +02: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 06:18:06 +01:00
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 20:47:05 +02: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 20:58:53 +02: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 20:47:05 +02: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 06:23:00 +02: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 20:47:05 +02: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 07:20:06 +02: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 20:47:05 +02: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 05:06:03 +02: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 06:23:00 +02: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 05:06:03 +02: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 20:58:53 +02: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 05:06:03 +02:00
+ entity.die();
Fix some false positive warnings printing that shouldnt be reduces some log spam
2018-08-21 02:20:40 +02: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 05:06:03 +02: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 07:20:06 +02: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 20:47:05 +02: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 20:58:53 +02: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 20:47:05 +02: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 20:58:53 +02: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 20:47:05 +02: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 20:58:53 +02: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 20:47:05 +02: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 07:20:06 +02: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 20:58:53 +02: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 07:20:06 +02: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 20:47:05 +02:00
+ }
+ }
+ thisChunk.put(entity.uniqueID, entity);
+ }
+ }
+ // Paper end
Updated Upstream (Bukkit/CraftBukkit/Spigot) 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 Warning: this commit contains more mapping changes from upstream, As always, ensure that you have working backups and test this build before deployment; Developers working on paper will, yet again, need to delete their work/Minecraft/1.13.2 folder Bukkit Changes: 7fca5fd4 SPIGOT-4558: Preserve user order in the face of copied defaults in configurations 15c9b1eb Ignore spurious slot IDs sent by client, e.g. in enchanting tables 5d2a10c5 SPIGOT-3747: Add API for force loaded chunks d6dd2bb3 SPIGOT-3538: Add getHitBlockFace for ProjectileHitEvent 771db4aa SPIGOT-794: Call EntityPlaceEvent for Minecart placement 55462509 Add InventoryView#getSlotType 2f3ce5b6 Remove EntityTransformEvent and CustomItemTagContainer from draft API f04ad7b6 Make ProjectileLaunchEvent extend EntitySpawnEvent ccb85808 Define EntitySpawnEvent b8cc3ebe Add PlayerItemDamageEvent 184a495d Ease ClassLoader Deadlocks Where Possible 11ac4728 Expand Boolean Prompt Values in Conversation API aae62d51 Added getAllSessionData() to the Conversation API. 9290ff91 Add InventoryView#getInventory API 995e530f Add API to get / set base arrow damage CraftBukkit Changes: c4a67eed SPIGOT-4556: Fix plugins closing inventory during drop events 5be2ddcb Replace version constants with methods to prevent compiler inlining a5b9c7b3 Use API method to create offset command completions 2bc7d1df SPIGOT-3747: Add API for force loaded chunks a408f375 SPIGOT-3538: Add getHitBlockFace for ProjectileHitEvent b54b9409 SPIGOT-2864: Make Arrow / Item setTicksLived behave like FallingBlock 79ded7a8 SPIGOT-1811: Death message not shown on respawn screen b4a4f15d SPIGOT-943: InventoryCloseEvent called on death regardless of open inventory 0afed592 SPIGOT-794: Call EntityPlaceEvent for Minecart placement 2b2d084a Add InventoryView#getSlotType 01a9959a Do not use deprecated ItemSpawnEvent constructor 9642498d SPIGOT-4547: Call EntitySpawnEvent as general spawn fallback event 963f4a5f Add PlayerItemDamageEvent 63db0445 Add API to get / set base arrow damage 531c25d7 Add CraftMagicNumbers.MAPPINGS_VERSION for use by NMS plugins d05c8b14 Mappings Update bd36e200 SPIGOT-4551: Ignore invalid attribute modifier slots Spigot Changes: 518206a1 Remove redundant trove depend 1959ad21 MC-11211,SPIGOT-4552: Fix placing double slabs at y = 255 29ab5e43 SPIGOT-3661: Allow arguments in restart-script 7cc46316 SPIGOT-852: Growth modifiers for beetroots, potatoes, carrots 82e117e1 Squelch "fatal: Resolve operation not in progress" message 0a1a68e7 Mappings Update & Patch Rebuild
2019-01-01 04:15:55 +01:00
// CraftBukkit start
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 06:18:06 +01:00
List<Entity> toRemove = new LinkedList<>();
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 20:47:05 +02: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) 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: da08d022 SPIGOT-4700: Add PlayerFishEvent.State.REEL_IN 0cef14e4 Remove draft API from selectEntities CraftBukkit Changes: a46fdbc6 Remove outdated build delay. 3697519b SPIGOT-4708: Fix ExactChoice recipes neglecting material 9ead7009 SPIGOT-4677: Add minecraft.admin.command_feedback permission c3749a23 Remove the Damage tag from items when it is 0. f74c7b95 SPIGOT-4706: Can't interact with active item 494eef45 Mention requirement of JIRA ticket for bug fixes 51d62dec SPIGOT-4702: Exception when middle clicking certain slots be557e69 SPIGOT-4700: Add PlayerFishEvent.State.REEL_IN
2019-04-22 23:36:14 +02:00
index b6c46e01d9..6598b87eef 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 20:47:05 +02:00
--- a/src/main/java/net/minecraft/server/Entity.java
+++ b/src/main/java/net/minecraft/server/Entity.java
Default nether void damage to off and allow that
2019-04-05 07:27:37 +02:00
@@ -2739,6 +2739,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 20:47:05 +02: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 22:43:00 +02: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 07:20:06 +02: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) 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: da08d022 SPIGOT-4700: Add PlayerFishEvent.State.REEL_IN 0cef14e4 Remove draft API from selectEntities CraftBukkit Changes: a46fdbc6 Remove outdated build delay. 3697519b SPIGOT-4708: Fix ExactChoice recipes neglecting material 9ead7009 SPIGOT-4677: Add minecraft.admin.command_feedback permission c3749a23 Remove the Damage tag from items when it is 0. f74c7b95 SPIGOT-4706: Can't interact with active item 494eef45 Mention requirement of JIRA ticket for bug fixes 51d62dec SPIGOT-4702: Exception when middle clicking certain slots be557e69 SPIGOT-4700: Add PlayerFishEvent.State.REEL_IN
2019-04-22 23:36:14 +02:00
index 1496125ddf..a5f4b9ad94 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 07:20:06 +02:00
--- a/src/main/java/net/minecraft/server/World.java
+++ b/src/main/java/net/minecraft/server/World.java
Updated Upstream (Bukkit/CraftBukkit/Spigot) 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 Warning: this commit contains more mapping changes from upstream, As always, ensure that you have working backups and test this build before deployment; Developers working on paper will, yet again, need to delete their work/Minecraft/1.13.2 folder Bukkit Changes: 7fca5fd4 SPIGOT-4558: Preserve user order in the face of copied defaults in configurations 15c9b1eb Ignore spurious slot IDs sent by client, e.g. in enchanting tables 5d2a10c5 SPIGOT-3747: Add API for force loaded chunks d6dd2bb3 SPIGOT-3538: Add getHitBlockFace for ProjectileHitEvent 771db4aa SPIGOT-794: Call EntityPlaceEvent for Minecart placement 55462509 Add InventoryView#getSlotType 2f3ce5b6 Remove EntityTransformEvent and CustomItemTagContainer from draft API f04ad7b6 Make ProjectileLaunchEvent extend EntitySpawnEvent ccb85808 Define EntitySpawnEvent b8cc3ebe Add PlayerItemDamageEvent 184a495d Ease ClassLoader Deadlocks Where Possible 11ac4728 Expand Boolean Prompt Values in Conversation API aae62d51 Added getAllSessionData() to the Conversation API. 9290ff91 Add InventoryView#getInventory API 995e530f Add API to get / set base arrow damage CraftBukkit Changes: c4a67eed SPIGOT-4556: Fix plugins closing inventory during drop events 5be2ddcb Replace version constants with methods to prevent compiler inlining a5b9c7b3 Use API method to create offset command completions 2bc7d1df SPIGOT-3747: Add API for force loaded chunks a408f375 SPIGOT-3538: Add getHitBlockFace for ProjectileHitEvent b54b9409 SPIGOT-2864: Make Arrow / Item setTicksLived behave like FallingBlock 79ded7a8 SPIGOT-1811: Death message not shown on respawn screen b4a4f15d SPIGOT-943: InventoryCloseEvent called on death regardless of open inventory 0afed592 SPIGOT-794: Call EntityPlaceEvent for Minecart placement 2b2d084a Add InventoryView#getSlotType 01a9959a Do not use deprecated ItemSpawnEvent constructor 9642498d SPIGOT-4547: Call EntitySpawnEvent as general spawn fallback event 963f4a5f Add PlayerItemDamageEvent 63db0445 Add API to get / set base arrow damage 531c25d7 Add CraftMagicNumbers.MAPPINGS_VERSION for use by NMS plugins d05c8b14 Mappings Update bd36e200 SPIGOT-4551: Ignore invalid attribute modifier slots Spigot Changes: 518206a1 Remove redundant trove depend 1959ad21 MC-11211,SPIGOT-4552: Fix placing double slabs at y = 255 29ab5e43 SPIGOT-3661: Allow arguments in restart-script 7cc46316 SPIGOT-852: Growth modifiers for beetroots, potatoes, carrots 82e117e1 Squelch "fatal: Resolve operation not in progress" message 0a1a68e7 Mappings Update & Patch Rebuild
2019-01-01 04:15:55 +01:00
@@ -70,7 +70,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 07:20:06 +02: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 20:11:49 +02: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 07:20:06 +02: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 07:59:20 +02: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 20:47:05 +02: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) 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: da08d022 SPIGOT-4700: Add PlayerFishEvent.State.REEL_IN 0cef14e4 Remove draft API from selectEntities CraftBukkit Changes: a46fdbc6 Remove outdated build delay. 3697519b SPIGOT-4708: Fix ExactChoice recipes neglecting material 9ead7009 SPIGOT-4677: Add minecraft.admin.command_feedback permission c3749a23 Remove the Damage tag from items when it is 0. f74c7b95 SPIGOT-4706: Can't interact with active item 494eef45 Mention requirement of JIRA ticket for bug fixes 51d62dec SPIGOT-4702: Exception when middle clicking certain slots be557e69 SPIGOT-4700: Add PlayerFishEvent.State.REEL_IN
2019-04-22 23:36:14 +02:00
index 6d1f70b39e..293818b196 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 20:47:05 +02:00
--- a/src/main/java/net/minecraft/server/WorldServer.java
+++ b/src/main/java/net/minecraft/server/WorldServer.java
Updated Upstream (Bukkit/CraftBukkit/Spigot) 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 Warning: this commit contains more mapping changes from upstream, As always, ensure that you have working backups and test this build before deployment; Developers working on paper will, yet again, need to delete their work/Minecraft/1.13.2 folder Bukkit Changes: 7fca5fd4 SPIGOT-4558: Preserve user order in the face of copied defaults in configurations 15c9b1eb Ignore spurious slot IDs sent by client, e.g. in enchanting tables 5d2a10c5 SPIGOT-3747: Add API for force loaded chunks d6dd2bb3 SPIGOT-3538: Add getHitBlockFace for ProjectileHitEvent 771db4aa SPIGOT-794: Call EntityPlaceEvent for Minecart placement 55462509 Add InventoryView#getSlotType 2f3ce5b6 Remove EntityTransformEvent and CustomItemTagContainer from draft API f04ad7b6 Make ProjectileLaunchEvent extend EntitySpawnEvent ccb85808 Define EntitySpawnEvent b8cc3ebe Add PlayerItemDamageEvent 184a495d Ease ClassLoader Deadlocks Where Possible 11ac4728 Expand Boolean Prompt Values in Conversation API aae62d51 Added getAllSessionData() to the Conversation API. 9290ff91 Add InventoryView#getInventory API 995e530f Add API to get / set base arrow damage CraftBukkit Changes: c4a67eed SPIGOT-4556: Fix plugins closing inventory during drop events 5be2ddcb Replace version constants with methods to prevent compiler inlining a5b9c7b3 Use API method to create offset command completions 2bc7d1df SPIGOT-3747: Add API for force loaded chunks a408f375 SPIGOT-3538: Add getHitBlockFace for ProjectileHitEvent b54b9409 SPIGOT-2864: Make Arrow / Item setTicksLived behave like FallingBlock 79ded7a8 SPIGOT-1811: Death message not shown on respawn screen b4a4f15d SPIGOT-943: InventoryCloseEvent called on death regardless of open inventory 0afed592 SPIGOT-794: Call EntityPlaceEvent for Minecart placement 2b2d084a Add InventoryView#getSlotType 01a9959a Do not use deprecated ItemSpawnEvent constructor 9642498d SPIGOT-4547: Call EntitySpawnEvent as general spawn fallback event 963f4a5f Add PlayerItemDamageEvent 63db0445 Add API to get / set base arrow damage 531c25d7 Add CraftMagicNumbers.MAPPINGS_VERSION for use by NMS plugins d05c8b14 Mappings Update bd36e200 SPIGOT-4551: Ignore invalid attribute modifier slots Spigot Changes: 518206a1 Remove redundant trove depend 1959ad21 MC-11211,SPIGOT-4552: Fix placing double slabs at y = 255 29ab5e43 SPIGOT-3661: Allow arguments in restart-script 7cc46316 SPIGOT-852: Growth modifiers for beetroots, potatoes, carrots 82e117e1 Squelch "fatal: Resolve operation not in progress" message 0a1a68e7 Mappings Update & Patch Rebuild
2019-01-01 04:15:55 +01:00
@@ -37,7 +37,7 @@ public class WorldServer extends World implements IAsyncTaskHandler {
Rebuild patches for upstream merge
2018-07-21 22:43:00 +02: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 20:47:05 +02: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 20:11:49 +02: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 20:47:05 +02:00
private int emptyTime;
Remove redstone checks for BlockPhysicsEvent as it wasnt working, general optimize Just make it ignore the event fires when no plugin is listening to it.
2019-02-26 02:38:55 +01:00
@@ -971,7 +971,7 @@ public class WorldServer extends World implements IAsyncTaskHandler {
Rebuild patches for upstream merge
2018-07-21 22:43:00 +02: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 20:47:05 +02: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 20:58:53 +02: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 20:47:05 +02:00
Remove redstone checks for BlockPhysicsEvent as it wasnt working, general optimize Just make it ignore the event fires when no plugin is listening to it.
2019-02-26 02:38:55 +01:00
@@ -1002,7 +1002,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 20:47:05 +02:00
}
Rebuild patches for upstream merge
2018-07-21 22:43:00 +02: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 20:47:05 +02: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) {
--
Updated Upstream (Bukkit/CraftBukkit/Spigot) 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 Developers!: You will need to clean up your work/Minecraft/1.13.2 folder for this Also, restore a patch that was dropped in the last upstream Bukkit Changes: 279eeab3 Fix command description not being set 96e2bb18 Remove debug print from SyntheticEventTest CraftBukkit Changes: d3ed1516 Fix dangerously threaded beacons 217a293d Don't relocate joptsimple to allow --help to work. 1be05a21 Prepare for imminent Java 12 release a49270b2 Mappings Update 5259d80c SPIGOT-4669: Fix PlayerTeleportEvent coordinates for relative teleports Spigot Changes: e6eb36f2 Rebuild patches
2019-03-20 02:46:00 +01:00
2.21.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 20:47:05 +02:00
In neuem Issue referenzieren Permalink kopieren