2019-03-25 00:33:39 +08:00
From b3a5b4a4f7bc25a94dd49ab96ac2072b087cf59e Mon Sep 17 00:00:00 2001
2016-03-29 09:01:42 +08:00
From: Aikar <aikar@aikar.co>
Date: Mon, 28 Mar 2016 20:55:47 -0400
Subject: [PATCH] MC Utils
2018-10-19 11:24:09 +08:00
diff --git a/src/main/java/net/minecraft/server/AttributeInstance.java b/src/main/java/net/minecraft/server/AttributeInstance.java
2019-02-24 01:17:41 +08:00
index be179ba213..c53bc8230a 100644
2018-10-19 11:24:09 +08:00
--- a/src/main/java/net/minecraft/server/AttributeInstance.java
+++ b/src/main/java/net/minecraft/server/AttributeInstance.java
2019-01-01 11:15:55 +08:00
@@ -21,8 +21,10 @@ public interface AttributeInstance {
2018-10-19 11:24:09 +08:00
@Nullable
2019-01-01 11:15:55 +08:00
AttributeModifier a(UUID uuid);
2018-10-19 11:24:09 +08:00
+ default void addModifier(AttributeModifier modifier) { b(modifier); } // Paper - OBFHELPER
2019-01-01 11:15:55 +08:00
void b(AttributeModifier attributemodifier);
2018-10-19 11:24:09 +08:00
+ default void removeModifier(AttributeModifier modifier) { c(modifier); } // Paper - OBFHELPER
2019-01-01 11:15:55 +08:00
void c(AttributeModifier attributemodifier);
2018-10-19 11:24:09 +08:00
2019-01-01 11:15:55 +08:00
void b(UUID uuid);
2018-07-17 23:14:23 +08:00
diff --git a/src/main/java/net/minecraft/server/BlockPosition.java b/src/main/java/net/minecraft/server/BlockPosition.java
2019-03-25 00:33:39 +08:00
index 13dc7abc50..9bb7c9c652 100644
2018-07-17 23:14:23 +08:00
--- a/src/main/java/net/minecraft/server/BlockPosition.java
+++ b/src/main/java/net/minecraft/server/BlockPosition.java
2019-01-01 11:15:55 +08:00
@@ -45,6 +45,7 @@ public class BlockPosition extends BaseBlockPosition {
return d0 == 0.0D && d1 == 0.0D && d2 == 0.0D ? this : new BlockPosition((double) this.getX() + d0, (double) this.getY() + d1, (double) this.getZ() + d2);
2018-07-19 07:31:45 +08:00
}
+ public BlockPosition add(int i, int j, int k) {return a(i, j, k);} // Paper - OBFHELPER
2019-01-01 11:15:55 +08:00
public BlockPosition a(int i, int j, int k) {
return i == 0 && j == 0 && k == 0 ? this : new BlockPosition(this.getX() + i, this.getY() + j, this.getZ() + k);
2018-07-19 07:31:45 +08:00
}
2019-01-01 11:15:55 +08:00
@@ -183,6 +184,7 @@ public class BlockPosition extends BaseBlockPosition {
2018-10-05 11:18:46 +08:00
};
}
+ public BlockPosition asImmutable() { return h(); } // Paper - OBFHELPER
public BlockPosition h() {
return this;
}
2019-01-01 11:15:55 +08:00
@@ -342,6 +344,7 @@ public class BlockPosition extends BaseBlockPosition {
2018-07-19 12:42:43 +08:00
return this.d;
}
+ public BlockPosition.MutableBlockPosition setValues(int i, int j, int k) { return c(i, j, k);} // Paper - OBFHELPER
public BlockPosition.MutableBlockPosition c(int i, int j, int k) {
this.b = i;
this.c = j;
2019-01-01 11:15:55 +08:00
@@ -349,6 +352,7 @@ public class BlockPosition extends BaseBlockPosition {
2018-07-19 12:42:43 +08:00
return this;
}
+ public BlockPosition.MutableBlockPosition setValues(double d0, double d1, double d2) { return c(d0, d1, d2);} // Paper - OBFHELPER
public BlockPosition.MutableBlockPosition c(double d0, double d1, double d2) {
return this.c(MathHelper.floor(d0), MathHelper.floor(d1), MathHelper.floor(d2));
}
2016-06-18 14:03:40 +08:00
diff --git a/src/main/java/net/minecraft/server/Chunk.java b/src/main/java/net/minecraft/server/Chunk.java
2019-02-24 01:17:41 +08:00
index 1ff78eed40..417c015e56 100644
2016-06-18 14:03:40 +08:00
--- a/src/main/java/net/minecraft/server/Chunk.java
+++ b/src/main/java/net/minecraft/server/Chunk.java
2019-01-01 11:15:55 +08:00
@@ -31,7 +31,7 @@ import org.bukkit.event.entity.CreatureSpawnEvent;
2018-07-15 09:53:17 +08:00
public class Chunk implements IChunkAccess {
2017-10-05 21:38:21 +08:00
2018-08-27 02:11:49 +08:00
private static final Logger d = LogManager.getLogger();
2017-10-05 21:38:21 +08:00
- public static final ChunkSection a = null;
+ public static final ChunkSection a = null; public static final ChunkSection EMPTY_CHUNK_SECTION = Chunk.a; // Paper - OBFHELPER
private final ChunkSection[] sections;
2018-08-27 02:11:49 +08:00
private final BiomeBase[] f;
private final boolean[] g;
2019-01-01 11:15:55 +08:00
@@ -704,6 +704,7 @@ public class Chunk implements IChunkAccess {
2018-07-15 09:53:17 +08:00
return this.a(blockposition, Chunk.EnumTileEntityState.CHECK);
2016-06-18 14:03:40 +08:00
}
+ @Nullable public final TileEntity getTileEntityImmediately(BlockPosition pos) { return this.a(pos, EnumTileEntityState.IMMEDIATE); } // Paper - OBFHELPER
@Nullable
public TileEntity a(BlockPosition blockposition, Chunk.EnumTileEntityState chunk_enumtileentitystate) {
// CraftBukkit start
2017-11-12 07:47:30 +08:00
diff --git a/src/main/java/net/minecraft/server/ChunkCoordIntPair.java b/src/main/java/net/minecraft/server/ChunkCoordIntPair.java
2019-02-24 01:17:41 +08:00
index 34586bca65..b0c004b1f2 100644
2017-11-12 07:47:30 +08:00
--- a/src/main/java/net/minecraft/server/ChunkCoordIntPair.java
+++ b/src/main/java/net/minecraft/server/ChunkCoordIntPair.java
2019-01-01 11:15:55 +08:00
@@ -24,6 +24,8 @@ public class ChunkCoordIntPair {
2018-07-15 09:53:17 +08:00
return a(this.x, this.z);
2017-11-12 07:47:30 +08:00
}
+ public static long asLong(final BlockPosition pos) { return a(pos.getX() >> 4, pos.getZ() >> 4); } // Paper - OBFHELPER
+ public static long asLong(int x, int z) { return a(x, z); } // Paper - OBFHELPER
public static long a(int i, int j) {
2019-01-01 11:15:55 +08:00
return (long) i & 4294967295L | ((long) j & 4294967295L) << 32;
2017-11-12 07:47:30 +08:00
}
2018-08-26 10:37:58 +08:00
diff --git a/src/main/java/net/minecraft/server/ChunkTaskScheduler.java b/src/main/java/net/minecraft/server/ChunkTaskScheduler.java
2019-02-24 01:17:41 +08:00
index cc9604749b..70a95c2636 100644
2018-08-26 10:37:58 +08:00
--- a/src/main/java/net/minecraft/server/ChunkTaskScheduler.java
+++ b/src/main/java/net/minecraft/server/ChunkTaskScheduler.java
2019-01-01 11:15:55 +08:00
@@ -13,7 +13,7 @@ import org.apache.logging.log4j.Logger;
2018-08-26 10:37:58 +08:00
public class ChunkTaskScheduler extends Scheduler<ChunkCoordIntPair, ChunkStatus, ProtoChunk> {
private static final Logger b = LogManager.getLogger();
- private final World c;
+ private final World c; private final World getWorld() { return this.c; } // Paper - OBFHELPER
private final ChunkGenerator<?> d;
private final IChunkLoader e;
private final IAsyncTaskHandler f;
diff --git a/src/main/java/net/minecraft/server/DataBits.java b/src/main/java/net/minecraft/server/DataBits.java
2019-02-24 01:17:41 +08:00
index d24ec3d53c..9e83610f1a 100644
2018-08-26 10:37:58 +08:00
--- a/src/main/java/net/minecraft/server/DataBits.java
+++ b/src/main/java/net/minecraft/server/DataBits.java
2019-01-01 11:15:55 +08:00
@@ -60,6 +60,7 @@ public class DataBits {
2018-08-26 10:37:58 +08:00
}
}
+ public long[] getDataBits() { return this.a(); } // Paper - OBFHELPER
public long[] a() {
return this.a;
}
diff --git a/src/main/java/net/minecraft/server/DataPalette.java b/src/main/java/net/minecraft/server/DataPalette.java
2019-02-24 01:17:41 +08:00
index dae40b9cde..2ee8791963 100644
2018-08-26 10:37:58 +08:00
--- a/src/main/java/net/minecraft/server/DataPalette.java
+++ b/src/main/java/net/minecraft/server/DataPalette.java
2019-01-01 11:15:55 +08:00
@@ -4,8 +4,10 @@ import javax.annotation.Nullable;
2018-08-26 10:37:58 +08:00
public interface DataPalette<T> {
2019-01-01 11:15:55 +08:00
2018-09-01 12:30:04 +08:00
+ default int getOrCreateIdFor(T object) { return this.a(object); } // Paper - OBFHELPER
2019-01-01 11:15:55 +08:00
int a(T t0);
2018-08-26 10:37:58 +08:00
+ @Nullable default T getObject(int dataBits) { return this.a(dataBits); } // Paper - OBFHELPER
2019-01-01 11:15:55 +08:00
@Nullable
T a(int i);
2018-08-26 10:37:58 +08:00
diff --git a/src/main/java/net/minecraft/server/DataPaletteBlock.java b/src/main/java/net/minecraft/server/DataPaletteBlock.java
2019-02-24 01:17:41 +08:00
index 59cbbdcb3d..6fcfc5ef72 100644
2018-08-26 10:37:58 +08:00
--- a/src/main/java/net/minecraft/server/DataPaletteBlock.java
+++ b/src/main/java/net/minecraft/server/DataPaletteBlock.java
2019-01-01 11:15:55 +08:00
@@ -8,7 +8,7 @@ import java.util.stream.Collectors;
2018-08-26 10:37:58 +08:00
public class DataPaletteBlock<T> implements DataPaletteExpandable<T> {
2019-01-01 11:15:55 +08:00
2018-08-26 10:37:58 +08:00
- private final DataPalette<T> b;
2019-01-01 11:15:55 +08:00
+ private final DataPalette<T> b; private final DataPalette<T> getDataPaletteGlobal() { return this.b; } // Paper - OBFHELPER
private final DataPaletteExpandable<T> c = (i, object) -> {
2018-08-26 10:37:58 +08:00
return 0;
};
2019-01-01 11:15:55 +08:00
@@ -16,9 +16,9 @@ public class DataPaletteBlock<T> implements DataPaletteExpandable<T> {
2018-08-26 10:37:58 +08:00
private final Function<NBTTagCompound, T> e;
private final Function<T, NBTTagCompound> f;
private final T g;
- protected DataBits a;
- private DataPalette<T> h;
- private int i;
+ protected DataBits a; protected DataBits getDataBits() { return this.a; } // Paper - OBFHELPER
+ private DataPalette<T> h; private DataPalette<T> getDataPalette() { return this.h; } // Paper - OBFHELPER
+ private int i; private int getBitsPerObject() { return this.i; } // Paper - OBFHELPER
private final ReentrantLock j = new ReentrantLock();
private void b() {
2019-01-01 11:15:55 +08:00
@@ -53,6 +53,7 @@ public class DataPaletteBlock<T> implements DataPaletteExpandable<T> {
return j << 8 | k << 4 | i;
2018-08-26 10:37:58 +08:00
}
+ private void initialize(int bitsPerObject) { this.b(bitsPerObject); } // Paper - OBFHELPER
2019-01-01 11:15:55 +08:00
private void b(int i) {
if (i != this.i) {
this.i = i;
@@ -115,6 +116,7 @@ public class DataPaletteBlock<T> implements DataPaletteExpandable<T> {
return t0 == null ? this.g : t0;
2018-08-26 10:37:58 +08:00
}
+ public void writeDataPaletteBlock(PacketDataSerializer packetDataSerializer) { this.b(packetDataSerializer); } // Paper - OBFHELPER
public void b(PacketDataSerializer packetdataserializer) {
this.b();
packetdataserializer.writeByte(this.i);
2018-08-05 05:03:53 +08:00
diff --git a/src/main/java/net/minecraft/server/EntityCreature.java b/src/main/java/net/minecraft/server/EntityCreature.java
2019-02-24 01:17:41 +08:00
index 372afbe94e..20b7c2c6dc 100644
2018-08-05 05:03:53 +08:00
--- a/src/main/java/net/minecraft/server/EntityCreature.java
+++ b/src/main/java/net/minecraft/server/EntityCreature.java
@@ -6,6 +6,7 @@ import org.bukkit.event.entity.EntityUnleashEvent;
public abstract class EntityCreature extends EntityInsentient {
2018-09-01 06:56:57 +08:00
+ public org.bukkit.craftbukkit.entity.CraftCreature getBukkitCreature() { return (org.bukkit.craftbukkit.entity.CraftCreature) super.getBukkitEntity(); } // Paper
2018-08-05 05:03:53 +08:00
private BlockPosition a;
private float b;
2018-09-01 06:56:57 +08:00
diff --git a/src/main/java/net/minecraft/server/EntityInsentient.java b/src/main/java/net/minecraft/server/EntityInsentient.java
2019-02-24 01:17:41 +08:00
index 8b2000f683..1a3517aeed 100644
2018-09-01 06:56:57 +08:00
--- a/src/main/java/net/minecraft/server/EntityInsentient.java
+++ b/src/main/java/net/minecraft/server/EntityInsentient.java
2019-01-01 11:15:55 +08:00
@@ -125,6 +125,7 @@ public abstract class EntityInsentient extends EntityLiving {
2018-09-01 06:56:57 +08:00
return this.goalTarget;
}
+ public org.bukkit.craftbukkit.entity.CraftMob getBukkitMob() { return (org.bukkit.craftbukkit.entity.CraftMob) super.getBukkitEntity(); } // Paper
public void setGoalTarget(@Nullable EntityLiving entityliving) {
// CraftBukkit start - fire event
setGoalTarget(entityliving, EntityTargetEvent.TargetReason.UNKNOWN, true);
2018-08-05 05:03:53 +08:00
diff --git a/src/main/java/net/minecraft/server/EntityLiving.java b/src/main/java/net/minecraft/server/EntityLiving.java
2019-03-25 00:33:39 +08:00
index d4fe0ab6bf..011c7af218 100644
2018-08-05 05:03:53 +08:00
--- a/src/main/java/net/minecraft/server/EntityLiving.java
+++ b/src/main/java/net/minecraft/server/EntityLiving.java
@@ -122,6 +122,7 @@ public abstract class EntityLiving extends Entity {
public org.bukkit.craftbukkit.attribute.CraftAttributeMap craftAttributes;
public boolean collides = true;
public boolean canPickUpLoot;
2018-09-01 06:56:57 +08:00
+ public org.bukkit.craftbukkit.entity.CraftLivingEntity getBukkitLivingEntity() { return (org.bukkit.craftbukkit.entity.CraftLivingEntity) super.getBukkitEntity(); } // Paper
2018-08-05 05:03:53 +08:00
@Override
public float getBukkitYaw() {
diff --git a/src/main/java/net/minecraft/server/EntityMonster.java b/src/main/java/net/minecraft/server/EntityMonster.java
2019-02-24 01:17:41 +08:00
index 5f9255df14..5ea5170436 100644
2018-08-05 05:03:53 +08:00
--- a/src/main/java/net/minecraft/server/EntityMonster.java
+++ b/src/main/java/net/minecraft/server/EntityMonster.java
2019-01-01 11:15:55 +08:00
@@ -2,11 +2,13 @@ package net.minecraft.server;
2018-08-05 05:03:53 +08:00
public abstract class EntityMonster extends EntityCreature implements IMonster {
2019-01-01 11:15:55 +08:00
2018-09-01 06:56:57 +08:00
+ public org.bukkit.craftbukkit.entity.CraftMonster getBukkitMonster() { return (org.bukkit.craftbukkit.entity.CraftMonster) super.getBukkitEntity(); } // Paper
2018-08-05 05:03:53 +08:00
protected EntityMonster(EntityTypes<?> entitytypes, World world) {
super(entitytypes, world);
this.b_ = 5;
2018-10-19 11:24:09 +08:00
}
+ public SoundCategory getSoundCategory() { return bV(); } // Paper - OBFHELPER
public SoundCategory bV() {
return SoundCategory.HOSTILE;
}
2018-01-15 06:02:38 +08:00
diff --git a/src/main/java/net/minecraft/server/EntityTypes.java b/src/main/java/net/minecraft/server/EntityTypes.java
2019-02-24 01:17:41 +08:00
index b8abd6363f..a07ee150c2 100644
2018-01-15 06:02:38 +08:00
--- a/src/main/java/net/minecraft/server/EntityTypes.java
+++ b/src/main/java/net/minecraft/server/EntityTypes.java
2018-07-15 09:53:17 +08:00
@@ -3,6 +3,7 @@ package net.minecraft.server;
import com.mojang.datafixers.DataFixUtils;
import com.mojang.datafixers.types.Type;
2018-01-15 06:15:27 +08:00
2018-07-15 09:53:17 +08:00
+import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.function.Function;
2018-08-27 02:11:49 +08:00
@@ -123,9 +124,20 @@ public class EntityTypes<T extends Entity> {
2018-07-15 09:53:17 +08:00
public static <T extends Entity> EntityTypes<T> a(String s, EntityTypes.a<T> entitytypes_a) {
2019-01-01 11:15:55 +08:00
EntityTypes<T> entitytypes = entitytypes_a.a(s);
2018-01-15 06:15:27 +08:00
2018-07-15 09:53:17 +08:00
+ // Paper start
2018-07-19 12:42:43 +08:00
+ if (clsToKeyMap == null ) clsToKeyMap = new java.util.HashMap<>();
+ if (clsToTypeMap == null ) clsToTypeMap = new java.util.HashMap<>();
+
2018-07-15 09:53:17 +08:00
+ MinecraftKey key = new MinecraftKey(s);
+ Class<? extends T> entityClass = entitytypes_a.getEntityClass();
2018-08-27 02:11:49 +08:00
IRegistry.ENTITY_TYPE.a(new MinecraftKey(s), entitytypes); // CraftBukkit - decompile error
2018-07-15 09:53:17 +08:00
+ clsToKeyMap.put(entityClass, key);
+ clsToTypeMap.put(entityClass, org.bukkit.entity.EntityType.fromName(s));
return entitytypes;
}
2018-07-19 12:42:43 +08:00
+ public static Map<Class<? extends Entity>, MinecraftKey> clsToKeyMap;
+ public static Map<Class<? extends Entity>, org.bukkit.entity.EntityType> clsToTypeMap;
2018-01-15 06:02:38 +08:00
+ // Paper end
2018-07-15 09:53:17 +08:00
@Nullable
public static MinecraftKey getName(EntityTypes<?> entitytypes) {
2018-08-27 02:11:49 +08:00
@@ -287,7 +299,7 @@ public class EntityTypes<T extends Entity> {
2018-07-15 09:53:17 +08:00
public static class a<T extends Entity> {
2018-01-15 06:02:38 +08:00
2018-07-15 09:53:17 +08:00
- private final Class<? extends T> a;
+ private final Class<? extends T> a; public Class<? extends T> getEntityClass() { return a; } // Paper - OBFHELPER
private final Function<? super World, ? extends T> b;
private boolean c = true;
private boolean d = true;
2018-08-27 02:11:49 +08:00
@@ -338,7 +350,7 @@ public class EntityTypes<T extends Entity> {
// Paper start
public static Set<MinecraftKey> getEntityNameList() {
- return REGISTRY.keySet();
+ return IRegistry.ENTITY_TYPE.keySet();
}
// Paper end
}
2018-06-29 12:55:29 +08:00
diff --git a/src/main/java/net/minecraft/server/ItemStack.java b/src/main/java/net/minecraft/server/ItemStack.java
2019-03-25 00:33:39 +08:00
index 132fe8e880..3fe2aa2313 100644
2018-06-29 12:55:29 +08:00
--- a/src/main/java/net/minecraft/server/ItemStack.java
+++ b/src/main/java/net/minecraft/server/ItemStack.java
2019-03-25 00:33:39 +08:00
@@ -584,6 +584,17 @@ public final class ItemStack {
2018-07-15 09:53:17 +08:00
return this.tag != null ? this.tag.getList("Enchantments", 10) : new NBTTagList();
2018-06-29 12:55:29 +08:00
}
+ // Paper start - (this is just a good no conflict location)
+ public org.bukkit.inventory.ItemStack asBukkitMirror() {
+ return CraftItemStack.asCraftMirror(this);
+ }
+ public org.bukkit.inventory.ItemStack asBukkitCopy() {
+ return CraftItemStack.asCraftMirror(this.cloneItemStack());
+ }
+ public static ItemStack fromBukkitCopy(org.bukkit.inventory.ItemStack itemstack) {
+ return CraftItemStack.asNMSCopy(itemstack);
+ }
+ // Paper end
public void setTag(@Nullable NBTTagCompound nbttagcompound) {
this.tag = nbttagcompound;
}
2019-03-25 00:33:39 +08:00
@@ -668,6 +679,7 @@ public final class ItemStack {
2019-01-07 01:48:24 +08:00
return this.tag != null && this.tag.hasKeyOfType("Enchantments", 9) ? !this.tag.getList("Enchantments", 10).isEmpty() : false;
}
+ public void getOrCreateTagAndSet(String s, NBTBase nbtbase) { a(s, nbtbase);} // Paper - OBFHELPER
public void a(String s, NBTBase nbtbase) {
this.getOrCreateTag().set(s, nbtbase);
}
2016-03-29 09:01:42 +08:00
diff --git a/src/main/java/net/minecraft/server/MCUtil.java b/src/main/java/net/minecraft/server/MCUtil.java
new file mode 100644
2019-02-24 01:17:41 +08:00
index 0000000000..c97e116aaf
2016-03-29 09:01:42 +08:00
--- /dev/null
+++ b/src/main/java/net/minecraft/server/MCUtil.java
2018-10-05 11:18:46 +08:00
@@ -0,0 +1,316 @@
2016-03-29 09:01:42 +08:00
+package net.minecraft.server;
+
2018-09-04 07:59:54 +08:00
+import com.destroystokyo.paper.block.TargetBlockInfo;
2016-05-17 08:50:09 +08:00
+import com.google.common.util.concurrent.ThreadFactoryBuilder;
2016-03-29 09:01:42 +08:00
+import org.bukkit.Location;
2018-09-04 07:59:54 +08:00
+import org.bukkit.block.BlockFace;
+import org.bukkit.craftbukkit.CraftWorld;
2016-05-28 10:28:23 +08:00
+import org.bukkit.craftbukkit.util.Waitable;
+import org.spigotmc.AsyncCatcher;
2016-03-29 09:01:42 +08:00
+
2018-09-04 07:59:54 +08:00
+import javax.annotation.Nonnull;
2016-05-13 13:34:37 +08:00
+import javax.annotation.Nullable;
2018-07-22 12:45:49 +08:00
+import java.util.Queue;
+import java.util.concurrent.CompletableFuture;
2016-05-28 10:28:23 +08:00
+import java.util.concurrent.ExecutionException;
2016-05-17 08:50:09 +08:00
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
2018-07-22 12:45:49 +08:00
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
2016-05-28 10:28:23 +08:00
+import java.util.function.Supplier;
2016-03-29 09:01:42 +08:00
+
2016-05-14 10:27:20 +08:00
+public final class MCUtil {
2016-05-23 10:14:17 +08:00
+ private static final Executor asyncExecutor = Executors.newSingleThreadExecutor(new ThreadFactoryBuilder().setNameFormat("Paper Async Task Handler Thread - %1$d").build());
2016-03-29 09:01:42 +08:00
+
+ private MCUtil() {}
+
+
2018-07-22 12:45:49 +08:00
+ public static boolean isMainThread() {
+ return MinecraftServer.getServer().isMainThread();
+ }
+
2018-07-23 07:39:56 +08:00
+ private static class DelayedRunnable implements Runnable {
+
+ private final int ticks;
+ private final Runnable run;
+
+ private DelayedRunnable(int ticks, Runnable run) {
+ this.ticks = ticks;
+ this.run = run;
+ }
+
+ @Override
+ public void run() {
+ if (ticks <= 0) {
+ run.run();
+ } else {
+ scheduleTask(ticks-1, run);
+ }
+ }
+ }
+
+ public static void scheduleTask(int ticks, Runnable runnable) {
+ // We use post to main instead of process queue as we don't want to process these mid tick if
+ // Someone uses processQueueWhileWaiting
+ MinecraftServer.getServer().postToMainThread(new DelayedRunnable(ticks, runnable));
+ }
+
2018-07-22 12:45:49 +08:00
+ public static void processQueue() {
+ Runnable runnable;
+ Queue<Runnable> processQueue = getProcessQueue();
+ while ((runnable = processQueue.poll()) != null) {
+ try {
+ runnable.run();
+ } catch (Exception e) {
+ MinecraftServer.LOGGER.error("Error executing task", e);
+ }
+ }
+ }
+ public static <T> T processQueueWhileWaiting(CompletableFuture <T> future) {
+ try {
+ if (isMainThread()) {
+ while (!future.isDone()) {
+ try {
+ return future.get(1, TimeUnit.MILLISECONDS);
+ } catch (TimeoutException ignored) {
+ processQueue();
+ }
+ }
+ }
+ return future.get();
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ public static void ensureMain(Runnable run) {
+ ensureMain(null, run);
+ }
+ /**
+ * Ensures the target code is running on the main thread
+ * @param reason
+ * @param run
+ * @return
+ */
+ public static void ensureMain(String reason, Runnable run) {
+ if (AsyncCatcher.enabled && Thread.currentThread() != MinecraftServer.getServer().primaryThread) {
+ if (reason != null) {
+ new IllegalStateException("Asynchronous " + reason + "!").printStackTrace();
+ }
+ getProcessQueue().add(run);
+ return;
+ }
+ run.run();
+ }
+
+ private static Queue<Runnable> getProcessQueue() {
+ return MinecraftServer.getServer().processQueue;
+ }
+
+ public static <T> T ensureMain(Supplier<T> run) {
+ return ensureMain(null, run);
+ }
2016-03-29 09:01:42 +08:00
+ /**
2016-05-28 10:28:23 +08:00
+ * Ensures the target code is running on the main thread
+ * @param reason
+ * @param run
+ * @param <T>
+ * @return
+ */
+ public static <T> T ensureMain(String reason, Supplier<T> run) {
+ if (AsyncCatcher.enabled && Thread.currentThread() != MinecraftServer.getServer().primaryThread) {
2018-07-22 12:45:49 +08:00
+ if (reason != null) {
+ new IllegalStateException("Asynchronous " + reason + "! Blocking thread until it returns ").printStackTrace();
+ }
2016-05-28 10:28:23 +08:00
+ Waitable<T> wait = new Waitable<T>() {
+ @Override
+ protected T evaluate() {
+ return run.get();
+ }
+ };
2018-07-22 12:45:49 +08:00
+ getProcessQueue().add(wait);
2016-05-28 10:28:23 +08:00
+ try {
+ return wait.get();
+ } catch (InterruptedException | ExecutionException e) {
+ e.printStackTrace();
+ }
+ return null;
+ }
+ return run.get();
+ }
+
+ /**
2016-03-29 09:01:42 +08:00
+ * Calculates distance between 2 entities
+ * @param e1
+ * @param e2
+ * @return
+ */
+ public static double distance(Entity e1, Entity e2) {
+ return Math.sqrt(distanceSq(e1, e2));
+ }
+
+
+ /**
+ * Calculates distance between 2 block positions
+ * @param e1
+ * @param e2
+ * @return
+ */
+ public static double distance(BlockPosition e1, BlockPosition e2) {
+ return Math.sqrt(distanceSq(e1, e2));
+ }
+
+ /**
+ * Gets the distance between 2 positions
+ * @param x1
+ * @param y1
+ * @param z1
+ * @param x2
+ * @param y2
+ * @param z2
+ * @return
+ */
+ public static double distance(double x1, double y1, double z1, double x2, double y2, double z2) {
+ return Math.sqrt(distanceSq(x1, y1, z1, x2, y2, z2));
+ }
+
+ /**
+ * Get's the distance squared between 2 entities
+ * @param e1
+ * @param e2
+ * @return
+ */
+ public static double distanceSq(Entity e1, Entity e2) {
+ return distanceSq(e1.locX,e1.locY,e1.locZ, e2.locX,e2.locY,e2.locZ);
+ }
+
+ /**
+ * Gets the distance sqaured between 2 block positions
+ * @param pos1
+ * @param pos2
+ * @return
+ */
+ public static double distanceSq(BlockPosition pos1, BlockPosition pos2) {
+ return distanceSq(pos1.getX(), pos1.getY(), pos1.getZ(), pos2.getX(), pos2.getY(), pos2.getZ());
+ }
+
+ /**
+ * Gets the distance squared between 2 positions
+ * @param x1
+ * @param y1
+ * @param z1
+ * @param x2
+ * @param y2
+ * @param z2
+ * @return
+ */
+ public static double distanceSq(double x1, double y1, double z1, double x2, double y2, double z2) {
+ return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) + (z1 - z2) * (z1 - z2);
+ }
+
+ /**
+ * Converts a NMS World/BlockPosition to Bukkit Location
+ * @param world
2018-01-15 06:02:38 +08:00
+ * @param x
+ * @param y
+ * @param z
+ * @return
+ */
+ public static Location toLocation(World world, double x, double y, double z) {
+ return new Location(world.getWorld(), x, y, z);
+ }
+
+ /**
+ * Converts a NMS World/BlockPosition to Bukkit Location
+ * @param world
2016-03-29 09:01:42 +08:00
+ * @param pos
+ * @return
+ */
+ public static Location toLocation(World world, BlockPosition pos) {
+ return new Location(world.getWorld(), pos.getX(), pos.getY(), pos.getZ());
+ }
+
+ /**
+ * Converts an NMS entity's current location to a Bukkit Location
+ * @param entity
+ * @return
+ */
+ public static Location toLocation(Entity entity) {
+ return new Location(entity.getWorld().getWorld(), entity.locX, entity.locY, entity.locZ);
+ }
2016-04-01 07:29:06 +08:00
+
2018-08-27 02:11:49 +08:00
+ public static org.bukkit.block.Block toBukkitBlock(World world, BlockPosition pos) {
+ return world.getWorld().getBlockAt(pos.getX(), pos.getY(), pos.getZ());
+ }
+
2016-04-16 09:31:12 +08:00
+ public static BlockPosition toBlockPosition(Location loc) {
+ return new BlockPosition(loc.getBlockX(), loc.getBlockY(), loc.getBlockZ());
+ }
+
2016-04-01 07:29:06 +08:00
+ public static boolean isEdgeOfChunk(BlockPosition pos) {
2016-04-01 09:43:37 +08:00
+ final int modX = pos.getX() & 15;
+ final int modZ = pos.getZ() & 15;
+ return (modX == 0 || modX == 15 || modZ == 0 || modZ == 15);
2016-04-01 07:29:06 +08:00
+ }
2016-05-13 13:34:37 +08:00
+
+ /**
2016-05-17 08:50:09 +08:00
+ * Posts a task to be executed asynchronously
+ * @param run
+ */
+ public static void scheduleAsyncTask(Runnable run) {
+ asyncExecutor.execute(run);
+ }
2016-06-18 14:03:40 +08:00
+
+ @Nullable
+ public static TileEntityHopper getHopper(World world, BlockPosition pos) {
+ Chunk chunk = world.getChunkIfLoaded(pos.getX() >> 4, pos.getZ() >> 4);
2018-09-04 07:59:54 +08:00
+ if (chunk != null && chunk.getBlockData(pos.getX(), pos.getY(), pos.getZ()).getBlock() == Blocks.HOPPER) {
2016-06-18 14:03:40 +08:00
+ TileEntity tileEntity = chunk.getTileEntityImmediately(pos);
+ if (tileEntity instanceof TileEntityHopper) {
+ return (TileEntityHopper) tileEntity;
+ }
+ }
+ return null;
+ }
2018-09-04 07:59:54 +08:00
+
+ @Nonnull
+ public static World getNMSWorld(@Nonnull org.bukkit.World world) {
+ return ((CraftWorld) world).getHandle();
+ }
+
+ public static World getNMSWorld(@Nonnull org.bukkit.entity.Entity entity) {
+ return getNMSWorld(entity.getWorld());
+ }
+
+ public static FluidCollisionOption getNMSFluidCollisionOption(TargetBlockInfo.FluidMode fluidMode) {
+ if (fluidMode == TargetBlockInfo.FluidMode.NEVER) {
+ return FluidCollisionOption.NEVER;
+ }
+ if (fluidMode == TargetBlockInfo.FluidMode.SOURCE_ONLY) {
+ return FluidCollisionOption.SOURCE_ONLY;
+ }
+ if (fluidMode == TargetBlockInfo.FluidMode.ALWAYS) {
+ return FluidCollisionOption.ALWAYS;
+ }
+ return null;
+ }
+
+ public static BlockFace toBukkitBlockFace(EnumDirection enumDirection) {
+ switch (enumDirection) {
+ case DOWN:
+ return BlockFace.DOWN;
+ case UP:
+ return BlockFace.UP;
+ case NORTH:
+ return BlockFace.NORTH;
+ case SOUTH:
+ return BlockFace.SOUTH;
+ case WEST:
+ return BlockFace.WEST;
+ case EAST:
+ return BlockFace.EAST;
+ default:
+ return null;
+ }
+ }
2016-03-29 09:01:42 +08:00
+}
2016-05-02 11:54:08 +08:00
diff --git a/src/main/java/net/minecraft/server/NBTTagCompound.java b/src/main/java/net/minecraft/server/NBTTagCompound.java
2019-02-24 01:17:41 +08:00
index 434471215d..8c5d6c1d38 100644
2016-05-02 11:54:08 +08:00
--- a/src/main/java/net/minecraft/server/NBTTagCompound.java
+++ b/src/main/java/net/minecraft/server/NBTTagCompound.java
2019-01-01 11:15:55 +08:00
@@ -23,7 +23,7 @@ public class NBTTagCompound implements NBTBase {
2018-07-15 09:53:17 +08:00
private static final Logger f = LogManager.getLogger();
private static final Pattern g = Pattern.compile("[A-Za-z0-9._+-]+");
2016-06-09 11:57:14 +08:00
- private final Map<String, NBTBase> map = Maps.newHashMap();
+ public final Map<String, NBTBase> map = Maps.newHashMap(); // Paper
2016-05-02 11:54:08 +08:00
2019-01-01 11:15:55 +08:00
public NBTTagCompound() {}
@@ -95,11 +95,13 @@ public class NBTTagCompound implements NBTBase {
2016-05-02 11:54:08 +08:00
this.map.put(s, new NBTTagLong(i));
}
2016-07-28 06:46:02 +08:00
+ public void setUUID(String prefix, UUID uuid) { a(prefix, uuid); } // Paper - OBFHELPER
2016-05-02 11:54:08 +08:00
public void a(String s, UUID uuid) {
this.setLong(s + "Most", uuid.getMostSignificantBits());
this.setLong(s + "Least", uuid.getLeastSignificantBits());
}
2016-07-28 06:46:02 +08:00
+ public UUID getUUID(String prefix) { return a(prefix); } // Paper - OBFHELPER
2016-05-12 10:07:46 +08:00
@Nullable
2016-05-02 11:54:08 +08:00
public UUID a(String s) {
return new UUID(this.getLong(s + "Most"), this.getLong(s + "Least"));
2018-08-26 10:37:58 +08:00
diff --git a/src/main/java/net/minecraft/server/NetworkManager.java b/src/main/java/net/minecraft/server/NetworkManager.java
2019-02-24 01:17:41 +08:00
index d85bc522c3..e2fc41d6d1 100644
2018-08-26 10:37:58 +08:00
--- a/src/main/java/net/minecraft/server/NetworkManager.java
+++ b/src/main/java/net/minecraft/server/NetworkManager.java
2019-01-01 11:15:55 +08:00
@@ -43,7 +43,7 @@ public class NetworkManager extends SimpleChannelInboundHandler<Packet<?>> {
2018-08-26 10:37:58 +08:00
return new DefaultEventLoopGroup(0, (new ThreadFactoryBuilder()).setNameFormat("Netty Local Client IO #%d").setDaemon(true).build());
});
private final EnumProtocolDirection h;
2018-12-17 13:18:06 +08:00
- private final Queue<NetworkManager.QueuedPacket> packetQueue = Queues.newConcurrentLinkedQueue();
+ private final Queue<NetworkManager.QueuedPacket> packetQueue = Queues.newConcurrentLinkedQueue(); private final Queue<NetworkManager.QueuedPacket> getPacketQueue() { return this.packetQueue; } // Paper - OBFHELPER
2018-08-26 10:37:58 +08:00
private final ReentrantReadWriteLock j = new ReentrantReadWriteLock();
public Channel channel;
2018-12-17 13:18:06 +08:00
public SocketAddress socketAddress;
2019-01-01 11:15:55 +08:00
@@ -167,6 +167,7 @@ public class NetworkManager extends SimpleChannelInboundHandler<Packet<?>> {
2018-08-26 10:37:58 +08:00
}
+ private void dispatchPacket(Packet<?> packet, @Nullable GenericFutureListener<? extends Future<? super Void>> genericFutureListener) { this.b(packet, genericFutureListener); } // Paper - OBFHELPER
private void b(Packet<?> packet, @Nullable GenericFutureListener<? extends Future<? super Void>> genericfuturelistener) {
EnumProtocol enumprotocol = EnumProtocol.a(packet);
EnumProtocol enumprotocol1 = (EnumProtocol) this.channel.attr(NetworkManager.c).get();
2019-01-01 11:15:55 +08:00
@@ -207,6 +208,7 @@ public class NetworkManager extends SimpleChannelInboundHandler<Packet<?>> {
2018-08-26 10:37:58 +08:00
}
+ private void sendPacketQueue() { this.o(); } // Paper - OBFHELPER
private void o() {
if (this.channel != null && this.channel.isOpen()) {
this.j.readLock().lock();
2019-01-01 11:15:55 +08:00
@@ -333,9 +335,9 @@ public class NetworkManager extends SimpleChannelInboundHandler<Packet<?>> {
2018-08-26 10:37:58 +08:00
static class QueuedPacket {
- private final Packet<?> a;
+ private final Packet<?> a; private final Packet<?> getPacket() { return this.a; } // Paper - OBFHELPER
@Nullable
- private final GenericFutureListener<? extends Future<? super Void>> b;
+ private final GenericFutureListener<? extends Future<? super Void>> b; private final GenericFutureListener<? extends Future<? super Void>> getGenericFutureListener() { return this.b; } // Paper - OBFHELPER
public QueuedPacket(Packet<?> packet, @Nullable GenericFutureListener<? extends Future<? super Void>> genericfuturelistener) {
this.a = packet;
diff --git a/src/main/java/net/minecraft/server/PacketDataSerializer.java b/src/main/java/net/minecraft/server/PacketDataSerializer.java
2019-02-24 01:17:41 +08:00
index 7582151ae4..d05f1e02cf 100644
2018-08-26 10:37:58 +08:00
--- a/src/main/java/net/minecraft/server/PacketDataSerializer.java
+++ b/src/main/java/net/minecraft/server/PacketDataSerializer.java
@@ -33,6 +33,7 @@ public class PacketDataSerializer extends ByteBuf {
this.a = bytebuf;
}
+ public static int countBytes(int i) { return PacketDataSerializer.a(i); } // Paper - OBFHELPER
public static int a(int i) {
for (int j = 1; j < 5; ++j) {
if ((i & -1 << j * 7) == 0) {
2018-10-03 10:53:27 +08:00
diff --git a/src/main/java/net/minecraft/server/PacketEncoder.java b/src/main/java/net/minecraft/server/PacketEncoder.java
2019-02-24 01:17:41 +08:00
index d54177bdcc..2aa805eef1 100644
2018-10-03 10:53:27 +08:00
--- a/src/main/java/net/minecraft/server/PacketEncoder.java
+++ b/src/main/java/net/minecraft/server/PacketEncoder.java
2019-01-01 11:15:55 +08:00
@@ -42,6 +42,7 @@ public class PacketEncoder extends MessageToByteEncoder<Packet<?>> {
2018-10-03 10:53:27 +08:00
packet.b(packetdataserializer);
} catch (Throwable throwable) {
2019-01-01 11:15:55 +08:00
PacketEncoder.a.error(throwable);
2018-10-03 10:53:27 +08:00
+ throwable.printStackTrace(); // Paper - WHAT WAS IT? WHO DID THIS TO YOU? WHAT DID YOU SEE?
if (packet.a()) {
throw new SkipEncodeException(throwable);
} else {
2018-08-26 10:37:58 +08:00
diff --git a/src/main/java/net/minecraft/server/PacketPlayOutMapChunk.java b/src/main/java/net/minecraft/server/PacketPlayOutMapChunk.java
2019-02-24 01:17:41 +08:00
index 395215bbdd..f2159bc2dd 100644
2018-08-26 10:37:58 +08:00
--- a/src/main/java/net/minecraft/server/PacketPlayOutMapChunk.java
+++ b/src/main/java/net/minecraft/server/PacketPlayOutMapChunk.java
2019-01-01 11:15:55 +08:00
@@ -13,7 +13,7 @@ public class PacketPlayOutMapChunk implements Packet<PacketListenerPlayOut> {
2018-08-26 10:37:58 +08:00
private int a;
private int b;
private int c;
- private byte[] d;
+ private byte[] d; private byte[] getData() { return this.d; } // Paper - OBFHELPER
private List<NBTTagCompound> e;
private boolean f;
2019-01-01 11:15:55 +08:00
@@ -97,6 +97,7 @@ public class PacketPlayOutMapChunk implements Packet<PacketListenerPlayOut> {
2018-08-26 10:37:58 +08:00
return bytebuf;
}
+ public int writeChunk(PacketDataSerializer packetDataSerializer, Chunk chunk, boolean writeSkyLightArray, int chunkSectionSelector) { return this.a(packetDataSerializer, chunk, writeSkyLightArray, chunkSectionSelector); } // Paper - OBFHELPER
public int a(PacketDataSerializer packetdataserializer, Chunk chunk, boolean flag, int i) {
int j = 0;
ChunkSection[] achunksection = chunk.getSections();
2017-10-15 21:00:42 +08:00
diff --git a/src/main/java/net/minecraft/server/PlayerConnection.java b/src/main/java/net/minecraft/server/PlayerConnection.java
2019-03-25 00:33:39 +08:00
index 330e74bb91..d97cc4f727 100644
2017-10-15 21:00:42 +08:00
--- a/src/main/java/net/minecraft/server/PlayerConnection.java
+++ b/src/main/java/net/minecraft/server/PlayerConnection.java
2019-01-01 11:15:55 +08:00
@@ -67,9 +67,9 @@ public class PlayerConnection implements PacketListenerPlayIn, ITickable {
2017-10-15 21:00:42 +08:00
private final MinecraftServer minecraftServer;
public EntityPlayer player;
private int e;
2018-12-17 13:18:06 +08:00
- private long lastKeepAlive;
- private boolean awaitingKeepAlive;
2017-10-15 21:00:42 +08:00
- private long h;
2018-12-17 13:18:06 +08:00
+ private long lastKeepAlive; private void setLastPing(long lastPing) { this.lastKeepAlive = lastPing;}; private long getLastPing() { return this.lastKeepAlive;}; // Paper - OBFHELPER
+ private boolean awaitingKeepAlive; private void setPendingPing(boolean isPending) { this.awaitingKeepAlive = isPending;}; private boolean isPendingPing() { return this.awaitingKeepAlive;}; // Paper - OBFHELPER
2017-10-15 21:00:42 +08:00
+ private long h; private void setKeepAliveID(long keepAliveID) { this.h = keepAliveID;}; private long getKeepAliveID() {return this.h; }; // Paper - OBFHELPER
// CraftBukkit start - multithreaded fields
private volatile int chatThrottle;
private static final AtomicIntegerFieldUpdater chatSpamField = AtomicIntegerFieldUpdater.newUpdater(PlayerConnection.class, "chatThrottle");
2018-10-19 11:24:09 +08:00
diff --git a/src/main/java/net/minecraft/server/PotionUtil.java b/src/main/java/net/minecraft/server/PotionUtil.java
2019-02-24 01:17:41 +08:00
index 6740b396a1..ea08c5a1c8 100644
2018-10-19 11:24:09 +08:00
--- a/src/main/java/net/minecraft/server/PotionUtil.java
+++ b/src/main/java/net/minecraft/server/PotionUtil.java
2019-01-01 11:15:55 +08:00
@@ -110,6 +110,7 @@ public class PotionUtil {
2018-10-19 11:24:09 +08:00
return nbttagcompound == null ? Potions.EMPTY : PotionRegistry.a(nbttagcompound.getString("Potion"));
}
+ public static ItemStack addPotionToItemStack(ItemStack itemstack, PotionRegistry potionregistry) { return a(itemstack, potionregistry); } // Paper - OBFHELPER
public static ItemStack a(ItemStack itemstack, PotionRegistry potionregistry) {
MinecraftKey minecraftkey = IRegistry.POTION.getKey(potionregistry);
2019-01-01 11:15:55 +08:00
2018-07-19 12:42:43 +08:00
diff --git a/src/main/java/net/minecraft/server/RegistryBlockID.java b/src/main/java/net/minecraft/server/RegistryBlockID.java
2019-02-24 01:17:41 +08:00
index a894f7886d..93935e7c77 100644
2018-07-19 12:42:43 +08:00
--- a/src/main/java/net/minecraft/server/RegistryBlockID.java
+++ b/src/main/java/net/minecraft/server/RegistryBlockID.java
2019-01-01 11:15:55 +08:00
@@ -56,6 +56,7 @@ public class RegistryBlockID<T> implements Registry<T> {
2018-08-26 10:37:58 +08:00
return Iterators.filter(this.c.iterator(), Predicates.notNull());
}
+ public int size() { return this.a(); } // Paper - OBFHELPER
public int a() {
return this.b.size();
}
2018-10-04 13:45:11 +08:00
diff --git a/src/main/java/net/minecraft/server/SystemUtils.java b/src/main/java/net/minecraft/server/SystemUtils.java
2019-02-24 01:17:41 +08:00
index 8cb97b894a..5e71d2ac27 100644
2018-10-04 13:45:11 +08:00
--- a/src/main/java/net/minecraft/server/SystemUtils.java
+++ b/src/main/java/net/minecraft/server/SystemUtils.java
2019-01-01 11:15:55 +08:00
@@ -35,8 +35,8 @@ public class SystemUtils {
2018-10-04 13:45:11 +08:00
return Collectors.toMap(Entry::getKey, Entry::getValue);
}
- public static <T extends Comparable<T>> String a(IBlockState<T> iblockstate, Object object) {
2019-01-01 11:15:55 +08:00
- return iblockstate.a((Comparable) object);
+ public static <T extends Comparable<T>> String a(IBlockState<T> iblockstate, T object) {
2018-10-04 13:45:11 +08:00
+ return iblockstate.a(object); // Paper - decompile fix
}
public static String a(String s, @Nullable MinecraftKey minecraftkey) {
2019-01-01 11:15:55 +08:00
@@ -48,7 +48,7 @@ public class SystemUtils {
2018-10-04 13:45:11 +08:00
}
2018-12-17 13:18:06 +08:00
public static long getMonotonicNanos() {
2019-01-01 11:15:55 +08:00
- return SystemUtils.a.getAsLong();
2018-10-04 13:45:11 +08:00
+ return System.nanoTime(); // Paper
}
2018-12-17 13:18:06 +08:00
public static long getTimeMillis() {
2019-01-01 11:15:55 +08:00
@@ -108,7 +108,7 @@ public class SystemUtils {
2018-10-04 13:45:11 +08:00
futuretask.run();
2019-01-01 11:15:55 +08:00
return futuretask.get();
2018-10-04 13:45:11 +08:00
} catch (ExecutionException executionexception) {
- logger.fatal("Error executing task", executionexception);
+ logger.fatal("Error executing task", executionexception.getCause() != null ? executionexception.getCause() : executionexception); // Paper
} catch (InterruptedException interruptedexception) {
logger.fatal("Error executing task", interruptedexception);
}
2019-01-01 11:15:55 +08:00
@@ -144,8 +144,8 @@ public class SystemUtils {
public static <T> T b(Iterable<T> iterable, @Nullable T t0) {
Iterator<T> iterator = iterable.iterator();
- Object object;
- Object object1;
+ T object; // Paper - decompile fix
+ T object1; // Paper - decompile fix
for (object1 = null; iterator.hasNext(); object1 = object) {
object = iterator.next();
@@ -170,7 +170,7 @@ public class SystemUtils {
2018-10-04 13:45:11 +08:00
}
public static <K> Strategy<K> g() {
- return SystemUtils.IdentityHashingStrategy.INSTANCE;
+ return (Strategy<K>) IdentityHashingStrategy.INSTANCE; // Paper - decompile fix
}
static enum IdentityHashingStrategy implements Strategy<Object> {
2016-03-29 09:01:42 +08:00
--
2019-03-25 00:33:39 +08:00
2.21.0
2016-03-29 09:01:42 +08:00
