Upstream Paper

src/main/java/net/minecraft/server/Advancement.java

@@ -0,0 +1,436 @@
+package net.minecraft.server;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonSyntaxException;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.Map.Entry;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import javax.annotation.Nullable;
+import org.apache.commons.lang3.ArrayUtils;
+
+public class Advancement {
+
+    private final Advancement a;
+    private final AdvancementDisplay b;
+    private final AdvancementRewards c;
+    private final MinecraftKey d;
+    private final Map<String, Criterion> e;
+    private final String[][] f;
+    private final Set<Advancement> g = Sets.newLinkedHashSet();
+    private final IChatBaseComponent h;
+    public final org.bukkit.advancement.Advancement bukkit = new org.bukkit.craftbukkit.advancement.CraftAdvancement(this); // CraftBukkit
+
+    public Advancement(MinecraftKey minecraftkey, @Nullable Advancement advancement, @Nullable AdvancementDisplay advancementdisplay, AdvancementRewards advancementrewards, Map<String, Criterion> map, String[][] astring) {
+        this.d = minecraftkey;
+        this.b = advancementdisplay;
+        this.e = ImmutableMap.copyOf(map);
+        this.a = advancement;
+        this.c = advancementrewards;
+        this.f = astring;
+        if (advancement != null) {
+            advancement.a(this);
+        }
+
+        if (advancementdisplay == null) {
+            this.h = new ChatComponentText(minecraftkey.toString());
+        } else {
+            IChatBaseComponent ichatbasecomponent = advancementdisplay.a();
+            EnumChatFormat enumchatformat = advancementdisplay.e().c();
+            IChatBaseComponent ichatbasecomponent1 = ichatbasecomponent.h().a(enumchatformat).a("\n").addSibling(advancementdisplay.b());
+            IChatBaseComponent ichatbasecomponent2 = ichatbasecomponent.h().a((chatmodifier) -> {
+                chatmodifier.setChatHoverable(new ChatHoverable(ChatHoverable.EnumHoverAction.SHOW_TEXT, ichatbasecomponent1));
+            });
+
+            this.h = (new ChatComponentText("[")).addSibling(ichatbasecomponent2).a("]").a(enumchatformat);
+        }
+
+    }
+
+    public Advancement.SerializedAdvancement a() {
+        return new Advancement.SerializedAdvancement(this.a == null ? null : this.a.getName(), this.b, this.c, this.e, this.f);
+    }
+
+    @Nullable
+    public Advancement b() {
+        return this.a;
+    }
+
+    @Nullable
+    public AdvancementDisplay c() {
+        return this.b;
+    }
+
+    public AdvancementRewards d() {
+        return this.c;
+    }
+
+    public String toString() {
+        return "SimpleAdvancement{id=" + this.getName() + ", parent=" + (this.a == null ? "null" : this.a.getName()) + ", display=" + this.b + ", rewards=" + this.c + ", criteria=" + this.e + ", requirements=" + Arrays.deepToString(this.f) + '}';
+    }
+
+    public Iterable<Advancement> e() {
+        return this.g;
+    }
+
+    public Map<String, Criterion> getCriteria() {
+        return this.e;
+    }
+
+    public void a(Advancement advancement) {
+        this.g.add(advancement);
+    }
+
+    public MinecraftKey getName() {
+        return this.d;
+    }
+
+    public boolean equals(Object object) {
+        if (this == object) {
+            return true;
+        } else if (!(object instanceof Advancement)) {
+            return false;
+        } else {
+            Advancement advancement = (Advancement) object;
+
+            return this.d.equals(advancement.d);
+        }
+    }
+
+    public int hashCode() {
+        return this.d.hashCode();
+    }
+
+    public String[][] i() {
+        return this.f;
+    }
+
+    public IChatBaseComponent j() {
+        return this.h;
+    }
+
+    public static class SerializedAdvancement {
+
+        private MinecraftKey a;
+        private Advancement b;
+        private AdvancementDisplay c;
+        private AdvancementRewards d;
+        private Map<String, Criterion> e;
+        private String[][] f;
+        private AdvancementRequirements g;
+
+        private SerializedAdvancement(@Nullable MinecraftKey minecraftkey, @Nullable AdvancementDisplay advancementdisplay, AdvancementRewards advancementrewards, Map<String, Criterion> map, String[][] astring) {
+            this.d = AdvancementRewards.a;
+            this.e = Maps.newLinkedHashMap();
+            this.g = AdvancementRequirements.AND;
+            this.a = minecraftkey;
+            this.c = advancementdisplay;
+            this.d = advancementrewards;
+            this.e = map;
+            this.f = astring;
+        }
+
+        private SerializedAdvancement() {
+            this.d = AdvancementRewards.a;
+            this.e = Maps.newLinkedHashMap();
+            this.g = AdvancementRequirements.AND;
+        }
+
+        public static Advancement.SerializedAdvancement a() {
+            return new Advancement.SerializedAdvancement();
+        }
+
+        public Advancement.SerializedAdvancement a(Advancement advancement) {
+            this.b = advancement;
+            return this;
+        }
+
+        public Advancement.SerializedAdvancement a(MinecraftKey minecraftkey) {
+            this.a = minecraftkey;
+            return this;
+        }
+
+        public Advancement.SerializedAdvancement a(IMaterial imaterial, IChatBaseComponent ichatbasecomponent, IChatBaseComponent ichatbasecomponent1, @Nullable MinecraftKey minecraftkey, AdvancementFrameType advancementframetype, boolean flag, boolean flag1, boolean flag2) {
+            return this.a(new AdvancementDisplay(new ItemStack(imaterial.getItem()), ichatbasecomponent, ichatbasecomponent1, minecraftkey, advancementframetype, flag, flag1, flag2));
+        }
+
+        public Advancement.SerializedAdvancement a(AdvancementDisplay advancementdisplay) {
+            this.c = advancementdisplay;
+            return this;
+        }
+
+        public Advancement.SerializedAdvancement a(AdvancementRewards.a advancementrewards_a) {
+            return this.a(advancementrewards_a.a());
+        }
+
+        public Advancement.SerializedAdvancement a(AdvancementRewards advancementrewards) {
+            this.d = advancementrewards;
+            return this;
+        }
+
+        public Advancement.SerializedAdvancement a(String s, CriterionInstance criterioninstance) {
+            return this.a(s, new Criterion(criterioninstance));
+        }
+
+        public Advancement.SerializedAdvancement a(String s, Criterion criterion) {
+            if (this.e.containsKey(s)) {
+                throw new IllegalArgumentException("Duplicate criterion " + s);
+            } else {
+                this.e.put(s, criterion);
+                return this;
+            }
+        }
+
+        public Advancement.SerializedAdvancement a(AdvancementRequirements advancementrequirements) {
+            this.g = advancementrequirements;
+            return this;
+        }
+
+        public boolean a(Function<MinecraftKey, Advancement> function) {
+            if (this.a == null) {
+                return true;
+            } else {
+                if (this.b == null) {
+                    this.b = (Advancement) function.apply(this.a);
+                }
+
+                return this.b != null;
+            }
+        }
+
+        public Advancement b(MinecraftKey minecraftkey) {
+            if (!this.a((Function<MinecraftKey, Advancement>) (minecraftkey1) -> { // CraftBukkit - decompile error
+                return null;
+            })) {
+                throw new IllegalStateException("Tried to build incomplete advancement!");
+            } else {
+                if (this.f == null) {
+                    this.f = this.g.createRequirements(this.e.keySet());
+                }
+
+                return new Advancement(minecraftkey, this.b, this.c, this.d, this.e, this.f);
+            }
+        }
+
+        public Advancement a(Consumer<Advancement> consumer, String s) {
+            Advancement advancement = this.b(new MinecraftKey(s));
+
+            consumer.accept(advancement);
+            return advancement;
+        }
+
+        public JsonObject b() {
+            if (this.f == null) {
+                this.f = this.g.createRequirements(this.e.keySet());
+            }
+
+            JsonObject jsonobject = new JsonObject();
+
+            if (this.b != null) {
+                jsonobject.addProperty("parent", this.b.getName().toString());
+            } else if (this.a != null) {
+                jsonobject.addProperty("parent", this.a.toString());
+            }
+
+            if (this.c != null) {
+                jsonobject.add("display", this.c.k());
+            }
+
+            jsonobject.add("rewards", this.d.b());
+            JsonObject jsonobject1 = new JsonObject();
+            Iterator iterator = this.e.entrySet().iterator();
+
+            while (iterator.hasNext()) {
+                Entry<String, Criterion> entry = (Entry) iterator.next();
+
+                jsonobject1.add((String) entry.getKey(), ((Criterion) entry.getValue()).b());
+            }
+
+            jsonobject.add("criteria", jsonobject1);
+            JsonArray jsonarray = new JsonArray();
+            String[][] astring = this.f;
+            int i = astring.length;
+
+            for (int j = 0; j < i; ++j) {
+                String[] astring1 = astring[j];
+                JsonArray jsonarray1 = new JsonArray();
+                String[] astring2 = astring1;
+                int k = astring1.length;
+
+                for (int l = 0; l < k; ++l) {
+                    String s = astring2[l];
+
+                    jsonarray1.add(s);
+                }
+
+                jsonarray.add(jsonarray1);
+            }
+
+            jsonobject.add("requirements", jsonarray);
+            return jsonobject;
+        }
+
+        public void a(PacketDataSerializer packetdataserializer) {
+            if (this.a == null) {
+                packetdataserializer.writeBoolean(false);
+            } else {
+                packetdataserializer.writeBoolean(true);
+                packetdataserializer.a(this.a);
+            }
+
+            if (this.c == null) {
+                packetdataserializer.writeBoolean(false);
+            } else {
+                packetdataserializer.writeBoolean(true);
+                this.c.a(packetdataserializer);
+            }
+
+            Criterion.a(this.e, packetdataserializer);
+            packetdataserializer.d(this.f.length);
+            String[][] astring = this.f;
+            int i = astring.length;
+
+            for (int j = 0; j < i; ++j) {
+                String[] astring1 = astring[j];
+
+                packetdataserializer.d(astring1.length);
+                String[] astring2 = astring1;
+                int k = astring1.length;
+
+                for (int l = 0; l < k; ++l) {
+                    String s = astring2[l];
+
+                    packetdataserializer.a(s);
+                }
+            }
+
+        }
+
+        public String toString() {
+            return "Task Advancement{parentId=" + this.a + ", display=" + this.c + ", rewards=" + this.d + ", criteria=" + this.e + ", requirements=" + Arrays.deepToString(this.f) + '}';
+        }
+
+        public static Advancement.SerializedAdvancement a(JsonObject jsonobject, JsonDeserializationContext jsondeserializationcontext) {
+            MinecraftKey minecraftkey = jsonobject.has("parent") ? new MinecraftKey(ChatDeserializer.h(jsonobject, "parent")) : null;
+            AdvancementDisplay advancementdisplay = jsonobject.has("display") ? AdvancementDisplay.a(ChatDeserializer.t(jsonobject, "display"), jsondeserializationcontext) : null;
+            AdvancementRewards advancementrewards = (AdvancementRewards) ChatDeserializer.a(jsonobject, "rewards", AdvancementRewards.a, jsondeserializationcontext, AdvancementRewards.class);
+            Map<String, Criterion> map = Criterion.b(ChatDeserializer.t(jsonobject, "criteria"), jsondeserializationcontext);
+
+            if (map.isEmpty()) {
+                throw new JsonSyntaxException("Advancement criteria cannot be empty");
+            } else {
+                JsonArray jsonarray = ChatDeserializer.a(jsonobject, "requirements", new JsonArray());
+                String[][] astring = new String[jsonarray.size()][];
+
+                int i;
+                int j;
+
+                for (i = 0; i < jsonarray.size(); ++i) {
+                    JsonArray jsonarray1 = ChatDeserializer.n(jsonarray.get(i), "requirements[" + i + "]");
+
+                    astring[i] = new String[jsonarray1.size()];
+
+                    for (j = 0; j < jsonarray1.size(); ++j) {
+                        astring[i][j] = ChatDeserializer.a(jsonarray1.get(j), "requirements[" + i + "][" + j + "]");
+                    }
+                }
+
+                if (astring.length == 0) {
+                    astring = new String[map.size()][];
+                    i = 0;
+
+                    String s;
+
+                    for (Iterator iterator = map.keySet().iterator(); iterator.hasNext(); astring[i++] = new String[] { s}) {
+                        s = (String) iterator.next();
+                    }
+                }
+
+                String[][] astring1 = astring;
+                int k = astring.length;
+
+                int l;
+
+                for (j = 0; j < k; ++j) {
+                    String[] astring2 = astring1[j];
+
+                    if (astring2.length == 0 && map.isEmpty()) {
+                        throw new JsonSyntaxException("Requirement entry cannot be empty");
+                    }
+
+                    String[] astring3 = astring2;
+
+                    l = astring2.length;
+
+                    for (int i1 = 0; i1 < l; ++i1) {
+                        String s1 = astring3[i1];
+
+                        if (!map.containsKey(s1)) {
+                            throw new JsonSyntaxException("Unknown required criterion '" + s1 + "'");
+                        }
+                    }
+                }
+
+                Iterator iterator1 = map.keySet().iterator();
+
+                while (iterator1.hasNext()) {
+                    String s2 = (String) iterator1.next();
+                    boolean flag = false;
+                    String[][] astring4 = astring;
+                    int j1 = astring.length;
+
+                    l = 0;
+
+                    while (true) {
+                        if (l < j1) {
+                            String[] astring5 = astring4[l];
+
+                            if (!ArrayUtils.contains(astring5, s2)) {
+                                ++l;
+                                continue;
+                            }
+
+                            flag = true;
+                        }
+
+                        if (!flag) {
+                            throw new JsonSyntaxException("Criterion '" + s2 + "' isn't a requirement for completion. This isn't supported behaviour, all criteria must be required.");
+                        }
+                        break;
+                    }
+                }
+
+                return new Advancement.SerializedAdvancement(minecraftkey, advancementdisplay, advancementrewards, map, astring);
+            }
+        }
+
+        public static Advancement.SerializedAdvancement b(PacketDataSerializer packetdataserializer) {
+            MinecraftKey minecraftkey = packetdataserializer.readBoolean() ? packetdataserializer.l() : null;
+            AdvancementDisplay advancementdisplay = packetdataserializer.readBoolean() ? AdvancementDisplay.b(packetdataserializer) : null;
+            Map<String, Criterion> map = Criterion.c(packetdataserializer);
+            String[][] astring = new String[packetdataserializer.g()][];
+
+            for (int i = 0; i < astring.length; ++i) {
+                astring[i] = new String[packetdataserializer.g()];
+
+                for (int j = 0; j < astring[i].length; ++j) {
+                    astring[i][j] = packetdataserializer.e(32767);
+                }
+            }
+
+            return new Advancement.SerializedAdvancement(minecraftkey, advancementdisplay, AdvancementRewards.a, map, astring);
+        }
+
+        public Map<String, Criterion> c() {
+            return this.e;
+        }
+    }
+}

src/main/java/net/minecraft/server/AdvancementDataPlayer.java

@@ -0,0 +1,466 @@
+package net.minecraft.server;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.common.io.Files;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonParseException;
+import com.google.gson.internal.Streams;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.stream.JsonReader;
+import com.mojang.datafixers.DataFixTypes;
+import com.mojang.datafixers.Dynamic;
+import com.mojang.datafixers.types.JsonOps;
+import java.io.File;
+import java.io.IOException;
+import java.io.StringReader;
+import java.nio.charset.StandardCharsets;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.Map.Entry;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import javax.annotation.Nullable;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+public class AdvancementDataPlayer {
+
+    private static final Logger a = LogManager.getLogger();
+    private static final Gson b = (new GsonBuilder()).registerTypeAdapter(AdvancementProgress.class, new AdvancementProgress.a()).registerTypeAdapter(MinecraftKey.class, new MinecraftKey.a()).setPrettyPrinting().create();
+    private static final TypeToken<Map<MinecraftKey, AdvancementProgress>> c = new TypeToken<Map<MinecraftKey, AdvancementProgress>>() {
+    };
+    private final MinecraftServer d;
+    private final File e;
+    public final Map<Advancement, AdvancementProgress> data = Maps.newLinkedHashMap();
+    private final Set<Advancement> g = Sets.newLinkedHashSet();
+    private final Set<Advancement> h = Sets.newLinkedHashSet();
+    private final Set<Advancement> i = Sets.newLinkedHashSet();
+    private EntityPlayer player;
+    @Nullable
+    private Advancement k;
+    private boolean l = true;
+
+    public AdvancementDataPlayer(MinecraftServer minecraftserver, File file, EntityPlayer entityplayer) {
+        this.d = minecraftserver;
+        this.e = file;
+        this.player = entityplayer;
+        this.g();
+    }
+
+    public void a(EntityPlayer entityplayer) {
+        this.player = entityplayer;
+    }
+
+    public void a() {
+        Iterator iterator = CriterionTriggers.a().iterator();
+
+        while (iterator.hasNext()) {
+            CriterionTrigger<?> criteriontrigger = (CriterionTrigger) iterator.next();
+
+            criteriontrigger.a(this);
+        }
+
+    }
+
+    public void b() {
+        this.a();
+        this.data.clear();
+        this.g.clear();
+        this.h.clear();
+        this.i.clear();
+        this.l = true;
+        this.k = null;
+        this.g();
+    }
+
+    private void d() {
+        Iterator iterator = this.d.getAdvancementData().b().iterator();
+
+        while (iterator.hasNext()) {
+            Advancement advancement = (Advancement) iterator.next();
+
+            this.c(advancement);
+        }
+
+    }
+
+    private void e() {
+        List<Advancement> list = Lists.newArrayList();
+        Iterator iterator = this.data.entrySet().iterator();
+
+        while (iterator.hasNext()) {
+            Entry<Advancement, AdvancementProgress> entry = (Entry) iterator.next();
+
+            if (((AdvancementProgress) entry.getValue()).isDone()) {
+                list.add(entry.getKey());
+                this.i.add(entry.getKey());
+            }
+        }
+
+        iterator = list.iterator();
+
+        while (iterator.hasNext()) {
+            Advancement advancement = (Advancement) iterator.next();
+
+            this.e(advancement);
+        }
+
+    }
+
+    private void f() {
+        Iterator iterator = this.d.getAdvancementData().b().iterator();
+
+        while (iterator.hasNext()) {
+            Advancement advancement = (Advancement) iterator.next();
+
+            if (advancement.getCriteria().isEmpty()) {
+                this.grantCriteria(advancement, "");
+                advancement.d().a(this.player);
+            }
+        }
+
+    }
+
+    private void g() {
+        if (this.e.isFile()) {
+            try {
+                JsonReader jsonreader = new JsonReader(new StringReader(Files.toString(this.e, StandardCharsets.UTF_8)));
+                Throwable throwable = null;
+
+                try {
+                    jsonreader.setLenient(false);
+                    Dynamic<JsonElement> dynamic = new Dynamic(JsonOps.INSTANCE, Streams.parse(jsonreader));
+
+                    if (!dynamic.get("DataVersion").flatMap(Dynamic::getNumberValue).isPresent()) {
+                        dynamic = dynamic.set("DataVersion", dynamic.createInt(1343));
+                    }
+
+                    dynamic = this.d.az().update(DataFixTypes.ADVANCEMENTS, dynamic, dynamic.getInt("DataVersion"), 1631);
+                    dynamic = dynamic.remove("DataVersion");
+                    Map<MinecraftKey, AdvancementProgress> map = (Map) AdvancementDataPlayer.b.getAdapter(AdvancementDataPlayer.c).fromJsonTree((JsonElement) dynamic.getValue());
+
+                    if (map == null) {
+                        throw new JsonParseException("Found null for advancements");
+                    }
+
+                    Stream<Entry<MinecraftKey, AdvancementProgress>> stream = map.entrySet().stream().sorted(Comparator.comparing(Entry::getValue));
+                    Iterator iterator = ((List) stream.collect(Collectors.toList())).iterator();
+
+                    while (iterator.hasNext()) {
+                        Entry<MinecraftKey, AdvancementProgress> entry = (Entry) iterator.next();
+                        Advancement advancement = this.d.getAdvancementData().a((MinecraftKey) entry.getKey());
+
+                        if (advancement == null) {
+                            // CraftBukkit start
+                            if (((MinecraftKey) entry.getKey()).b().equals("minecraft")) {
+                                AdvancementDataPlayer.a.warn("Ignored advancement '{}' in progress file {} - it doesn't exist anymore?", entry.getKey(), this.e);
+                            }
+                            // CraftBukkit end
+                        } else {
+                            this.a(advancement, (AdvancementProgress) entry.getValue());
+                        }
+                    }
+                } catch (Throwable throwable1) {
+                    throwable = throwable1;
+                    throw throwable1;
+                } finally {
+                    if (jsonreader != null) {
+                        if (throwable != null) {
+                            try {
+                                jsonreader.close();
+                            } catch (Throwable throwable2) {
+                                throwable.addSuppressed(throwable2);
+                            }
+                        } else {
+                            jsonreader.close();
+                        }
+                    }
+
+                }
+            } catch (JsonParseException jsonparseexception) {
+                AdvancementDataPlayer.a.error("Couldn't parse player advancements in {}", this.e, jsonparseexception);
+            } catch (IOException ioexception) {
+                AdvancementDataPlayer.a.error("Couldn't access player advancements in {}", this.e, ioexception);
+            }
+        }
+
+        this.f();
+        this.e();
+        this.d();
+    }
+
+    public void c() {
+        if (org.spigotmc.SpigotConfig.disableAdvancementSaving) return;
+        Map<MinecraftKey, AdvancementProgress> map = Maps.newHashMap();
+        Iterator iterator = this.data.entrySet().iterator();
+
+        while (iterator.hasNext()) {
+            Entry<Advancement, AdvancementProgress> entry = (Entry) iterator.next();
+            AdvancementProgress advancementprogress = (AdvancementProgress) entry.getValue();
+
+            if (advancementprogress.b()) {
+                map.put(((Advancement) entry.getKey()).getName(), advancementprogress);
+            }
+        }
+
+        if (this.e.getParentFile() != null) {
+            this.e.getParentFile().mkdirs();
+        }
+
+        try {
+            Files.write(AdvancementDataPlayer.b.toJson(map), this.e, StandardCharsets.UTF_8);
+        } catch (IOException ioexception) {
+            AdvancementDataPlayer.a.error("Couldn't save player advancements to {}", this.e, ioexception);
+        }
+
+    }
+
+    public boolean grantCriteria(Advancement advancement, String s) {
+        boolean flag = false;
+        AdvancementProgress advancementprogress = this.getProgress(advancement);
+        boolean flag1 = advancementprogress.isDone();
+
+        if (advancementprogress.a(s)) {
+            // Paper start
+            if (!new com.destroystokyo.paper.event.player.PlayerAdvancementCriterionGrantEvent(this.player.getBukkitEntity(), advancement.bukkit, s).callEvent()) {
+                advancementprogress.b(s);
+                return false;
+            }
+            // Paper end
+            this.d(advancement);
+            this.i.add(advancement);
+            flag = true;
+            if (!flag1 && advancementprogress.isDone()) {
+                this.player.world.getServer().getPluginManager().callEvent(new org.bukkit.event.player.PlayerAdvancementDoneEvent(this.player.getBukkitEntity(), advancement.bukkit)); // CraftBukkit
+                advancement.d().a(this.player);
+                if (advancement.c() != null && advancement.c().i() && this.player.world.getGameRules().getBoolean("announceAdvancements")) {
+                    this.d.getPlayerList().sendMessage(new ChatMessage("chat.type.advancement." + advancement.c().e().a(), new Object[] { this.player.getScoreboardDisplayName(), advancement.j()}));
+                }
+            }
+        }
+
+        if (advancementprogress.isDone()) {
+            this.e(advancement);
+        }
+
+        return flag;
+    }
+
+    public boolean revokeCritera(Advancement advancement, String s) {
+        boolean flag = false;
+        AdvancementProgress advancementprogress = this.getProgress(advancement);
+
+        if (advancementprogress.b(s)) {
+            this.c(advancement);
+            this.i.add(advancement);
+            flag = true;
+        }
+
+        if (!advancementprogress.b()) {
+            this.e(advancement);
+        }
+
+        return flag;
+    }
+
+    private void c(Advancement advancement) {
+        AdvancementProgress advancementprogress = this.getProgress(advancement);
+
+        if (!advancementprogress.isDone()) {
+            Iterator iterator = advancement.getCriteria().entrySet().iterator();
+
+            while (iterator.hasNext()) {
+                Entry<String, Criterion> entry = (Entry) iterator.next();
+                CriterionProgress criterionprogress = advancementprogress.getCriterionProgress((String) entry.getKey());
+
+                if (criterionprogress != null && !criterionprogress.a()) {
+                    CriterionInstance criterioninstance = ((Criterion) entry.getValue()).a();
+
+                    if (criterioninstance != null) {
+                        CriterionTrigger<CriterionInstance> criteriontrigger = CriterionTriggers.a(criterioninstance.a());
+
+                        if (criteriontrigger != null) {
+                            criteriontrigger.a(this, new CriterionTrigger.a<>(criterioninstance, advancement, (String) entry.getKey()));
+                        }
+                    }
+                }
+            }
+
+        }
+    }
+
+    private void d(Advancement advancement) {
+        AdvancementProgress advancementprogress = this.getProgress(advancement);
+        Iterator iterator = advancement.getCriteria().entrySet().iterator();
+
+        while (iterator.hasNext()) {
+            Entry<String, Criterion> entry = (Entry) iterator.next();
+            CriterionProgress criterionprogress = advancementprogress.getCriterionProgress((String) entry.getKey());
+
+            if (criterionprogress != null && (criterionprogress.a() || advancementprogress.isDone())) {
+                CriterionInstance criterioninstance = ((Criterion) entry.getValue()).a();
+
+                if (criterioninstance != null) {
+                    CriterionTrigger<CriterionInstance> criteriontrigger = CriterionTriggers.a(criterioninstance.a());
+
+                    if (criteriontrigger != null) {
+                        criteriontrigger.b(this, new CriterionTrigger.a<>(criterioninstance, advancement, (String) entry.getKey()));
+                    }
+                }
+            }
+        }
+
+    }
+
+    public void b(EntityPlayer entityplayer) {
+        if (this.l || !this.h.isEmpty() || !this.i.isEmpty()) {
+            Map<MinecraftKey, AdvancementProgress> map = Maps.newHashMap();
+            Set<Advancement> set = Sets.newLinkedHashSet();
+            Set<MinecraftKey> set1 = Sets.newLinkedHashSet();
+            Iterator iterator = this.i.iterator();
+
+            Advancement advancement;
+
+            while (iterator.hasNext()) {
+                advancement = (Advancement) iterator.next();
+                if (this.g.contains(advancement)) {
+                    map.put(advancement.getName(), this.data.get(advancement));
+                }
+            }
+
+            iterator = this.h.iterator();
+
+            while (iterator.hasNext()) {
+                advancement = (Advancement) iterator.next();
+                if (this.g.contains(advancement)) {
+                    set.add(advancement);
+                } else {
+                    set1.add(advancement.getName());
+                }
+            }
+
+            if (this.l || !map.isEmpty() || !set.isEmpty() || !set1.isEmpty()) {
+                entityplayer.playerConnection.sendPacket(new PacketPlayOutAdvancements(this.l, set, set1, map));
+                this.h.clear();
+                this.i.clear();
+            }
+        }
+
+        this.l = false;
+    }
+
+    public void a(@Nullable Advancement advancement) {
+        Advancement advancement1 = this.k;
+
+        if (advancement != null && advancement.b() == null && advancement.c() != null) {
+            this.k = advancement;
+        } else {
+            this.k = null;
+        }
+
+        if (advancement1 != this.k) {
+            this.player.playerConnection.sendPacket(new PacketPlayOutSelectAdvancementTab(this.k == null ? null : this.k.getName()));
+        }
+
+    }
+
+    public AdvancementProgress getProgress(Advancement advancement) {
+        AdvancementProgress advancementprogress = (AdvancementProgress) this.data.get(advancement);
+
+        if (advancementprogress == null) {
+            advancementprogress = new AdvancementProgress();
+            this.a(advancement, advancementprogress);
+        }
+
+        return advancementprogress;
+    }
+
+    private void a(Advancement advancement, AdvancementProgress advancementprogress) {
+        advancementprogress.a(advancement.getCriteria(), advancement.i());
+        this.data.put(advancement, advancementprogress);
+    }
+
+    private void e(Advancement advancement) {
+        boolean flag = this.f(advancement);
+        boolean flag1 = this.g.contains(advancement);
+
+        if (flag && !flag1) {
+            this.g.add(advancement);
+            this.h.add(advancement);
+            if (this.data.containsKey(advancement)) {
+                this.i.add(advancement);
+            }
+        } else if (!flag && flag1) {
+            this.g.remove(advancement);
+            this.h.add(advancement);
+        }
+
+        if (flag != flag1 && advancement.b() != null) {
+            this.e(advancement.b());
+        }
+
+        Iterator iterator = advancement.e().iterator();
+
+        while (iterator.hasNext()) {
+            Advancement advancement1 = (Advancement) iterator.next();
+
+            this.e(advancement1);
+        }
+
+    }
+
+    private boolean f(Advancement advancement) {
+        for (int i = 0; advancement != null && i <= 2; ++i) {
+            if (i == 0 && this.g(advancement)) {
+                return true;
+            }
+
+            if (advancement.c() == null) {
+                return false;
+            }
+
+            AdvancementProgress advancementprogress = this.getProgress(advancement);
+
+            if (advancementprogress.isDone()) {
+                return true;
+            }
+
+            if (advancement.c().j()) {
+                return false;
+            }
+
+            advancement = advancement.b();
+        }
+
+        return false;
+    }
+
+    private boolean g(Advancement advancement) {
+        AdvancementProgress advancementprogress = this.getProgress(advancement);
+
+        if (advancementprogress.isDone()) {
+            return true;
+        } else {
+            Iterator iterator = advancement.e().iterator();
+
+            Advancement advancement1;
+
+            do {
+                if (!iterator.hasNext()) {
+                    return false;
+                }
+
+                advancement1 = (Advancement) iterator.next();
+            } while (!this.g(advancement1));
+
+            return true;
+        }
+    }
+}

src/main/java/net/minecraft/server/AdvancementDataWorld.java

@@ -0,0 +1,119 @@
+package net.minecraft.server;
+
+import com.google.common.collect.Maps;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParseException;
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.nio.charset.StandardCharsets;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+import javax.annotation.Nullable;
+import org.apache.commons.io.IOUtils;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+public class AdvancementDataWorld implements IResourcePackListener {
+
+    private static final Logger c = LogManager.getLogger();
+    public static final Gson DESERIALIZER = (new GsonBuilder()).registerTypeHierarchyAdapter(Advancement.SerializedAdvancement.class, (com.google.gson.JsonDeserializer) (jsonelement, type, jsondeserializationcontext) -> {
+        JsonObject jsonobject = ChatDeserializer.m(jsonelement, "advancement");
+
+        return Advancement.SerializedAdvancement.a(jsonobject, jsondeserializationcontext);
+    }).registerTypeAdapter(AdvancementRewards.class, new AdvancementRewards.b()).registerTypeHierarchyAdapter(IChatBaseComponent.class, new IChatBaseComponent.ChatSerializer()).registerTypeHierarchyAdapter(ChatModifier.class, new ChatModifier.ChatModifierSerializer()).registerTypeAdapterFactory(new ChatTypeAdapterFactory()).create();
+    public static final Advancements REGISTRY = new Advancements();
+    public static final int a = "advancements/".length();
+    public static final int b = ".json".length();
+    private boolean f;
+
+    public AdvancementDataWorld() {}
+
+    private Map<MinecraftKey, Advancement.SerializedAdvancement> b(IResourceManager iresourcemanager) {
+        Map<MinecraftKey, Advancement.SerializedAdvancement> map = Maps.newHashMap();
+        Iterator iterator = iresourcemanager.a("advancements", (s) -> {
+            return s.endsWith(".json");
+        }).iterator();
+
+        while (iterator.hasNext()) {
+            MinecraftKey minecraftkey = (MinecraftKey) iterator.next();
+            String s = minecraftkey.getKey();
+            MinecraftKey minecraftkey1 = new MinecraftKey(minecraftkey.b(), s.substring(AdvancementDataWorld.a, s.length() - AdvancementDataWorld.b));
+
+            try {
+                IResource iresource = iresourcemanager.a(minecraftkey);
+                Throwable throwable = null;
+                // Spigot start
+                if (org.spigotmc.SpigotConfig.disabledAdvancements != null && (org.spigotmc.SpigotConfig.disabledAdvancements.contains("*") || org.spigotmc.SpigotConfig.disabledAdvancements.contains(minecraftkey.toString()))) {
+                    continue;
+                }
+                // Spigot end
+
+                try {
+                    Advancement.SerializedAdvancement advancement_serializedadvancement = (Advancement.SerializedAdvancement) ChatDeserializer.a(AdvancementDataWorld.DESERIALIZER, IOUtils.toString(iresource.b(), StandardCharsets.UTF_8), Advancement.SerializedAdvancement.class);
+
+                    if (advancement_serializedadvancement == null) {
+                        AdvancementDataWorld.c.error("Couldn't load custom advancement {} from {} as it's empty or null", minecraftkey1, minecraftkey);
+                    } else {
+                        map.put(minecraftkey1, advancement_serializedadvancement);
+                    }
+                } catch (Throwable throwable1) {
+                    throwable = throwable1;
+                    throw throwable1;
+                } finally {
+                    if (iresource != null) {
+                        if (throwable != null) {
+                            try {
+                                iresource.close();
+                            } catch (Throwable throwable2) {
+                                throwable.addSuppressed(throwable2);
+                            }
+                        } else {
+                            iresource.close();
+                        }
+                    }
+
+                }
+            } catch (IllegalArgumentException | JsonParseException jsonparseexception) {
+                AdvancementDataWorld.c.error("Parsing error loading custom advancement {}: {}", minecraftkey1, jsonparseexception.getMessage());
+                this.f = true;
+            } catch (IOException ioexception) {
+                AdvancementDataWorld.c.error("Couldn't read custom advancement {} from {}", minecraftkey1, minecraftkey, ioexception);
+                this.f = true;
+            }
+        }
+
+        return map;
+    }
+
+    @Nullable
+    public Advancement a(MinecraftKey minecraftkey) {
+        return AdvancementDataWorld.REGISTRY.a(minecraftkey);
+    }
+
+    public Collection<Advancement> b() {
+        return AdvancementDataWorld.REGISTRY.c();
+    }
+
+    public void a(IResourceManager iresourcemanager) {
+        this.f = false;
+        AdvancementDataWorld.REGISTRY.a();
+        Map<MinecraftKey, Advancement.SerializedAdvancement> map = this.b(iresourcemanager);
+
+        AdvancementDataWorld.REGISTRY.a(map);
+        Iterator iterator = AdvancementDataWorld.REGISTRY.b().iterator();
+
+        while (iterator.hasNext()) {
+            Advancement advancement = (Advancement) iterator.next();
+
+            if (advancement.c() != null) {
+                AdvancementTree.a(advancement);
+            }
+        }
+
+    }
+}

src/main/java/net/minecraft/server/Advancements.java

@@ -0,0 +1,109 @@
+package net.minecraft.server;
+
+import com.google.common.base.Function;
+import com.google.common.base.Functions;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.Map.Entry;
+import javax.annotation.Nullable;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+public class Advancements {
+
+    private static final Logger a = LogManager.getLogger();
+    public final Map<MinecraftKey, Advancement> advancements = Maps.newHashMap();
+    private final Set<Advancement> c = Sets.newLinkedHashSet();
+    private final Set<Advancement> d = Sets.newLinkedHashSet();
+    private Advancements.a e;
+
+    public Advancements() {}
+
+    public void a(Map<MinecraftKey, Advancement.SerializedAdvancement> map) {
+        Function function = Functions.forMap(this.advancements, (Object) null);
+
+        label42:
+        while (!map.isEmpty()) {
+            boolean flag = false;
+            Iterator iterator = map.entrySet().iterator();
+
+            Entry entry;
+
+            while (iterator.hasNext()) {
+                entry = (Entry) iterator.next();
+                MinecraftKey minecraftkey = (MinecraftKey) entry.getKey();
+                Advancement.SerializedAdvancement advancement_serializedadvancement = (Advancement.SerializedAdvancement) entry.getValue();
+
+                if (advancement_serializedadvancement.a((java.util.function.Function) function)) {
+                    Advancement advancement = advancement_serializedadvancement.b(minecraftkey);
+
+                    this.advancements.put(minecraftkey, advancement);
+                    flag = true;
+                    iterator.remove();
+                    if (advancement.b() == null) {
+                        this.c.add(advancement);
+                        if (this.e != null) {
+                            this.e.a(advancement);
+                        }
+                    } else {
+                        this.d.add(advancement);
+                        if (this.e != null) {
+                            this.e.c(advancement);
+                        }
+                    }
+                }
+            }
+
+            if (!flag) {
+                iterator = map.entrySet().iterator();
+
+                while (true) {
+                    if (!iterator.hasNext()) {
+                        break label42;
+                    }
+
+                    entry = (Entry) iterator.next();
+                    Advancements.a.error("Couldn't load advancement {}: {}", entry.getKey(), entry.getValue());
+                }
+            }
+        }
+
+        // Advancements.a.info("Loaded {} advancements", this.advancements.size()); // CraftBukkit - moved to AdvancementDataWorld#reload
+    }
+
+    public void a() {
+        this.advancements.clear();
+        this.c.clear();
+        this.d.clear();
+        if (this.e != null) {
+            this.e.a();
+        }
+
+    }
+
+    public Iterable<Advancement> b() {
+        return this.c;
+    }
+
+    public Collection<Advancement> c() {
+        return this.advancements.values();
+    }
+
+    @Nullable
+    public Advancement a(MinecraftKey minecraftkey) {
+        return (Advancement) this.advancements.get(minecraftkey);
+    }
+
+    public interface a {
+
+        void a(Advancement advancement);
+
+        void c(Advancement advancement);
+
+        void a();
+    }
+}

src/main/java/net/minecraft/server/ArgumentBlock.java

@@ -0,0 +1,541 @@
+package net.minecraft.server;
+
+import com.google.common.collect.Maps;
+import com.google.common.collect.UnmodifiableIterator;
+import com.mojang.brigadier.StringReader;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import com.mojang.brigadier.exceptions.Dynamic2CommandExceptionType;
+import com.mojang.brigadier.exceptions.Dynamic3CommandExceptionType;
+import com.mojang.brigadier.exceptions.DynamicCommandExceptionType;
+import com.mojang.brigadier.exceptions.SimpleCommandExceptionType;
+import com.mojang.brigadier.suggestion.Suggestions;
+import com.mojang.brigadier.suggestion.SuggestionsBuilder;
+import java.util.Iterator;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Map.Entry;
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Function;
+import javax.annotation.Nullable;
+
+public class ArgumentBlock {
+
+    public static final SimpleCommandExceptionType a = new SimpleCommandExceptionType(new ChatMessage("argument.block.tag.disallowed", new Object[0]));
+    public static final DynamicCommandExceptionType b = new DynamicCommandExceptionType((object) -> {
+        return new ChatMessage("argument.block.id.invalid", new Object[] { object});
+    });
+    public static final Dynamic2CommandExceptionType c = new Dynamic2CommandExceptionType((object, object1) -> {
+        return new ChatMessage("argument.block.property.unknown", new Object[] { object, object1});
+    });
+    public static final Dynamic2CommandExceptionType d = new Dynamic2CommandExceptionType((object, object1) -> {
+        return new ChatMessage("argument.block.property.duplicate", new Object[] { object1, object});
+    });
+    public static final Dynamic3CommandExceptionType e = new Dynamic3CommandExceptionType((object, object1, object2) -> {
+        return new ChatMessage("argument.block.property.invalid", new Object[] { object, object2, object1});
+    });
+    public static final Dynamic2CommandExceptionType f = new Dynamic2CommandExceptionType((object, object1) -> {
+        return new ChatMessage("argument.block.property.novalue", new Object[] { object, object1});
+    });
+    public static final SimpleCommandExceptionType g = new SimpleCommandExceptionType(new ChatMessage("argument.block.property.unclosed", new Object[0]));
+    private static final Function<SuggestionsBuilder, CompletableFuture<Suggestions>> h = SuggestionsBuilder::buildFuture;
+    private final StringReader i;
+    private final boolean j;
+    private final Map<IBlockState<?>, Comparable<?>> k = Maps.newLinkedHashMap(); // CraftBukkit - stable
+    private final Map<String, String> l = Maps.newHashMap();
+    private MinecraftKey m = new MinecraftKey(""); public MinecraftKey getBlockKey() { return this.m; } // Paper - OBFHELPER
+    private BlockStateList<Block, IBlockData> n;
+    private IBlockData o;
+    @Nullable
+    private NBTTagCompound p;
+    private MinecraftKey q = new MinecraftKey("");
+    private int r;
+    private Function<SuggestionsBuilder, CompletableFuture<Suggestions>> s;
+
+    public ArgumentBlock(StringReader stringreader, boolean flag) {
+        this.s = ArgumentBlock.h;
+        this.i = stringreader;
+        this.j = flag;
+    }
+
+    public Map<IBlockState<?>, Comparable<?>> getStateMap() {
+        return this.k;
+    }
+
+    @Nullable
+    public IBlockData getBlockData() {
+        return this.o;
+    }
+
+    @Nullable
+    public NBTTagCompound c() {
+        return this.p;
+    }
+
+    public @Nullable MinecraftKey getTagKey() { return d(); } // Paper - OBFHELPER
+    @Nullable
+    public MinecraftKey d() {
+        return this.q;
+    }
+
+    public ArgumentBlock parse(boolean parseTile) throws CommandSyntaxException { return this.a(parseTile); } // Paper - OBFHELPER
+    public ArgumentBlock a(boolean flag) throws CommandSyntaxException {
+        this.s = this::l;
+        if (this.i.canRead() && this.i.peek() == '#') {
+            this.f();
+            this.s = this::i;
+            if (this.i.canRead() && this.i.peek() == '[') {
+                this.h();
+                this.s = this::f;
+            }
+        } else {
+            this.e();
+            this.s = this::j;
+            if (this.i.canRead() && this.i.peek() == '[') {
+                this.g();
+                this.s = this::f;
+            }
+        }
+
+        if (flag && this.i.canRead() && this.i.peek() == '{') {
+            this.s = ArgumentBlock.h;
+            this.i();
+        }
+
+        return this;
+    }
+
+    private CompletableFuture<Suggestions> b(SuggestionsBuilder suggestionsbuilder) {
+        if (suggestionsbuilder.getRemaining().isEmpty()) {
+            suggestionsbuilder.suggest(String.valueOf(']'));
+        }
+
+        return this.d(suggestionsbuilder);
+    }
+
+    private CompletableFuture<Suggestions> c(SuggestionsBuilder suggestionsbuilder) {
+        if (suggestionsbuilder.getRemaining().isEmpty()) {
+            suggestionsbuilder.suggest(String.valueOf(']'));
+        }
+
+        return this.e(suggestionsbuilder);
+    }
+
+    private CompletableFuture<Suggestions> d(SuggestionsBuilder suggestionsbuilder) {
+        String s = suggestionsbuilder.getRemaining().toLowerCase(Locale.ROOT);
+        Iterator iterator = this.o.a().iterator();
+
+        while (iterator.hasNext()) {
+            IBlockState<?> iblockstate = (IBlockState) iterator.next();
+
+            if (!this.k.containsKey(iblockstate) && iblockstate.a().startsWith(s)) {
+                suggestionsbuilder.suggest(iblockstate.a() + '=');
+            }
+        }
+
+        return suggestionsbuilder.buildFuture();
+    }
+
+    private CompletableFuture<Suggestions> e(SuggestionsBuilder suggestionsbuilder) {
+        String s = suggestionsbuilder.getRemaining().toLowerCase(Locale.ROOT);
+
+        if (this.q != null && !this.q.getKey().isEmpty()) {
+            Tag<Block> tag = TagsBlock.a().a(this.q);
+
+            if (tag != null) {
+                Iterator iterator = tag.a().iterator();
+
+                while (iterator.hasNext()) {
+                    Block block = (Block) iterator.next();
+                    Iterator iterator1 = block.getStates().d().iterator();
+
+                    while (iterator1.hasNext()) {
+                        IBlockState<?> iblockstate = (IBlockState) iterator1.next();
+
+                        if (!this.l.containsKey(iblockstate.a()) && iblockstate.a().startsWith(s)) {
+                            suggestionsbuilder.suggest(iblockstate.a() + '=');
+                        }
+                    }
+                }
+            }
+        }
+
+        return suggestionsbuilder.buildFuture();
+    }
+
+    private CompletableFuture<Suggestions> f(SuggestionsBuilder suggestionsbuilder) {
+        if (suggestionsbuilder.getRemaining().isEmpty() && this.k()) {
+            suggestionsbuilder.suggest(String.valueOf('{'));
+        }
+
+        return suggestionsbuilder.buildFuture();
+    }
+
+    private boolean k() {
+        if (this.o != null) {
+            return this.o.getBlock().isTileEntity();
+        } else {
+            if (this.q != null) {
+                Tag<Block> tag = TagsBlock.a().a(this.q);
+
+                if (tag != null) {
+                    Iterator iterator = tag.a().iterator();
+
+                    while (iterator.hasNext()) {
+                        Block block = (Block) iterator.next();
+
+                        if (block.isTileEntity()) {
+                            return true;
+                        }
+                    }
+                }
+            }
+
+            return false;
+        }
+    }
+
+    private CompletableFuture<Suggestions> g(SuggestionsBuilder suggestionsbuilder) {
+        if (suggestionsbuilder.getRemaining().isEmpty()) {
+            suggestionsbuilder.suggest(String.valueOf('='));
+        }
+
+        return suggestionsbuilder.buildFuture();
+    }
+
+    private CompletableFuture<Suggestions> h(SuggestionsBuilder suggestionsbuilder) {
+        if (suggestionsbuilder.getRemaining().isEmpty()) {
+            suggestionsbuilder.suggest(String.valueOf(']'));
+        }
+
+        if (suggestionsbuilder.getRemaining().isEmpty() && this.k.size() < this.o.a().size()) {
+            suggestionsbuilder.suggest(String.valueOf(','));
+        }
+
+        return suggestionsbuilder.buildFuture();
+    }
+
+    private static <T extends Comparable<T>> SuggestionsBuilder a(SuggestionsBuilder suggestionsbuilder, IBlockState<T> iblockstate) {
+        Iterator iterator = iblockstate.d().iterator();
+
+        while (iterator.hasNext()) {
+            T t0 = (T) iterator.next(); // CraftBukkit - decompile error
+
+            if (t0 instanceof Integer) {
+                suggestionsbuilder.suggest((Integer) t0);
+            } else {
+                suggestionsbuilder.suggest(iblockstate.a(t0));
+            }
+        }
+
+        return suggestionsbuilder;
+    }
+
+    private CompletableFuture<Suggestions> a(SuggestionsBuilder suggestionsbuilder, String s) {
+        boolean flag = false;
+
+        if (this.q != null && !this.q.getKey().isEmpty()) {
+            Tag<Block> tag = TagsBlock.a().a(this.q);
+
+            if (tag != null) {
+                Iterator iterator = tag.a().iterator();
+
+                while (iterator.hasNext()) {
+                    Block block = (Block) iterator.next();
+                    IBlockState<?> iblockstate = block.getStates().a(s);
+
+                    if (iblockstate != null) {
+                        a(suggestionsbuilder, iblockstate);
+                    }
+
+                    if (!flag) {
+                        Iterator iterator1 = block.getStates().d().iterator();
+
+                        while (iterator1.hasNext()) {
+                            IBlockState<?> iblockstate1 = (IBlockState) iterator1.next();
+
+                            if (!this.l.containsKey(iblockstate1.a())) {
+                                flag = true;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        if (flag) {
+            suggestionsbuilder.suggest(String.valueOf(','));
+        }
+
+        suggestionsbuilder.suggest(String.valueOf(']'));
+        return suggestionsbuilder.buildFuture();
+    }
+
+    private CompletableFuture<Suggestions> i(SuggestionsBuilder suggestionsbuilder) {
+        if (suggestionsbuilder.getRemaining().isEmpty()) {
+            Tag<Block> tag = TagsBlock.a().a(this.q);
+
+            if (tag != null) {
+                boolean flag = false;
+                boolean flag1 = false;
+                Iterator iterator = tag.a().iterator();
+
+                while (iterator.hasNext()) {
+                    Block block = (Block) iterator.next();
+
+                    flag |= !block.getStates().d().isEmpty();
+                    flag1 |= block.isTileEntity();
+                    if (flag && flag1) {
+                        break;
+                    }
+                }
+
+                if (flag) {
+                    suggestionsbuilder.suggest(String.valueOf('['));
+                }
+
+                if (flag1) {
+                    suggestionsbuilder.suggest(String.valueOf('{'));
+                }
+            }
+        }
+
+        return this.k(suggestionsbuilder);
+    }
+
+    private CompletableFuture<Suggestions> j(SuggestionsBuilder suggestionsbuilder) {
+        if (suggestionsbuilder.getRemaining().isEmpty()) {
+            if (!this.o.getBlock().getStates().d().isEmpty()) {
+                suggestionsbuilder.suggest(String.valueOf('['));
+            }
+
+            if (this.o.getBlock().isTileEntity()) {
+                suggestionsbuilder.suggest(String.valueOf('{'));
+            }
+        }
+
+        return suggestionsbuilder.buildFuture();
+    }
+
+    private CompletableFuture<Suggestions> k(SuggestionsBuilder suggestionsbuilder) {
+        return ICompletionProvider.a((Iterable) TagsBlock.a().a(), suggestionsbuilder.createOffset(this.r).add(suggestionsbuilder));
+    }
+
+    private CompletableFuture<Suggestions> l(SuggestionsBuilder suggestionsbuilder) {
+        if (this.j) {
+            ICompletionProvider.a((Iterable) TagsBlock.a().a(), suggestionsbuilder, String.valueOf('#'));
+        }
+
+        ICompletionProvider.a((Iterable) IRegistry.BLOCK.keySet(), suggestionsbuilder);
+        return suggestionsbuilder.buildFuture();
+    }
+
+    public void e() throws CommandSyntaxException {
+        int i = this.i.getCursor();
+
+        this.m = MinecraftKey.a(this.i);
+        if (IRegistry.BLOCK.c(this.m)) {
+            Block block = (Block) IRegistry.BLOCK.getOrDefault(this.m);
+
+            this.n = block.getStates();
+            this.o = block.getBlockData();
+        } else {
+            this.i.setCursor(i);
+            throw ArgumentBlock.b.createWithContext(this.i, this.m.toString());
+        }
+    }
+
+    public void f() throws CommandSyntaxException {
+        if (!this.j) {
+            throw ArgumentBlock.a.create();
+        } else {
+            this.s = this::k;
+            this.i.expect('#');
+            this.r = this.i.getCursor();
+            this.q = MinecraftKey.a(this.i);
+        }
+    }
+
+    public void g() throws CommandSyntaxException {
+        this.i.skip();
+        this.s = this::b;
+        this.i.skipWhitespace();
+
+        while (true) {
+            if (this.i.canRead() && this.i.peek() != ']') {
+                this.i.skipWhitespace();
+                int i = this.i.getCursor();
+                String s = this.i.readString();
+                IBlockState<?> iblockstate = this.n.a(s);
+
+                if (iblockstate == null) {
+                    this.i.setCursor(i);
+                    throw ArgumentBlock.c.createWithContext(this.i, this.m.toString(), s);
+                }
+
+                if (this.k.containsKey(iblockstate)) {
+                    this.i.setCursor(i);
+                    throw ArgumentBlock.d.createWithContext(this.i, this.m.toString(), s);
+                }
+
+                this.i.skipWhitespace();
+                this.s = this::g;
+                if (!this.i.canRead() || this.i.peek() != '=') {
+                    throw ArgumentBlock.f.createWithContext(this.i, this.m.toString(), s);
+                }
+
+                this.i.skip();
+                this.i.skipWhitespace();
+                this.s = (suggestionsbuilder) -> {
+                    return a(suggestionsbuilder, iblockstate).buildFuture();
+                };
+                int j = this.i.getCursor();
+
+                this.a(iblockstate, this.i.readString(), j);
+                this.s = this::h;
+                this.i.skipWhitespace();
+                if (!this.i.canRead()) {
+                    continue;
+                }
+
+                if (this.i.peek() == ',') {
+                    this.i.skip();
+                    this.s = this::d;
+                    continue;
+                }
+
+                if (this.i.peek() != ']') {
+                    throw ArgumentBlock.g.createWithContext(this.i);
+                }
+            }
+
+            if (this.i.canRead()) {
+                this.i.skip();
+                return;
+            }
+
+            throw ArgumentBlock.g.createWithContext(this.i);
+        }
+    }
+
+    public void h() throws CommandSyntaxException {
+        this.i.skip();
+        this.s = this::c;
+        int i = -1;
+
+        this.i.skipWhitespace();
+
+        while (true) {
+            if (this.i.canRead() && this.i.peek() != ']') {
+                this.i.skipWhitespace();
+                int j = this.i.getCursor();
+                String s = this.i.readString();
+
+                if (this.l.containsKey(s)) {
+                    this.i.setCursor(j);
+                    throw ArgumentBlock.d.createWithContext(this.i, this.m.toString(), s);
+                }
+
+                this.i.skipWhitespace();
+                if (!this.i.canRead() || this.i.peek() != '=') {
+                    this.i.setCursor(j);
+                    throw ArgumentBlock.f.createWithContext(this.i, this.m.toString(), s);
+                }
+
+                this.i.skip();
+                this.i.skipWhitespace();
+                this.s = (suggestionsbuilder) -> {
+                    return this.a(suggestionsbuilder, s);
+                };
+                i = this.i.getCursor();
+                String s1 = this.i.readString();
+
+                this.l.put(s, s1);
+                this.i.skipWhitespace();
+                if (!this.i.canRead()) {
+                    continue;
+                }
+
+                i = -1;
+                if (this.i.peek() == ',') {
+                    this.i.skip();
+                    this.s = this::e;
+                    continue;
+                }
+
+                if (this.i.peek() != ']') {
+                    throw ArgumentBlock.g.createWithContext(this.i);
+                }
+            }
+
+            if (this.i.canRead()) {
+                this.i.skip();
+                return;
+            }
+
+            if (i >= 0) {
+                this.i.setCursor(i);
+            }
+
+            throw ArgumentBlock.g.createWithContext(this.i);
+        }
+    }
+
+    public void i() throws CommandSyntaxException {
+        this.p = (new MojangsonParser(this.i)).f();
+    }
+
+    private <T extends Comparable<T>> void a(IBlockState<T> iblockstate, String s, int i) throws CommandSyntaxException {
+        Optional<T> optional = iblockstate.b(s);
+
+        if (optional.isPresent()) {
+            this.o = (IBlockData) this.o.set(iblockstate, (T) optional.get()); // CraftBukkit - decompile error
+            this.k.put(iblockstate, optional.get());
+        } else {
+            this.i.setCursor(i);
+            throw ArgumentBlock.e.createWithContext(this.i, this.m.toString(), iblockstate.a(), s);
+        }
+    }
+
+    public static String a(IBlockData iblockdata, @Nullable NBTTagCompound nbttagcompound) {
+        StringBuilder stringbuilder = new StringBuilder(IRegistry.BLOCK.getKey(iblockdata.getBlock()).toString());
+
+        if (!iblockdata.a().isEmpty()) {
+            stringbuilder.append('[');
+            boolean flag = false;
+
+            for (UnmodifiableIterator unmodifiableiterator = iblockdata.getStateMap().entrySet().iterator(); unmodifiableiterator.hasNext(); flag = true) {
+                Entry<IBlockState<?>, Comparable<?>> entry = (Entry) unmodifiableiterator.next();
+
+                if (flag) {
+                    stringbuilder.append(',');
+                }
+
+                a(stringbuilder, (IBlockState) entry.getKey(), (Comparable) entry.getValue());
+            }
+
+            stringbuilder.append(']');
+        }
+
+        if (nbttagcompound != null) {
+            stringbuilder.append(nbttagcompound);
+        }
+
+        return stringbuilder.toString();
+    }
+
+    private static <T extends Comparable<T>> void a(StringBuilder stringbuilder, IBlockState<T> iblockstate, Comparable<?> comparable) {
+        stringbuilder.append(iblockstate.a());
+        stringbuilder.append('=');
+        stringbuilder.append(iblockstate.a((T) comparable)); // CraftBukkit - decompile error
+    }
+
+    public CompletableFuture<Suggestions> a(SuggestionsBuilder suggestionsbuilder) {
+        return (CompletableFuture) this.s.apply(suggestionsbuilder.createOffset(this.i.getCursor()));
+    }
+
+    public Map<String, String> j() {
+        return this.l;
+    }
+}

src/main/java/net/minecraft/server/ArgumentEntity.java

@@ -0,0 +1,171 @@
+package net.minecraft.server;
+
+import com.google.common.collect.Iterables;
+import com.google.gson.JsonObject;
+import com.mojang.brigadier.StringReader;
+import com.mojang.brigadier.arguments.ArgumentType;
+import com.mojang.brigadier.context.CommandContext;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import com.mojang.brigadier.exceptions.SimpleCommandExceptionType;
+import com.mojang.brigadier.suggestion.Suggestions;
+import com.mojang.brigadier.suggestion.SuggestionsBuilder;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+public class ArgumentEntity implements ArgumentType<EntitySelector> {
+
+    private static final Collection<String> g = Arrays.asList("Player", "0123", "@e", "@e[type=foo]", "dd12be42-52a9-4a91-a8a1-11c01849e498");
+    public static final SimpleCommandExceptionType a = new SimpleCommandExceptionType(new ChatMessage("argument.entity.toomany", new Object[0]));
+    public static final SimpleCommandExceptionType b = new SimpleCommandExceptionType(new ChatMessage("argument.player.toomany", new Object[0]));
+    public static final SimpleCommandExceptionType c = new SimpleCommandExceptionType(new ChatMessage("argument.player.entities", new Object[0]));
+    public static final SimpleCommandExceptionType d = new SimpleCommandExceptionType(new ChatMessage("argument.entity.notfound.entity", new Object[0]));
+    public static final SimpleCommandExceptionType e = new SimpleCommandExceptionType(new ChatMessage("argument.entity.notfound.player", new Object[0]));
+    public static final SimpleCommandExceptionType f = new SimpleCommandExceptionType(new ChatMessage("argument.entity.selector.not_allowed", new Object[0]));
+    private final boolean h;
+    private final boolean i;
+
+    protected ArgumentEntity(boolean flag, boolean flag1) {
+        this.h = flag;
+        this.i = flag1;
+    }
+
+    public static ArgumentEntity a() {
+        return new ArgumentEntity(true, false);
+    }
+
+    public static Entity a(CommandContext<CommandListenerWrapper> commandcontext, String s) throws CommandSyntaxException {
+        return ((EntitySelector) commandcontext.getArgument(s, EntitySelector.class)).a((CommandListenerWrapper) commandcontext.getSource());
+    }
+
+    public static ArgumentEntity b() {
+        return new ArgumentEntity(false, false);
+    }
+
+    public static Collection<? extends Entity> b(CommandContext<CommandListenerWrapper> commandcontext, String s) throws CommandSyntaxException {
+        Collection<? extends Entity> collection = c(commandcontext, s);
+
+        if (collection.isEmpty()) {
+            throw ArgumentEntity.d.create();
+        } else {
+            return collection;
+        }
+    }
+
+    public static Collection<? extends Entity> c(CommandContext<CommandListenerWrapper> commandcontext, String s) throws CommandSyntaxException {
+        return ((EntitySelector) commandcontext.getArgument(s, EntitySelector.class)).b((CommandListenerWrapper) commandcontext.getSource());
+    }
+
+    public static Collection<EntityPlayer> d(CommandContext<CommandListenerWrapper> commandcontext, String s) throws CommandSyntaxException {
+        return ((EntitySelector) commandcontext.getArgument(s, EntitySelector.class)).d((CommandListenerWrapper) commandcontext.getSource());
+    }
+
+    public static ArgumentEntity c() {
+        return new ArgumentEntity(true, true);
+    }
+
+    public static EntityPlayer e(CommandContext<CommandListenerWrapper> commandcontext, String s) throws CommandSyntaxException {
+        return ((EntitySelector) commandcontext.getArgument(s, EntitySelector.class)).c((CommandListenerWrapper) commandcontext.getSource());
+    }
+
+    public static ArgumentEntity d() {
+        return new ArgumentEntity(false, true);
+    }
+
+    public static Collection<EntityPlayer> f(CommandContext<CommandListenerWrapper> commandcontext, String s) throws CommandSyntaxException {
+        List<EntityPlayer> list = ((EntitySelector) commandcontext.getArgument(s, EntitySelector.class)).d((CommandListenerWrapper) commandcontext.getSource());
+
+        if (list.isEmpty()) {
+            throw ArgumentEntity.e.create();
+        } else {
+            return list;
+        }
+    }
+
+    public EntitySelector parse(StringReader stringreader) throws CommandSyntaxException {
+        // CraftBukkit start
+        return parse(stringreader, false);
+    }
+
+    public EntitySelector parse(StringReader stringreader, boolean overridePermissions) throws CommandSyntaxException {
+        // CraftBukkit end
+        boolean flag = false;
+        ArgumentParserSelector argumentparserselector = new ArgumentParserSelector(stringreader);
+        EntitySelector entityselector = argumentparserselector.s(overridePermissions); // CraftBukkit
+
+        if (entityselector.a() > 1 && this.h) {
+            if (this.i) {
+                stringreader.setCursor(0);
+                throw ArgumentEntity.b.createWithContext(stringreader);
+            } else {
+                stringreader.setCursor(0);
+                throw ArgumentEntity.a.createWithContext(stringreader);
+            }
+        } else if (entityselector.b() && this.i && !entityselector.c()) {
+            stringreader.setCursor(0);
+            throw ArgumentEntity.c.createWithContext(stringreader);
+        } else {
+            return entityselector;
+        }
+    }
+
+    public <S> CompletableFuture<Suggestions> listSuggestions(CommandContext<S> commandcontext, SuggestionsBuilder suggestionsbuilder) {
+        if (commandcontext.getSource() instanceof ICompletionProvider) {
+            StringReader stringreader = new StringReader(suggestionsbuilder.getInput());
+
+            stringreader.setCursor(suggestionsbuilder.getStart());
+            ICompletionProvider icompletionprovider = (ICompletionProvider) commandcontext.getSource();
+            ArgumentParserSelector argumentparserselector = new ArgumentParserSelector(stringreader, icompletionprovider.hasPermission(2));
+
+            try {
+                argumentparserselector.s();
+            } catch (CommandSyntaxException commandsyntaxexception) {
+                ;
+            }
+
+            return argumentparserselector.a(suggestionsbuilder, (suggestionsbuilder1) -> {
+                Collection<String> collection = icompletionprovider.l();
+                Iterable<String> iterable = this.i ? collection : Iterables.concat(collection, icompletionprovider.p());
+
+                ICompletionProvider.b((Iterable) iterable, suggestionsbuilder1);
+            });
+        } else {
+            return Suggestions.empty();
+        }
+    }
+
+    public Collection<String> getExamples() {
+        return ArgumentEntity.g;
+    }
+
+    public static class a implements ArgumentSerializer<ArgumentEntity> {
+
+        public a() {}
+
+        public void a(ArgumentEntity argumententity, PacketDataSerializer packetdataserializer) {
+            byte b0 = 0;
+
+            if (argumententity.h) {
+                b0 = (byte) (b0 | 1);
+            }
+
+            if (argumententity.i) {
+                b0 = (byte) (b0 | 2);
+            }
+
+            packetdataserializer.writeByte(b0);
+        }
+
+        public ArgumentEntity b(PacketDataSerializer packetdataserializer) {
+            byte b0 = packetdataserializer.readByte();
+
+            return new ArgumentEntity((b0 & 1) != 0, (b0 & 2) != 0);
+        }
+
+        public void a(ArgumentEntity argumententity, JsonObject jsonobject) {
+            jsonobject.addProperty("amount", argumententity.h ? "single" : "multiple");
+            jsonobject.addProperty("type", argumententity.i ? "players" : "entities");
+        }
+    }
+}

src/main/java/net/minecraft/server/ArgumentParserSelector.java

@@ -0,0 +1,630 @@
+package net.minecraft.server;
+
+import com.google.common.primitives.Doubles;
+import com.mojang.brigadier.StringReader;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import com.mojang.brigadier.exceptions.DynamicCommandExceptionType;
+import com.mojang.brigadier.exceptions.SimpleCommandExceptionType;
+import com.mojang.brigadier.suggestion.Suggestions;
+import com.mojang.brigadier.suggestion.SuggestionsBuilder;
+import java.util.Collections;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.ToDoubleFunction;
+import javax.annotation.Nullable;
+
+public class ArgumentParserSelector {
+
+    public static final SimpleCommandExceptionType a = new SimpleCommandExceptionType(new ChatMessage("argument.entity.invalid", new Object[0]));
+    public static final DynamicCommandExceptionType b = new DynamicCommandExceptionType((object) -> {
+        return new ChatMessage("argument.entity.selector.unknown", new Object[] { object});
+    });
+    public static final SimpleCommandExceptionType c = new SimpleCommandExceptionType(new ChatMessage("argument.entity.selector.not_allowed", new Object[0]));
+    public static final SimpleCommandExceptionType d = new SimpleCommandExceptionType(new ChatMessage("argument.entity.selector.missing", new Object[0]));
+    public static final SimpleCommandExceptionType e = new SimpleCommandExceptionType(new ChatMessage("argument.entity.options.unterminated", new Object[0]));
+    public static final DynamicCommandExceptionType f = new DynamicCommandExceptionType((object) -> {
+        return new ChatMessage("argument.entity.options.valueless", new Object[] { object});
+    });
+    public static final BiConsumer<Vec3D, List<? extends Entity>> g = (vec3d, list) -> {
+    };
+    public static final BiConsumer<Vec3D, List<? extends Entity>> h = (vec3d, list) -> {
+        list.sort((entity, entity1) -> {
+            return Doubles.compare(entity.a(vec3d), entity1.a(vec3d));
+        });
+    };
+    public static final BiConsumer<Vec3D, List<? extends Entity>> i = (vec3d, list) -> {
+        list.sort((entity, entity1) -> {
+            return Doubles.compare(entity1.a(vec3d), entity.a(vec3d));
+        });
+    };
+    public static final BiConsumer<Vec3D, List<? extends Entity>> j = (vec3d, list) -> {
+        Collections.shuffle(list);
+    };
+    public static final BiFunction<SuggestionsBuilder, Consumer<SuggestionsBuilder>, CompletableFuture<Suggestions>> k = (suggestionsbuilder, consumer) -> {
+        return suggestionsbuilder.buildFuture();
+    };
+    private final StringReader l;
+    private final boolean m;
+    private int n;
+    private boolean o;
+    private boolean p;
+    private CriterionConditionValue.c q;
+    private CriterionConditionValue.d r;
+    @Nullable
+    private Double s;
+    @Nullable
+    private Double t;
+    @Nullable
+    private Double u;
+    @Nullable
+    private Double v;
+    @Nullable
+    private Double w;
+    @Nullable
+    private Double x;
+    private CriterionConditionRange y;
+    private CriterionConditionRange z;
+    private Predicate<Entity> A;
+    private BiConsumer<Vec3D, List<? extends Entity>> B;
+    private boolean C;
+    @Nullable
+    private String D;
+    private int E;
+    @Nullable
+    private UUID F;
+    private BiFunction<SuggestionsBuilder, Consumer<SuggestionsBuilder>, CompletableFuture<Suggestions>> G;
+    private boolean H;
+    private boolean I;
+    private boolean J;
+    private boolean K;
+    private boolean L;
+    private boolean M;
+    private boolean N;
+    private boolean O;
+    private Class<? extends Entity> P;
+    private boolean Q;
+    private boolean R;
+    private boolean S;
+    private boolean T;
+
+    public ArgumentParserSelector(StringReader stringreader) {
+        this(stringreader, true);
+    }
+
+    // CraftBukkit start - decompile error
+    private static final CriterionConditionValue.c DEFAULT_q;
+    private static final CriterionConditionValue.d DEFAULT_r;
+
+    static {
+        try {
+            DEFAULT_q = (CriterionConditionValue.c) Class.forName("net.minecraft.server.CriterionConditionValue$c").getDeclaredField("e").get(null);
+            DEFAULT_r = (CriterionConditionValue.d) Class.forName("net.minecraft.server.CriterionConditionValue$d").getDeclaredField("e").get(null);
+        } catch (Exception ex) {
+            throw new AssertionError(ex);
+        }
+    }
+
+    public ArgumentParserSelector(StringReader stringreader, boolean flag) {
+        this.q = DEFAULT_q;
+        this.r = DEFAULT_r;
+        // CraftBukkit end
+        this.y = CriterionConditionRange.a;
+        this.z = CriterionConditionRange.a;
+        this.A = (entity) -> {
+            return true;
+        };
+        this.B = ArgumentParserSelector.g;
+        this.G = ArgumentParserSelector.k;
+        this.l = stringreader;
+        this.m = flag;
+    }
+
+    public EntitySelector a() {
+        AxisAlignedBB axisalignedbb;
+
+        if (this.v == null && this.w == null && this.x == null) {
+            if (this.q.b() != null) {
+                float f = (Float) this.q.b();
+
+                axisalignedbb = new AxisAlignedBB((double) (-f), (double) (-f), (double) (-f), (double) (f + 1.0F), (double) (f + 1.0F), (double) (f + 1.0F));
+            } else {
+                axisalignedbb = null;
+            }
+        } else {
+            axisalignedbb = this.a(this.v == null ? 0.0D : this.v, this.w == null ? 0.0D : this.w, this.x == null ? 0.0D : this.x);
+        }
+
+        Function<Vec3D, Vec3D> function; // CraftBukkit - decompile error
+
+        if (this.s == null && this.t == null && this.u == null) {
+            function = (vec3d) -> {
+                return vec3d;
+            };
+        } else {
+            function = (vec3d) -> {
+                return new Vec3D(this.s == null ? vec3d.x : this.s, this.t == null ? vec3d.y : this.t, this.u == null ? vec3d.z : this.u);
+            };
+        }
+
+        return new EntitySelector(this.n, this.o, this.p, this.A, this.q, function, axisalignedbb, this.B, this.C, this.D, this.F, this.P == null ? Entity.class : this.P, this.T);
+    }
+
+    private AxisAlignedBB a(double d0, double d1, double d2) {
+        boolean flag = d0 < 0.0D;
+        boolean flag1 = d1 < 0.0D;
+        boolean flag2 = d2 < 0.0D;
+        double d3 = flag ? d0 : 0.0D;
+        double d4 = flag1 ? d1 : 0.0D;
+        double d5 = flag2 ? d2 : 0.0D;
+        double d6 = (flag ? 0.0D : d0) + 1.0D;
+        double d7 = (flag1 ? 0.0D : d1) + 1.0D;
+        double d8 = (flag2 ? 0.0D : d2) + 1.0D;
+
+        return new AxisAlignedBB(d3, d4, d5, d6, d7, d8);
+    }
+
+    private void I() {
+        if (this.y != CriterionConditionRange.a) {
+            this.A = this.A.and(this.a(this.y, (entity) -> {
+                return (double) entity.pitch;
+            }));
+        }
+
+        if (this.z != CriterionConditionRange.a) {
+            this.A = this.A.and(this.a(this.z, (entity) -> {
+                return (double) entity.yaw;
+            }));
+        }
+
+        if (!this.r.c()) {
+            this.A = this.A.and((entity) -> {
+                return !(entity instanceof EntityPlayer) ? false : this.r.d(((EntityPlayer) entity).expLevel);
+            });
+        }
+
+    }
+
+    private Predicate<Entity> a(CriterionConditionRange criterionconditionrange, ToDoubleFunction<Entity> todoublefunction) {
+        double d0 = (double) MathHelper.g(criterionconditionrange.a() == null ? 0.0F : criterionconditionrange.a());
+        double d1 = (double) MathHelper.g(criterionconditionrange.b() == null ? 359.0F : criterionconditionrange.b());
+
+        return (entity) -> {
+            double d2 = MathHelper.g(todoublefunction.applyAsDouble(entity));
+
+            return d0 > d1 ? d2 >= d0 || d2 <= d1 : d2 >= d0 && d2 <= d1;
+        };
+    }
+
+    // CraftBukkit start
+    protected void b(boolean overridePermissions) throws CommandSyntaxException {
+        this.T = !overridePermissions;
+        // CraftBukkit end
+        this.G = this::d;
+        if (!this.l.canRead()) {
+            throw ArgumentParserSelector.d.createWithContext(this.l);
+        } else {
+            int i = this.l.getCursor();
+            char c0 = this.l.read();
+
+            if (c0 == 'p') {
+                this.n = 1;
+                this.o = false;
+                this.B = ArgumentParserSelector.h;
+                this.a(EntityPlayer.class);
+            } else if (c0 == 'a') {
+                this.n = Integer.MAX_VALUE;
+                this.o = false;
+                this.B = ArgumentParserSelector.g;
+                this.a(EntityPlayer.class);
+            } else if (c0 == 'r') {
+                this.n = 1;
+                this.o = false;
+                this.B = ArgumentParserSelector.j;
+                this.a(EntityPlayer.class);
+            } else if (c0 == 's') {
+                this.n = 1;
+                this.o = true;
+                this.C = true;
+            } else {
+                if (c0 != 'e') {
+                    this.l.setCursor(i);
+                    throw ArgumentParserSelector.b.createWithContext(this.l, '@' + String.valueOf(c0));
+                }
+
+                this.n = Integer.MAX_VALUE;
+                this.o = true;
+                this.B = ArgumentParserSelector.g;
+                this.A = Entity::isAlive;
+            }
+
+            this.G = this::e;
+            if (this.l.canRead() && this.l.peek() == '[') {
+                this.l.skip();
+                this.G = this::f;
+                this.d();
+            }
+
+        }
+    }
+
+    protected void c() throws CommandSyntaxException {
+        if (this.l.canRead()) {
+            this.G = this::c;
+        }
+
+        int i = this.l.getCursor();
+        String s = this.l.readString();
+
+        try {
+            this.F = UUID.fromString(s);
+            this.o = true;
+        } catch (IllegalArgumentException illegalargumentexception) {
+            if (s.isEmpty() || s.length() > 16) {
+                this.l.setCursor(i);
+                throw ArgumentParserSelector.a.createWithContext(this.l);
+            }
+
+            this.o = false;
+            this.D = s;
+        }
+
+        this.n = 1;
+    }
+
+    protected void d() throws CommandSyntaxException {
+        this.G = this::g;
+        this.l.skipWhitespace();
+
+        while (true) {
+            if (this.l.canRead() && this.l.peek() != ']') {
+                this.l.skipWhitespace();
+                int i = this.l.getCursor();
+                String s = this.l.readString();
+                PlayerSelector.a playerselector_a = PlayerSelector.a(this, s, i);
+
+                this.l.skipWhitespace();
+                if (!this.l.canRead() || this.l.peek() != '=') {
+                    this.l.setCursor(i);
+                    throw ArgumentParserSelector.f.createWithContext(this.l, s);
+                }
+
+                this.l.skip();
+                this.l.skipWhitespace();
+                this.G = ArgumentParserSelector.k;
+                playerselector_a.handle(this);
+                this.l.skipWhitespace();
+                this.G = this::h;
+                if (!this.l.canRead()) {
+                    continue;
+                }
+
+                if (this.l.peek() == ',') {
+                    this.l.skip();
+                    this.G = this::g;
+                    continue;
+                }
+
+                if (this.l.peek() != ']') {
+                    throw ArgumentParserSelector.e.createWithContext(this.l);
+                }
+            }
+
+            if (this.l.canRead()) {
+                this.l.skip();
+                this.G = ArgumentParserSelector.k;
+                return;
+            }
+
+            throw ArgumentParserSelector.e.createWithContext(this.l);
+        }
+    }
+
+    public boolean e() {
+        this.l.skipWhitespace();
+        if (this.l.canRead() && this.l.peek() == '!') {
+            this.l.skip();
+            this.l.skipWhitespace();
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public StringReader f() {
+        return this.l;
+    }
+
+    public void a(Predicate<Entity> predicate) {
+        this.A = this.A.and(predicate);
+    }
+
+    public void g() {
+        this.p = true;
+    }
+
+    public CriterionConditionValue.c h() {
+        return this.q;
+    }
+
+    public void a(CriterionConditionValue.c criterionconditionvalue_c) {
+        this.q = criterionconditionvalue_c;
+    }
+
+    public CriterionConditionValue.d i() {
+        return this.r;
+    }
+
+    public void a(CriterionConditionValue.d criterionconditionvalue_d) {
+        this.r = criterionconditionvalue_d;
+    }
+
+    public CriterionConditionRange j() {
+        return this.y;
+    }
+
+    public void a(CriterionConditionRange criterionconditionrange) {
+        this.y = criterionconditionrange;
+    }
+
+    public CriterionConditionRange k() {
+        return this.z;
+    }
+
+    public void b(CriterionConditionRange criterionconditionrange) {
+        this.z = criterionconditionrange;
+    }
+
+    @Nullable
+    public Double l() {
+        return this.s;
+    }
+
+    @Nullable
+    public Double m() {
+        return this.t;
+    }
+
+    @Nullable
+    public Double n() {
+        return this.u;
+    }
+
+    public void a(double d0) {
+        this.s = d0;
+    }
+
+    public void b(double d0) {
+        this.t = d0;
+    }
+
+    public void c(double d0) {
+        this.u = d0;
+    }
+
+    public void d(double d0) {
+        this.v = d0;
+    }
+
+    public void e(double d0) {
+        this.w = d0;
+    }
+
+    public void f(double d0) {
+        this.x = d0;
+    }
+
+    @Nullable
+    public Double o() {
+        return this.v;
+    }
+
+    @Nullable
+    public Double p() {
+        return this.w;
+    }
+
+    @Nullable
+    public Double q() {
+        return this.x;
+    }
+
+    public void a(int i) {
+        this.n = i;
+    }
+
+    public void a(boolean flag) {
+        this.o = flag;
+    }
+
+    public void a(BiConsumer<Vec3D, List<? extends Entity>> biconsumer) {
+        this.B = biconsumer;
+    }
+
+    public EntitySelector s() throws CommandSyntaxException {
+        // CraftBukkit start
+        return s(false);
+    }
+
+    public EntitySelector s(boolean overridePermissions) throws CommandSyntaxException {
+        // CraftBukkit end
+        this.E = this.l.getCursor();
+        this.G = this::b;
+        if (this.l.canRead() && this.l.peek() == '@') {
+            if (!this.m) {
+                throw ArgumentParserSelector.c.createWithContext(this.l);
+            }
+
+            this.l.skip();
+            this.b(overridePermissions); // CraftBukkit
+        } else {
+            this.c();
+        }
+
+        this.I();
+        return this.a();
+    }
+
+    private static void a(SuggestionsBuilder suggestionsbuilder) {
+        suggestionsbuilder.suggest("@p", new ChatMessage("argument.entity.selector.nearestPlayer", new Object[0]));
+        suggestionsbuilder.suggest("@a", new ChatMessage("argument.entity.selector.allPlayers", new Object[0]));
+        suggestionsbuilder.suggest("@r", new ChatMessage("argument.entity.selector.randomPlayer", new Object[0]));
+        suggestionsbuilder.suggest("@s", new ChatMessage("argument.entity.selector.self", new Object[0]));
+        suggestionsbuilder.suggest("@e", new ChatMessage("argument.entity.selector.allEntities", new Object[0]));
+    }
+
+    private CompletableFuture<Suggestions> b(SuggestionsBuilder suggestionsbuilder, Consumer<SuggestionsBuilder> consumer) {
+        consumer.accept(suggestionsbuilder);
+        if (this.m) {
+            a(suggestionsbuilder);
+        }
+
+        return suggestionsbuilder.buildFuture();
+    }
+
+    private CompletableFuture<Suggestions> c(SuggestionsBuilder suggestionsbuilder, Consumer<SuggestionsBuilder> consumer) {
+        SuggestionsBuilder suggestionsbuilder1 = suggestionsbuilder.createOffset(this.E);
+
+        consumer.accept(suggestionsbuilder1);
+        return suggestionsbuilder.add(suggestionsbuilder1).buildFuture();
+    }
+
+    private CompletableFuture<Suggestions> d(SuggestionsBuilder suggestionsbuilder, Consumer<SuggestionsBuilder> consumer) {
+        SuggestionsBuilder suggestionsbuilder1 = suggestionsbuilder.createOffset(suggestionsbuilder.getStart() - 1);
+
+        a(suggestionsbuilder1);
+        suggestionsbuilder.add(suggestionsbuilder1);
+        return suggestionsbuilder.buildFuture();
+    }
+
+    private CompletableFuture<Suggestions> e(SuggestionsBuilder suggestionsbuilder, Consumer<SuggestionsBuilder> consumer) {
+        suggestionsbuilder.suggest(String.valueOf('['));
+        return suggestionsbuilder.buildFuture();
+    }
+
+    private CompletableFuture<Suggestions> f(SuggestionsBuilder suggestionsbuilder, Consumer<SuggestionsBuilder> consumer) {
+        suggestionsbuilder.suggest(String.valueOf(']'));
+        PlayerSelector.a(this, suggestionsbuilder);
+        return suggestionsbuilder.buildFuture();
+    }
+
+    private CompletableFuture<Suggestions> g(SuggestionsBuilder suggestionsbuilder, Consumer<SuggestionsBuilder> consumer) {
+        PlayerSelector.a(this, suggestionsbuilder);
+        return suggestionsbuilder.buildFuture();
+    }
+
+    private CompletableFuture<Suggestions> h(SuggestionsBuilder suggestionsbuilder, Consumer<SuggestionsBuilder> consumer) {
+        suggestionsbuilder.suggest(String.valueOf(','));
+        suggestionsbuilder.suggest(String.valueOf(']'));
+        return suggestionsbuilder.buildFuture();
+    }
+
+    public boolean t() {
+        return this.C;
+    }
+
+    public void a(BiFunction<SuggestionsBuilder, Consumer<SuggestionsBuilder>, CompletableFuture<Suggestions>> bifunction) {
+        this.G = bifunction;
+    }
+
+    public CompletableFuture<Suggestions> a(SuggestionsBuilder suggestionsbuilder, Consumer<SuggestionsBuilder> consumer) {
+        return (CompletableFuture) this.G.apply(suggestionsbuilder.createOffset(this.l.getCursor()), consumer);
+    }
+
+    public boolean u() {
+        return this.H;
+    }
+
+    public void c(boolean flag) {
+        this.H = flag;
+    }
+
+    public boolean v() {
+        return this.I;
+    }
+
+    public void d(boolean flag) {
+        this.I = flag;
+    }
+
+    public boolean w() {
+        return this.J;
+    }
+
+    public void e(boolean flag) {
+        this.J = flag;
+    }
+
+    public boolean x() {
+        return this.K;
+    }
+
+    public void f(boolean flag) {
+        this.K = flag;
+    }
+
+    public boolean y() {
+        return this.L;
+    }
+
+    public void g(boolean flag) {
+        this.L = flag;
+    }
+
+    public boolean z() {
+        return this.M;
+    }
+
+    public void h(boolean flag) {
+        this.M = flag;
+    }
+
+    public boolean A() {
+        return this.N;
+    }
+
+    public void i(boolean flag) {
+        this.N = flag;
+    }
+
+    public void j(boolean flag) {
+        this.O = flag;
+    }
+
+    public void a(Class<? extends Entity> oclass) {
+        this.P = oclass;
+    }
+
+    public void C() {
+        this.Q = true;
+    }
+
+    public boolean E() {
+        return this.P != null;
+    }
+
+    public boolean F() {
+        return this.Q;
+    }
+
+    public boolean G() {
+        return this.R;
+    }
+
+    public void k(boolean flag) {
+        this.R = flag;
+    }
+
+    public boolean H() {
+        return this.S;
+    }
+
+    public void l(boolean flag) {
+        this.S = flag;
+    }
+}

src/main/java/net/minecraft/server/AttributeInstance.java

@@ -0,0 +1,33 @@
+package net.minecraft.server;
+
+import java.util.Collection;
+import java.util.UUID;
+import javax.annotation.Nullable;
+
+public interface AttributeInstance {
+
+    IAttribute getAttribute();
+
+    double b();
+
+    void setValue(double d0);
+
+    Collection<AttributeModifier> a(int i);
+
+    Collection<AttributeModifier> c();
+
+    boolean a(AttributeModifier attributemodifier);
+
+    @Nullable
+    AttributeModifier a(UUID uuid);
+
+    default void addModifier(AttributeModifier modifier) { b(modifier); } // Paper - OBFHELPER
+    void b(AttributeModifier attributemodifier);
+
+    default void removeModifier(AttributeModifier modifier) { c(modifier); } // Paper - OBFHELPER
+    void c(AttributeModifier attributemodifier);
+
+    void b(UUID uuid);
+
+    double getValue();
+}

src/main/java/net/minecraft/server/AttributeRanged.java

@@ -0,0 +1,39 @@
+package net.minecraft.server;
+
+import javax.annotation.Nullable;
+
+public class AttributeRanged extends AttributeBase {
+
+    private final double a;
+    public double maximum; // Spigot
+    private String c;
+
+    public AttributeRanged(@Nullable IAttribute iattribute, String s, double d0, double d1, double d2) {
+        super(iattribute, s, d0);
+        this.a = d1;
+        this.maximum = d2;
+        if (d1 > d2) {
+            throw new IllegalArgumentException("Minimum value cannot be bigger than maximum value!");
+        } else if (d0 < d1) {
+            throw new IllegalArgumentException("Default value cannot be lower than minimum value!");
+        } else if (d0 > d2) {
+            throw new IllegalArgumentException("Default value cannot be bigger than maximum value!");
+        }
+    }
+
+    public AttributeRanged a(String s) {
+        this.c = s;
+        return this;
+    }
+
+    public String g() {
+        return this.c;
+    }
+
+    public double a(double d0) {
+        if (d0 != d0) return getDefault(); // CraftBukkit
+
+        d0 = MathHelper.a(d0, this.a, this.maximum);
+        return d0;
+    }
+}

src/main/java/net/minecraft/server/AxisAlignedBB.java

@@ -0,0 +1,303 @@
+package net.minecraft.server;
+
+import java.util.Iterator;
+import javax.annotation.Nullable;
+
+public class AxisAlignedBB {
+
+    public final double minX; public double getMinX() { return this.minX; } // Paper - OBFHELPER
+    public final double minY; public double getMinY() { return this.minY; } // Paper - OBFHELPER
+    public final double minZ; public double getMinZ() { return this.minZ; } // Paper - OBFHELPER
+    public final double maxX; public double getMaxX() { return this.maxX; } // Paper - OBFHELPER
+    public final double maxY; public double getMaxY() { return this.maxY; } // Paper - OBFHELPER
+    public final double maxZ; public double getMaxZ() { return this.maxZ; } // Paper - OBFHELPER
+
+    public AxisAlignedBB(double d0, double d1, double d2, double d3, double d4, double d5) {
+        this.minX = Math.min(d0, d3);
+        this.minY = Math.min(d1, d4);
+        this.minZ = Math.min(d2, d5);
+        this.maxX = Math.max(d0, d3);
+        this.maxY = Math.max(d1, d4);
+        this.maxZ = Math.max(d2, d5);
+    }
+
+    public AxisAlignedBB(BlockPosition blockposition) {
+        this((double) blockposition.getX(), (double) blockposition.getY(), (double) blockposition.getZ(), (double) (blockposition.getX() + 1), (double) (blockposition.getY() + 1), (double) (blockposition.getZ() + 1));
+    }
+
+    public AxisAlignedBB(BlockPosition blockposition, BlockPosition blockposition1) {
+        this((double) blockposition.getX(), (double) blockposition.getY(), (double) blockposition.getZ(), (double) blockposition1.getX(), (double) blockposition1.getY(), (double) blockposition1.getZ());
+    }
+
+    public double a(EnumDirection.EnumAxis enumdirection_enumaxis) {
+        return enumdirection_enumaxis.a(this.minX, this.minY, this.minZ);
+    }
+
+    public double b(EnumDirection.EnumAxis enumdirection_enumaxis) {
+        return enumdirection_enumaxis.a(this.maxX, this.maxY, this.maxZ);
+    }
+
+    public boolean equals(Object object) {
+        if (this == object) {
+            return true;
+        } else if (!(object instanceof AxisAlignedBB)) {
+            return false;
+        } else {
+            AxisAlignedBB axisalignedbb = (AxisAlignedBB) object;
+
+            return Double.compare(axisalignedbb.minX, this.minX) != 0 ? false : (Double.compare(axisalignedbb.minY, this.minY) != 0 ? false : (Double.compare(axisalignedbb.minZ, this.minZ) != 0 ? false : (Double.compare(axisalignedbb.maxX, this.maxX) != 0 ? false : (Double.compare(axisalignedbb.maxY, this.maxY) != 0 ? false : Double.compare(axisalignedbb.maxZ, this.maxZ) == 0))));
+        }
+    }
+
+    public int hashCode() {
+        long i = Double.doubleToLongBits(this.minX);
+        int j = (int) (i ^ i >>> 32);
+
+        i = Double.doubleToLongBits(this.minY);
+        j = 31 * j + (int) (i ^ i >>> 32);
+        i = Double.doubleToLongBits(this.minZ);
+        j = 31 * j + (int) (i ^ i >>> 32);
+        i = Double.doubleToLongBits(this.maxX);
+        j = 31 * j + (int) (i ^ i >>> 32);
+        i = Double.doubleToLongBits(this.maxY);
+        j = 31 * j + (int) (i ^ i >>> 32);
+        i = Double.doubleToLongBits(this.maxZ);
+        j = 31 * j + (int) (i ^ i >>> 32);
+        return j;
+    }
+
+    public AxisAlignedBB a(double d0, double d1, double d2) {
+        double d3 = this.minX;
+        double d4 = this.minY;
+        double d5 = this.minZ;
+        double d6 = this.maxX;
+        double d7 = this.maxY;
+        double d8 = this.maxZ;
+
+        if (d0 < 0.0D) {
+            d3 -= d0;
+        } else if (d0 > 0.0D) {
+            d6 -= d0;
+        }
+
+        if (d1 < 0.0D) {
+            d4 -= d1;
+        } else if (d1 > 0.0D) {
+            d7 -= d1;
+        }
+
+        if (d2 < 0.0D) {
+            d5 -= d2;
+        } else if (d2 > 0.0D) {
+            d8 -= d2;
+        }
+
+        return new AxisAlignedBB(d3, d4, d5, d6, d7, d8);
+    }
+
+    public AxisAlignedBB expand(double x, double y, double z) { return b(x, y, z); } // Paper - OBFHELPER
+    public AxisAlignedBB b(double d0, double d1, double d2) {
+        double d3 = this.minX;
+        double d4 = this.minY;
+        double d5 = this.minZ;
+        double d6 = this.maxX;
+        double d7 = this.maxY;
+        double d8 = this.maxZ;
+
+        if (d0 < 0.0D) {
+            d3 += d0;
+        } else if (d0 > 0.0D) {
+            d6 += d0;
+        }
+
+        if (d1 < 0.0D) {
+            d4 += d1;
+        } else if (d1 > 0.0D) {
+            d7 += d1;
+        }
+
+        if (d2 < 0.0D) {
+            d5 += d2;
+        } else if (d2 > 0.0D) {
+            d8 += d2;
+        }
+
+        return new AxisAlignedBB(d3, d4, d5, d6, d7, d8);
+    }
+
+    // Paper start
+    public AxisAlignedBB grow(double d0) {
+        return grow(d0, d0, d0);
+    }
+    // Paper end
+
+    public AxisAlignedBB grow(double d0, double d1, double d2) {
+        double d3 = this.minX - d0;
+        double d4 = this.minY - d1;
+        double d5 = this.minZ - d2;
+        double d6 = this.maxX + d0;
+        double d7 = this.maxY + d1;
+        double d8 = this.maxZ + d2;
+
+        return new AxisAlignedBB(d3, d4, d5, d6, d7, d8);
+    }
+
+    public AxisAlignedBB g(double d0) {
+        return this.grow(d0, d0, d0);
+    }
+
+    public AxisAlignedBB a(AxisAlignedBB axisalignedbb) {
+        double d0 = Math.max(this.minX, axisalignedbb.minX);
+        double d1 = Math.max(this.minY, axisalignedbb.minY);
+        double d2 = Math.max(this.minZ, axisalignedbb.minZ);
+        double d3 = Math.min(this.maxX, axisalignedbb.maxX);
+        double d4 = Math.min(this.maxY, axisalignedbb.maxY);
+        double d5 = Math.min(this.maxZ, axisalignedbb.maxZ);
+
+        return new AxisAlignedBB(d0, d1, d2, d3, d4, d5);
+    }
+
+    public AxisAlignedBB b(AxisAlignedBB axisalignedbb) {
+        double d0 = Math.min(this.minX, axisalignedbb.minX);
+        double d1 = Math.min(this.minY, axisalignedbb.minY);
+        double d2 = Math.min(this.minZ, axisalignedbb.minZ);
+        double d3 = Math.max(this.maxX, axisalignedbb.maxX);
+        double d4 = Math.max(this.maxY, axisalignedbb.maxY);
+        double d5 = Math.max(this.maxZ, axisalignedbb.maxZ);
+
+        return new AxisAlignedBB(d0, d1, d2, d3, d4, d5);
+    }
+
+    public AxisAlignedBB d(double d0, double d1, double d2) {
+        return new AxisAlignedBB(this.minX + d0, this.minY + d1, this.minZ + d2, this.maxX + d0, this.maxY + d1, this.maxZ + d2);
+    }
+
+    public AxisAlignedBB a(BlockPosition blockposition) {
+        return new AxisAlignedBB(this.minX + (double) blockposition.getX(), this.minY + (double) blockposition.getY(), this.minZ + (double) blockposition.getZ(), this.maxX + (double) blockposition.getX(), this.maxY + (double) blockposition.getY(), this.maxZ + (double) blockposition.getZ());
+    }
+
+    public AxisAlignedBB a(Vec3D vec3d) {
+        return this.d(vec3d.x, vec3d.y, vec3d.z);
+    }
+
+    public boolean c(AxisAlignedBB axisalignedbb) {
+        return this.a(axisalignedbb.minX, axisalignedbb.minY, axisalignedbb.minZ, axisalignedbb.maxX, axisalignedbb.maxY, axisalignedbb.maxZ);
+    }
+
+    public boolean a(double d0, double d1, double d2, double d3, double d4, double d5) {
+        return this.minX < d3 && this.maxX > d0 && this.minY < d4 && this.maxY > d1 && this.minZ < d5 && this.maxZ > d2;
+    }
+
+    public boolean contains(Vec3D vec3d) { return b(vec3d); } // Paper - OBFHELPER
+    public boolean b(Vec3D vec3d) {
+        return this.e(vec3d.x, vec3d.y, vec3d.z);
+    }
+
+    public boolean e(double d0, double d1, double d2) {
+        return d0 >= this.minX && d0 < this.maxX && d1 >= this.minY && d1 < this.maxY && d2 >= this.minZ && d2 < this.maxZ;
+    }
+
+    public double a() {
+        double d0 = this.maxX - this.minX;
+        double d1 = this.maxY - this.minY;
+        double d2 = this.maxZ - this.minZ;
+
+        return (d0 + d1 + d2) / 3.0D;
+    }
+
+    public AxisAlignedBB f(double d0, double d1, double d2) {
+        return this.grow(-d0, -d1, -d2);
+    }
+
+    public AxisAlignedBB shrink(double d0) {
+        return this.g(-d0);
+    }
+
+    public MovingObjectPosition calculateIntercept(Vec3D vec3d, Vec3D vec3d1) { return b(vec3d, vec3d1); } // Paper - OBFHELPER
+    @Nullable
+    public MovingObjectPosition b(Vec3D vec3d, Vec3D vec3d1) {
+        return this.a(vec3d, vec3d1, (BlockPosition) null);
+    }
+
+    @Nullable
+    public MovingObjectPosition a(Vec3D vec3d, Vec3D vec3d1, @Nullable BlockPosition blockposition) {
+        double[] adouble = new double[] { 1.0D};
+        EnumDirection enumdirection = null;
+        double d0 = vec3d1.x - vec3d.x;
+        double d1 = vec3d1.y - vec3d.y;
+        double d2 = vec3d1.z - vec3d.z;
+
+        enumdirection = a(blockposition == null ? this : this.a(blockposition), vec3d, adouble, enumdirection, d0, d1, d2);
+        if (enumdirection == null) {
+            return null;
+        } else {
+            double d3 = adouble[0];
+
+            return new MovingObjectPosition(vec3d.add(d3 * d0, d3 * d1, d3 * d2), enumdirection, blockposition == null ? BlockPosition.ZERO : blockposition);
+        }
+    }
+
+    @Nullable
+    public static MovingObjectPosition a(Iterable<AxisAlignedBB> iterable, Vec3D vec3d, Vec3D vec3d1, BlockPosition blockposition) {
+        double[] adouble = new double[] { 1.0D};
+        EnumDirection enumdirection = null;
+        double d0 = vec3d1.x - vec3d.x;
+        double d1 = vec3d1.y - vec3d.y;
+        double d2 = vec3d1.z - vec3d.z;
+
+        AxisAlignedBB axisalignedbb;
+
+        for (Iterator iterator = iterable.iterator(); iterator.hasNext(); enumdirection = a(axisalignedbb.a(blockposition), vec3d, adouble, enumdirection, d0, d1, d2)) {
+            axisalignedbb = (AxisAlignedBB) iterator.next();
+        }
+
+        if (enumdirection == null) {
+            return null;
+        } else {
+            double d3 = adouble[0];
+
+            return new MovingObjectPosition(vec3d.add(d3 * d0, d3 * d1, d3 * d2), enumdirection, blockposition);
+        }
+    }
+
+    @Nullable
+    private static EnumDirection a(AxisAlignedBB axisalignedbb, Vec3D vec3d, double[] adouble, @Nullable EnumDirection enumdirection, double d0, double d1, double d2) {
+        if (d0 > 1.0E-7D) {
+            enumdirection = a(adouble, enumdirection, d0, d1, d2, axisalignedbb.minX, axisalignedbb.minY, axisalignedbb.maxY, axisalignedbb.minZ, axisalignedbb.maxZ, EnumDirection.WEST, vec3d.x, vec3d.y, vec3d.z);
+        } else if (d0 < -1.0E-7D) {
+            enumdirection = a(adouble, enumdirection, d0, d1, d2, axisalignedbb.maxX, axisalignedbb.minY, axisalignedbb.maxY, axisalignedbb.minZ, axisalignedbb.maxZ, EnumDirection.EAST, vec3d.x, vec3d.y, vec3d.z);
+        }
+
+        if (d1 > 1.0E-7D) {
+            enumdirection = a(adouble, enumdirection, d1, d2, d0, axisalignedbb.minY, axisalignedbb.minZ, axisalignedbb.maxZ, axisalignedbb.minX, axisalignedbb.maxX, EnumDirection.DOWN, vec3d.y, vec3d.z, vec3d.x);
+        } else if (d1 < -1.0E-7D) {
+            enumdirection = a(adouble, enumdirection, d1, d2, d0, axisalignedbb.maxY, axisalignedbb.minZ, axisalignedbb.maxZ, axisalignedbb.minX, axisalignedbb.maxX, EnumDirection.UP, vec3d.y, vec3d.z, vec3d.x);
+        }
+
+        if (d2 > 1.0E-7D) {
+            enumdirection = a(adouble, enumdirection, d2, d0, d1, axisalignedbb.minZ, axisalignedbb.minX, axisalignedbb.maxX, axisalignedbb.minY, axisalignedbb.maxY, EnumDirection.NORTH, vec3d.z, vec3d.x, vec3d.y);
+        } else if (d2 < -1.0E-7D) {
+            enumdirection = a(adouble, enumdirection, d2, d0, d1, axisalignedbb.maxZ, axisalignedbb.minX, axisalignedbb.maxX, axisalignedbb.minY, axisalignedbb.maxY, EnumDirection.SOUTH, vec3d.z, vec3d.x, vec3d.y);
+        }
+
+        return enumdirection;
+    }
+
+    @Nullable
+    private static EnumDirection a(double[] adouble, @Nullable EnumDirection enumdirection, double d0, double d1, double d2, double d3, double d4, double d5, double d6, double d7, EnumDirection enumdirection1, double d8, double d9, double d10) {
+        double d11 = (d3 - d8) / d0;
+        double d12 = d9 + d11 * d1;
+        double d13 = d10 + d11 * d2;
+
+        if (0.0D < d11 && d11 < adouble[0] && d4 - 1.0E-7D < d12 && d12 < d5 + 1.0E-7D && d6 - 1.0E-7D < d13 && d13 < d7 + 1.0E-7D) {
+            adouble[0] = d11;
+            return enumdirection1;
+        } else {
+            return enumdirection;
+        }
+    }
+
+    public String toString() {
+        return "box[" + this.minX + ", " + this.minY + ", " + this.minZ + " -> " + this.maxX + ", " + this.maxY + ", " + this.maxZ + "]";
+    }
+}

src/main/java/net/minecraft/server/BaseBlockPosition.java

@@ -0,0 +1,105 @@
+package net.minecraft.server;
+
+import com.google.common.base.MoreObjects;
+import javax.annotation.concurrent.Immutable;
+
+@Immutable
+public class BaseBlockPosition implements Comparable<BaseBlockPosition> {
+
+    public static final BaseBlockPosition ZERO = new BaseBlockPosition(0, 0, 0);
+    // Paper start
+    protected int x;
+    protected int y;
+    protected int z;
+    public boolean isValidLocation() {
+        return x >= -30000000 && z >= -30000000 && x < 30000000 && z < 30000000 && y >= 0 && y < 256;
+    }
+    public boolean isInvalidYLocation() {
+        return y < 0 || y >= 256;
+    }
+    // Paper end
+
+    public BaseBlockPosition(int i, int j, int k) {
+        this.x = i;
+        this.y = j;
+        this.z = k;
+    }
+
+    public BaseBlockPosition(double d0, double d1, double d2) {
+        this(MathHelper.floor(d0), MathHelper.floor(d1), MathHelper.floor(d2));
+    }
+
+    public boolean equals(Object object) {
+        if (this == object) {
+            return true;
+        } else if (!(object instanceof BaseBlockPosition)) {
+            return false;
+        } else {
+            BaseBlockPosition baseblockposition = (BaseBlockPosition) object;
+
+            return this.getX() != baseblockposition.getX() ? false : (this.getY() != baseblockposition.getY() ? false : this.getZ() == baseblockposition.getZ());
+        }
+    }
+
+    public int hashCode() {
+        return (this.getY() + this.getZ() * 31) * 31 + this.getX();
+    }
+
+    public int compareTo(BaseBlockPosition baseblockposition) {
+        return this.getY() == baseblockposition.getY() ? (this.getZ() == baseblockposition.getZ() ? this.getX() - baseblockposition.getX() : this.getZ() - baseblockposition.getZ()) : this.getY() - baseblockposition.getY();
+    }
+
+    // Paper start
+    public final int getX() {
+        return this.x;
+    }
+
+    public int getY() {
+        return this.y;
+    }
+
+    public int getZ() {
+        return this.z;
+    }
+    // Paper end
+
+    public BaseBlockPosition d(BaseBlockPosition baseblockposition) {
+        return new BaseBlockPosition(this.getY() * baseblockposition.getZ() - this.getZ() * baseblockposition.getY(), this.getZ() * baseblockposition.getX() - this.getX() * baseblockposition.getZ(), this.getX() * baseblockposition.getY() - this.getY() * baseblockposition.getX());
+    }
+
+    public double h(int i, int j, int k) {
+        double d0 = (double) (this.getX() - i);
+        double d1 = (double) (this.getY() - j);
+        double d2 = (double) (this.getZ() - k);
+
+        return Math.sqrt(d0 * d0 + d1 * d1 + d2 * d2);
+    }
+
+    public double m(BaseBlockPosition baseblockposition) {
+        return this.h(baseblockposition.getX(), baseblockposition.getY(), baseblockposition.getZ());
+    }
+
+    public double distanceSquared(double d0, double d1, double d2) {
+        double d3 = (double) this.getX() - d0;
+        double d4 = (double) this.getY() - d1;
+        double d5 = (double) this.getZ() - d2;
+
+        return d3 * d3 + d4 * d4 + d5 * d5;
+    }
+
+    public double g(double d0, double d1, double d2) {
+        double d3 = (double) this.getX() + 0.5D - d0;
+        double d4 = (double) this.getY() + 0.5D - d1;
+        double d5 = (double) this.getZ() + 0.5D - d2;
+
+        return d3 * d3 + d4 * d4 + d5 * d5;
+    }
+
+    public double n(BaseBlockPosition baseblockposition) {
+        return this.distanceSquared((double) baseblockposition.getX(), (double) baseblockposition.getY(), (double) baseblockposition.getZ());
+    }
+
+    public String toString() {
+        return MoreObjects.toStringHelper(this).add("x", this.getX()).add("y", this.getY()).add("z", this.getZ()).toString();
+    }
+}

src/main/java/net/minecraft/server/BiomeBase.java

@@ -0,0 +1,626 @@
+package net.minecraft.server;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.Set;
+import javax.annotation.Nullable;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+public abstract class BiomeBase {
+
+    public static final Logger a = LogManager.getLogger();
+    public static final WorldGenCarverAbstract<WorldGenFeatureConfigurationChance> b = new WorldGenCaves();
+    public static final WorldGenCarverAbstract<WorldGenFeatureConfigurationChance> c = new WorldGenCavesHell();
+    public static final WorldGenCarverAbstract<WorldGenFeatureConfigurationChance> d = new WorldGenCanyon();
+    public static final WorldGenCarverAbstract<WorldGenFeatureConfigurationChance> e = new WorldGenCanyonOcean();
+    public static final WorldGenCarverAbstract<WorldGenFeatureConfigurationChance> f = new WorldGenCavesOcean();
+    public static final WorldGenDecorator<WorldGenDecoratorFrequencyConfiguration> g = new WorldGenDecoratorHeight();
+    public static final WorldGenDecorator<WorldGenDecoratorFrequencyConfiguration> h = new WorldGenDecoratorSkyVisible();
+    public static final WorldGenDecorator<WorldGenDecoratorFrequencyConfiguration> i = new WorldGenDecoratorHeight32();
+    public static final WorldGenDecorator<WorldGenDecoratorFrequencyConfiguration> j = new WorldGenDecoratorHeightDouble();
+    public static final WorldGenDecorator<WorldGenDecoratorFrequencyConfiguration> k = new WorldGenDecoratorHeight64();
+    public static final WorldGenDecorator<WorldGenFeatureDecoratorNoiseConfiguration> l = new WorldGenDecoratorNoiseHeight32();
+    public static final WorldGenDecorator<WorldGenFeatureDecoratorNoiseConfiguration> m = new WorldGenDecoratorNoiseHeightDouble();
+    public static final WorldGenDecorator<WorldGenFeatureDecoratorEmptyConfiguration> n = new WorldGenDecoratorEmpty();
+    public static final WorldGenDecorator<WorldGenDecoratorChanceConfiguration> o = new WorldGenDecoratorChance();
+    public static final WorldGenDecorator<WorldGenDecoratorChanceConfiguration> p = new WorldGenDecoratorChanceHeight();
+    public static final WorldGenDecorator<WorldGenDecoratorChanceConfiguration> q = new WorldGenDecoratorChancePass();
+    public static final WorldGenDecorator<WorldGenDecoratorChanceConfiguration> r = new WorldGenDecoratorSkyVisibleBiased();
+    public static final WorldGenDecorator<WorldGenDecoratorFrequencyExtraChanceConfiguration> s = new WorldGenDecoratorHeightExtraChance();
+    public static final WorldGenDecorator<WorldGenFeatureChanceDecoratorCountConfiguration> t = new WorldGenDecoratorNetherHeight();
+    public static final WorldGenDecorator<WorldGenFeatureChanceDecoratorCountConfiguration> u = new WorldGenDecoratorHeightBiased();
+    public static final WorldGenDecorator<WorldGenFeatureChanceDecoratorCountConfiguration> v = new WorldGenDecoratorHeightBiased2();
+    public static final WorldGenDecorator<WorldGenFeatureChanceDecoratorCountConfiguration> w = new WorldGenDecoratorNetherRandomCount();
+    public static final WorldGenDecorator<WorldGenFeatureChanceDecoratorRangeConfiguration> x = new WorldGenDecoratorNetherChance();
+    public static final WorldGenDecorator<WorldGenDecoratorFrequencyChanceConfiguration> y = new WorldGenFeatureChanceDecorator();
+    public static final WorldGenDecorator<WorldGenDecoratorFrequencyChanceConfiguration> z = new WorldGenFeatureChanceDecoratorHeight();
+    public static final WorldGenDecorator<WorldGenDecoratorHeightAverageConfiguration> A = new WorldGenDecoratorHeightAverage();
+    public static final WorldGenDecorator<WorldGenFeatureDecoratorEmptyConfiguration> B = new WorldGenDecoratorSolidTop();
+    public static final WorldGenDecorator<WorldGenDecoratorRangeConfiguration> C = new WorldGenDecoratorSolidTopHeight();
+    public static final WorldGenDecorator<WorldGenDecoratorNoiseConfiguration> D = new WorldGenDecoratorSolidTopNoise();
+    public static final WorldGenDecorator<WorldGenDecoratorCarveMaskConfiguration> E = new WorldGenDecoratorCarveMask();
+    public static final WorldGenDecorator<WorldGenDecoratorFrequencyConfiguration> F = new WorldGenDecoratorForestRock();
+    public static final WorldGenDecorator<WorldGenDecoratorFrequencyConfiguration> G = new WorldGenDecoratorNetherFire();
+    public static final WorldGenDecorator<WorldGenDecoratorFrequencyConfiguration> H = new WorldGenDecoratorNetherMagma();
+    public static final WorldGenDecorator<WorldGenFeatureDecoratorEmptyConfiguration> I = new WorldGenDecoratorEmerald();
+    public static final WorldGenDecorator<WorldGenDecoratorLakeChanceConfiguration> J = new WorldGenDecoratorLakeLava();
+    public static final WorldGenDecorator<WorldGenDecoratorLakeChanceConfiguration> K = new WorldGenDecoratorLakeWater();
+    public static final WorldGenDecorator<WorldGenDecoratorDungeonConfiguration> L = new WorldGenDecoratorDungeon();
+    public static final WorldGenDecorator<WorldGenFeatureDecoratorEmptyConfiguration> M = new WorldGenDecoratorRoofedTree();
+    public static final WorldGenDecorator<WorldGenDecoratorChanceConfiguration> N = new WorldGenDecoratorIceburg();
+    public static final WorldGenDecorator<WorldGenDecoratorFrequencyConfiguration> O = new WorldGenDecoratorNetherGlowstone();
+    public static final WorldGenDecorator<WorldGenFeatureDecoratorEmptyConfiguration> P = new WorldGenDecoratorSpike();
+    public static final WorldGenDecorator<WorldGenFeatureDecoratorEmptyConfiguration> Q = new WorldGenDecoratorEndIsland();
+    public static final WorldGenDecorator<WorldGenFeatureDecoratorEmptyConfiguration> R = new WorldGenDecoratorChorusPlant();
+    public static final WorldGenDecorator<WorldGenFeatureDecoratorEmptyConfiguration> S = new WorldGenDecoratorEndGateway();
+    protected static final IBlockData T = Blocks.AIR.getBlockData();
+    protected static final IBlockData U = Blocks.DIRT.getBlockData();
+    protected static final IBlockData V = Blocks.GRASS_BLOCK.getBlockData();
+    protected static final IBlockData W = Blocks.PODZOL.getBlockData();
+    protected static final IBlockData X = Blocks.GRAVEL.getBlockData();
+    protected static final IBlockData Y = Blocks.STONE.getBlockData();
+    protected static final IBlockData Z = Blocks.COARSE_DIRT.getBlockData();
+    protected static final IBlockData aa = Blocks.SAND.getBlockData();
+    protected static final IBlockData ab = Blocks.RED_SAND.getBlockData();
+    protected static final IBlockData ac = Blocks.WHITE_TERRACOTTA.getBlockData();
+    protected static final IBlockData ad = Blocks.MYCELIUM.getBlockData();
+    protected static final IBlockData ae = Blocks.NETHERRACK.getBlockData();
+    protected static final IBlockData af = Blocks.END_STONE.getBlockData();
+    public static final WorldGenSurfaceConfigurationBase ag = new WorldGenSurfaceConfigurationBase(BiomeBase.T, BiomeBase.T, BiomeBase.T);
+    public static final WorldGenSurfaceConfigurationBase ah = new WorldGenSurfaceConfigurationBase(BiomeBase.U, BiomeBase.U, BiomeBase.X);
+    public static final WorldGenSurfaceConfigurationBase ai = new WorldGenSurfaceConfigurationBase(BiomeBase.V, BiomeBase.U, BiomeBase.X);
+    public static final WorldGenSurfaceConfigurationBase aj = new WorldGenSurfaceConfigurationBase(BiomeBase.Y, BiomeBase.Y, BiomeBase.X);
+    public static final WorldGenSurfaceConfigurationBase ak = new WorldGenSurfaceConfigurationBase(BiomeBase.X, BiomeBase.X, BiomeBase.X);
+    public static final WorldGenSurfaceConfigurationBase al = new WorldGenSurfaceConfigurationBase(BiomeBase.Z, BiomeBase.U, BiomeBase.X);
+    public static final WorldGenSurfaceConfigurationBase am = new WorldGenSurfaceConfigurationBase(BiomeBase.W, BiomeBase.U, BiomeBase.X);
+    public static final WorldGenSurfaceConfigurationBase an = new WorldGenSurfaceConfigurationBase(BiomeBase.aa, BiomeBase.aa, BiomeBase.aa);
+    public static final WorldGenSurfaceConfigurationBase ao = new WorldGenSurfaceConfigurationBase(BiomeBase.V, BiomeBase.U, BiomeBase.aa);
+    public static final WorldGenSurfaceConfigurationBase ap = new WorldGenSurfaceConfigurationBase(BiomeBase.aa, BiomeBase.aa, BiomeBase.X);
+    public static final WorldGenSurfaceConfigurationBase aq = new WorldGenSurfaceConfigurationBase(BiomeBase.ab, BiomeBase.ac, BiomeBase.X);
+    public static final WorldGenSurfaceConfigurationBase ar = new WorldGenSurfaceConfigurationBase(BiomeBase.ad, BiomeBase.U, BiomeBase.X);
+    public static final WorldGenSurfaceConfigurationBase as = new WorldGenSurfaceConfigurationBase(BiomeBase.ae, BiomeBase.ae, BiomeBase.ae);
+    public static final WorldGenSurfaceConfigurationBase at = new WorldGenSurfaceConfigurationBase(BiomeBase.af, BiomeBase.af, BiomeBase.af);
+    public static final WorldGenSurface<WorldGenSurfaceConfigurationBase> au = new WorldGenSurfaceDefaultBlock();
+    public static final WorldGenSurface<WorldGenSurfaceConfigurationBase> av = new WorldGenSurfaceExtremeHills();
+    public static final WorldGenSurface<WorldGenSurfaceConfigurationBase> aw = new WorldGenSurfaceSavannaMutated();
+    public static final WorldGenSurface<WorldGenSurfaceConfigurationBase> ax = new WorldGenSurfaceExtremeHillMutated();
+    public static final WorldGenSurface<WorldGenSurfaceConfigurationBase> ay = new WorldGenSurfaceTaigaMega();
+    public static final WorldGenSurface<WorldGenSurfaceConfigurationBase> az = new WorldGenSurfaceSwamp();
+    public static final WorldGenSurface<WorldGenSurfaceConfigurationBase> aA = new WorldGenSurfaceMesa();
+    public static final WorldGenSurface<WorldGenSurfaceConfigurationBase> aB = new WorldGenSurfaceMesaForest();
+    public static final WorldGenSurface<WorldGenSurfaceConfigurationBase> aC = new WorldGenSurfaceMesaBryce();
+    public static final WorldGenSurface<WorldGenSurfaceConfigurationBase> aD = new WorldGenSurfaceFrozenOcean();
+    public static final WorldGenSurface<WorldGenSurfaceConfigurationBase> aE = new WorldGenSurfaceNether();
+    public static final WorldGenSurface<WorldGenSurfaceConfigurationBase> aF = new WorldGenSurfaceEmpty();
+    public static final Set<BiomeBase> aG = Sets.newHashSet();
+    public static final RegistryBlockID<BiomeBase> aH = new RegistryBlockID<>();
+    protected static final NoiseGenerator3 aI = new NoiseGenerator3(new Random(1234L), 1);
+    public static final NoiseGenerator3 aJ = new NoiseGenerator3(new Random(2345L), 1);
+    @Nullable
+    protected String aK;
+    protected final float aL;
+    protected final float aM;
+    protected final float aN;
+    protected final float aO;
+    protected final int aP;
+    protected final int aQ;
+    @Nullable
+    protected final String aR;
+    protected final WorldGenSurfaceComposite<?> aS;
+    protected final BiomeBase.Geography aT;
+    protected final BiomeBase.Precipitation aU;
+    protected final Map<WorldGenStage.Features, List<WorldGenCarverWrapper<?>>> aV = Maps.newHashMap();
+    protected final Map<WorldGenStage.Decoration, List<WorldGenFeatureComposite<?, ?>>> aW = Maps.newHashMap();
+    protected final List<WorldGenFeatureCompositeFlower<?>> aX = Lists.newArrayList();
+    protected final Map<StructureGenerator<?>, WorldGenFeatureConfiguration> aY = Maps.newHashMap();
+    private final java.util.EnumMap<EnumCreatureType, List<BiomeBase.BiomeMeta>> aZ = Maps.newEnumMap(EnumCreatureType.class); // Paper
+
+    @Nullable
+    public static BiomeBase a(BiomeBase biomebase) {
+        return (BiomeBase) BiomeBase.aH.fromId(IRegistry.BIOME.a(biomebase)); // Paper - decompile fix
+    }
+
+    public static <C extends WorldGenFeatureConfiguration> WorldGenCarverWrapper<C> a(WorldGenCarver<C> worldgencarver, C c0) {
+        return new WorldGenCarverWrapper<>(worldgencarver, c0);
+    }
+
+    public static <F extends WorldGenFeatureConfiguration, D extends WorldGenFeatureDecoratorConfiguration> WorldGenFeatureComposite<F, D> a(WorldGenerator<F> worldgenerator, F f0, WorldGenDecorator<D> worldgendecorator, D d0) {
+        return new WorldGenFeatureComposite<>(worldgenerator, f0, worldgendecorator, d0);
+    }
+
+    public static <D extends WorldGenFeatureDecoratorConfiguration> WorldGenFeatureCompositeFlower<D> a(WorldGenFlowers worldgenflowers, WorldGenDecorator<D> worldgendecorator, D d0) {
+        return new WorldGenFeatureCompositeFlower<>(worldgenflowers, worldgendecorator, d0);
+    }
+
+    protected BiomeBase(BiomeBase.a biomebase_a) {
+        if (biomebase_a.a != null && biomebase_a.b != null && biomebase_a.c != null && biomebase_a.d != null && biomebase_a.e != null && biomebase_a.f != null && biomebase_a.g != null && biomebase_a.h != null && biomebase_a.i != null) {
+            this.aS = biomebase_a.a;
+            this.aU = biomebase_a.b;
+            this.aT = biomebase_a.c;
+            this.aL = biomebase_a.d;
+            this.aM = biomebase_a.e;
+            this.aN = biomebase_a.f;
+            this.aO = biomebase_a.g;
+            this.aP = biomebase_a.h;
+            this.aQ = biomebase_a.i;
+            this.aR = biomebase_a.j;
+            WorldGenStage.Decoration[] aworldgenstage_decoration = WorldGenStage.Decoration.values();
+            int i = aworldgenstage_decoration.length;
+
+            int j;
+
+            for (j = 0; j < i; ++j) {
+                WorldGenStage.Decoration worldgenstage_decoration = aworldgenstage_decoration[j];
+
+                this.aW.put(worldgenstage_decoration, Lists.newArrayList());
+            }
+
+            EnumCreatureType[] aenumcreaturetype = EnumCreatureType.values();
+
+            i = aenumcreaturetype.length;
+
+            for (j = 0; j < i; ++j) {
+                EnumCreatureType enumcreaturetype = aenumcreaturetype[j];
+
+                this.aZ.put(enumcreaturetype, new MobList()); // Paper
+            }
+
+        } else {
+            throw new IllegalStateException("You are missing parameters to build a proper biome for " + this.getClass().getSimpleName() + "\n" + biomebase_a);
+        }
+    }
+
+    protected void a() {
+        this.a(WorldGenStage.Decoration.UNDERGROUND_STRUCTURES, a(WorldGenerator.f, new WorldGenMineshaftConfiguration(0.004000000189989805D, WorldGenMineshaft.Type.NORMAL), BiomeBase.n, WorldGenFeatureDecoratorConfiguration.e));
+        this.a(WorldGenStage.Decoration.SURFACE_STRUCTURES, a(WorldGenerator.e, new WorldGenFeatureVillageConfiguration(0, WorldGenVillagePieces.Material.OAK), BiomeBase.n, WorldGenFeatureDecoratorConfiguration.e));
+        this.a(WorldGenStage.Decoration.UNDERGROUND_STRUCTURES, a(WorldGenerator.m, new WorldGenFeatureStrongholdConfiguration(), BiomeBase.n, WorldGenFeatureDecoratorConfiguration.e));
+        this.a(WorldGenStage.Decoration.SURFACE_STRUCTURES, a(WorldGenerator.l, new WorldGenFeatureSwampHutConfiguration(), BiomeBase.n, WorldGenFeatureDecoratorConfiguration.e));
+        this.a(WorldGenStage.Decoration.SURFACE_STRUCTURES, a(WorldGenerator.i, new WorldGenFeatureDesertPyramidConfiguration(), BiomeBase.n, WorldGenFeatureDecoratorConfiguration.e));
+        this.a(WorldGenStage.Decoration.SURFACE_STRUCTURES, a(WorldGenerator.h, new WorldGenFeatureJunglePyramidConfiguration(), BiomeBase.n, WorldGenFeatureDecoratorConfiguration.e));
+        this.a(WorldGenStage.Decoration.SURFACE_STRUCTURES, a(WorldGenerator.j, new WorldGenFeatureIglooConfiguration(), BiomeBase.n, WorldGenFeatureDecoratorConfiguration.e));
+        this.a(WorldGenStage.Decoration.SURFACE_STRUCTURES, a(WorldGenerator.k, new WorldGenFeatureShipwreckConfiguration(false), BiomeBase.n, WorldGenFeatureDecoratorConfiguration.e));
+        this.a(WorldGenStage.Decoration.SURFACE_STRUCTURES, a(WorldGenerator.n, new WorldGenMonumentConfiguration(), BiomeBase.n, WorldGenFeatureDecoratorConfiguration.e));
+        this.a(WorldGenStage.Decoration.SURFACE_STRUCTURES, a(WorldGenerator.g, new WorldGenMansionConfiguration(), BiomeBase.n, WorldGenFeatureDecoratorConfiguration.e));
+        this.a(WorldGenStage.Decoration.SURFACE_STRUCTURES, a(WorldGenerator.o, new WorldGenFeatureOceanRuinConfiguration(WorldGenFeatureOceanRuin.Temperature.COLD, 0.3F, 0.9F), BiomeBase.n, WorldGenFeatureDecoratorConfiguration.e));
+        this.a(WorldGenStage.Decoration.UNDERGROUND_STRUCTURES, a(WorldGenerator.r, new WorldGenBuriedTreasureConfiguration(0.01F), BiomeBase.n, WorldGenFeatureDecoratorConfiguration.e));
+    }
+
+    public boolean b() {
+        return this.aR != null;
+    }
+
+    protected void a(EnumCreatureType enumcreaturetype, BiomeBase.BiomeMeta biomebase_biomemeta) {
+        ((List) this.aZ.get(enumcreaturetype)).add(biomebase_biomemeta);
+    }
+
+    public List<BiomeBase.BiomeMeta> getMobs(EnumCreatureType enumcreaturetype) {
+        return (List) this.aZ.get(enumcreaturetype);
+    }
+
+    public BiomeBase.Precipitation c() {
+        return this.aU;
+    }
+
+    public boolean d() {
+        return this.getHumidity() > 0.85F;
+    }
+
+    public float e() {
+        return 0.1F;
+    }
+
+    public float getAdjustedTemperature(BlockPosition blockposition) {
+        if (blockposition.getY() > 64) {
+            float f = (float) (BiomeBase.aI.a((double) ((float) blockposition.getX() / 8.0F), (double) ((float) blockposition.getZ() / 8.0F)) * 4.0D);
+
+            return this.getTemperature() - (f + (float) blockposition.getY() - 64.0F) * 0.05F / 30.0F;
+        } else {
+            return this.getTemperature();
+        }
+    }
+
+    public boolean a(IWorldReader iworldreader, BlockPosition blockposition) {
+        return this.a(iworldreader, blockposition, true);
+    }
+
+    public boolean a(IWorldReader iworldreader, BlockPosition blockposition, boolean flag) {
+        if (this.getAdjustedTemperature(blockposition) >= 0.15F) {
+            return false;
+        } else {
+            if (blockposition.getY() >= 0 && blockposition.getY() < 256 && iworldreader.getBrightness(EnumSkyBlock.BLOCK, blockposition) < 10) {
+                IBlockData iblockdata = iworldreader.getType(blockposition);
+                Fluid fluid = iworldreader.getFluid(blockposition);
+
+                if (fluid.c() == FluidTypes.WATER && iblockdata.getBlock() instanceof BlockFluids) {
+                    if (!flag) {
+                        return true;
+                    }
+
+                    boolean flag1 = iworldreader.B(blockposition.west()) && iworldreader.B(blockposition.east()) && iworldreader.B(blockposition.north()) && iworldreader.B(blockposition.south());
+
+                    if (!flag1) {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+    }
+
+    public boolean b(IWorldReader iworldreader, BlockPosition blockposition) {
+        if (this.getAdjustedTemperature(blockposition) >= 0.15F) {
+            return false;
+        } else {
+            if (blockposition.getY() >= 0 && blockposition.getY() < 256 && iworldreader.getBrightness(EnumSkyBlock.BLOCK, blockposition) < 10) {
+                IBlockData iblockdata = iworldreader.getType(blockposition);
+
+                if (iblockdata.isAir() && Blocks.SNOW.getBlockData().canPlace(iworldreader, blockposition)) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    }
+
+    public void a(WorldGenStage.Decoration worldgenstage_decoration, WorldGenFeatureComposite<?, ?> worldgenfeaturecomposite) {
+        if (worldgenfeaturecomposite instanceof WorldGenFeatureCompositeFlower) {
+            this.aX.add((WorldGenFeatureCompositeFlower) worldgenfeaturecomposite);
+        }
+
+        ((List) this.aW.get(worldgenstage_decoration)).add(worldgenfeaturecomposite);
+    }
+
+    public <C extends WorldGenFeatureConfiguration> void a(WorldGenStage.Features worldgenstage_features, WorldGenCarverWrapper<C> worldgencarverwrapper) {
+        ((List) this.aV.computeIfAbsent(worldgenstage_features, (worldgenstage_features1) -> {
+            return Lists.newArrayList();
+        })).add(worldgencarverwrapper);
+    }
+
+    public List<WorldGenCarverWrapper<?>> a(WorldGenStage.Features worldgenstage_features) {
+        return (List) this.aV.computeIfAbsent(worldgenstage_features, (worldgenstage_features1) -> {
+            return Lists.newArrayList();
+        });
+    }
+
+    public <C extends WorldGenFeatureConfiguration> void a(StructureGenerator<C> structuregenerator, C c0) {
+        this.aY.put(structuregenerator, c0);
+    }
+
+    public <C extends WorldGenFeatureConfiguration> boolean a(StructureGenerator<C> structuregenerator) {
+        return this.aY.containsKey(structuregenerator);
+    }
+
+    @Nullable
+    public <C extends WorldGenFeatureConfiguration> WorldGenFeatureConfiguration b(StructureGenerator<C> structuregenerator) {
+        return (WorldGenFeatureConfiguration) this.aY.get(structuregenerator);
+    }
+
+    public List<WorldGenFeatureCompositeFlower<?>> f() {
+        return this.aX;
+    }
+
+    public List<WorldGenFeatureComposite<?, ?>> a(WorldGenStage.Decoration worldgenstage_decoration) {
+        return (List) this.aW.get(worldgenstage_decoration);
+    }
+
+    public void a(WorldGenStage.Decoration worldgenstage_decoration, ChunkGenerator<? extends GeneratorSettings> chunkgenerator, GeneratorAccess generatoraccess, long i, SeededRandom seededrandom, BlockPosition blockposition) {
+        int j = 0;
+
+        for (Iterator iterator = ((List) this.aW.get(worldgenstage_decoration)).iterator(); iterator.hasNext(); ++j) {
+            WorldGenFeatureComposite<?, ?> worldgenfeaturecomposite = (WorldGenFeatureComposite) iterator.next();
+
+            seededrandom.b(i, j, worldgenstage_decoration.ordinal());
+            worldgenfeaturecomposite.a(generatoraccess, chunkgenerator, seededrandom, blockposition, WorldGenFeatureConfiguration.e);
+        }
+
+    }
+
+    public void a(Random random, IChunkAccess ichunkaccess, int i, int j, int k, double d0, IBlockData iblockdata, IBlockData iblockdata1, int l, long i1) {
+        this.aS.a(i1);
+        this.aS.a(random, ichunkaccess, this, i, j, k, d0, iblockdata, iblockdata1, l, i1, BiomeBase.ag);
+    }
+
+    public BiomeBase.EnumTemperature g() {
+        return this.aT == BiomeBase.Geography.OCEAN ? BiomeBase.EnumTemperature.OCEAN : ((double) this.getTemperature() < 0.2D ? BiomeBase.EnumTemperature.COLD : ((double) this.getTemperature() < 1.0D ? BiomeBase.EnumTemperature.MEDIUM : BiomeBase.EnumTemperature.WARM));
+    }
+
+    public static BiomeBase getBiome(int i, BiomeBase biomebase) {
+        BiomeBase biomebase1 = (BiomeBase) IRegistry.BIOME.fromId(i);
+
+        return biomebase1 == null ? biomebase : biomebase1;
+    }
+
+    public final float h() {
+        return this.aL;
+    }
+
+    public final float getHumidity() {
+        return this.aO;
+    }
+
+    public String k() {
+        if (this.aK == null) {
+            this.aK = SystemUtils.a("biome", IRegistry.BIOME.getKey(this));
+        }
+
+        return this.aK;
+    }
+
+    public final float l() {
+        return this.aM;
+    }
+
+    public final float getTemperature() {
+        return this.aN;
+    }
+
+    public final int n() {
+        return this.aP;
+    }
+
+    public final int o() {
+        return this.aQ;
+    }
+
+    public final BiomeBase.Geography p() {
+        return this.aT;
+    }
+
+    public WorldGenSurfaceComposite<?> q() {
+        return this.aS;
+    }
+
+    public WorldGenSurfaceConfiguration r() {
+        return this.aS.a();
+    }
+
+    @Nullable
+    public String s() {
+        return this.aR;
+    }
+
+    public static void t() {
+        a(0, "ocean", new BiomeOcean());
+        a(1, "plains", new BiomePlains());
+        a(2, "desert", new BiomeDesert());
+        a(3, "mountains", new BiomeBigHills());
+        a(4, "forest", new BiomeForest());
+        a(5, "taiga", new BiomeTaiga());
+        a(6, "swamp", new BiomeSwamp());
+        a(7, "river", new BiomeRiver());
+        a(8, "nether", new BiomeHell());
+        a(9, "the_end", new BiomeTheEnd());
+        a(10, "frozen_ocean", new BiomeFrozenOcean());
+        a(11, "frozen_river", new BiomeFrozenRiver());
+        a(12, "snowy_tundra", new BiomeIcePlains());
+        a(13, "snowy_mountains", new BiomeIceMountains());
+        a(14, "mushroom_fields", new BiomeMushrooms());
+        a(15, "mushroom_field_shore", new BiomeMushroomIslandShore());
+        a(16, "beach", new BiomeBeach());
+        a(17, "desert_hills", new BiomeDesertHills());
+        a(18, "wooded_hills", new BiomeForestHills());
+        a(19, "taiga_hills", new BiomeTaigaHills());
+        a(20, "mountain_edge", new BiomeExtremeHillsEdge());
+        a(21, "jungle", new BiomeJungle());
+        a(22, "jungle_hills", new BiomeJungleHills());
+        a(23, "jungle_edge", new BiomeJungleEdge());
+        a(24, "deep_ocean", new BiomeDeepOcean());
+        a(25, "stone_shore", new BiomeStoneBeach());
+        a(26, "snowy_beach", new BiomeColdBeach());
+        a(27, "birch_forest", new BiomeBirchForest());
+        a(28, "birch_forest_hills", new BiomeBirchForestHills());
+        a(29, "dark_forest", new BiomeRoofedForest());
+        a(30, "snowy_taiga", new BiomeColdTaiga());
+        a(31, "snowy_taiga_hills", new BiomeColdTaigaHills());
+        a(32, "giant_tree_taiga", new BiomeMegaTaiga());
+        a(33, "giant_tree_taiga_hills", new BiomeMegaTaigaHills());
+        a(34, "wooded_mountains", new BiomeExtremeHillsWithTrees());
+        a(35, "savanna", new BiomeSavanna());
+        a(36, "savanna_plateau", new BiomeSavannaPlateau());
+        a(37, "badlands", new BiomeMesa());
+        a(38, "wooded_badlands_plateau", new BiomeMesaPlataeu());
+        a(39, "badlands_plateau", new BiomeMesaPlataeuClear());
+        a(40, "small_end_islands", new BiomeTheEndFloatingIslands());
+        a(41, "end_midlands", new BiomeTheEndMediumIsland());
+        a(42, "end_highlands", new BiomeTheEndHighIsland());
+        a(43, "end_barrens", new BiomeTheEndBarrenIsland());
+        a(44, "warm_ocean", new BiomeWarmOcean());
+        a(45, "lukewarm_ocean", new BiomeLukewarmOcean());
+        a(46, "cold_ocean", new BiomeColdOcean());
+        a(47, "deep_warm_ocean", new BiomeWarmDeepOcean());
+        a(48, "deep_lukewarm_ocean", new BiomeLukewarmDeepOcean());
+        a(49, "deep_cold_ocean", new BiomeColdDeepOcean());
+        a(50, "deep_frozen_ocean", new BiomeFrozenDeepOcean());
+        a(127, "the_void", new BiomeVoid());
+        a(129, "sunflower_plains", new BiomeSunflowerPlains());
+        a(130, "desert_lakes", new BiomeDesertMutated());
+        a(131, "gravelly_mountains", new BiomeExtremeHillsMutated());
+        a(132, "flower_forest", new BiomeFlowerForest());
+        a(133, "taiga_mountains", new BiomeTaigaMutated());
+        a(134, "swamp_hills", new BiomeSwamplandMutated());
+        a(140, "ice_spikes", new BiomeIcePlainsSpikes());
+        a(149, "modified_jungle", new BiomeJungleMutated());
+        a(151, "modified_jungle_edge", new BiomeJungleEdgeMutated());
+        a(155, "tall_birch_forest", new BiomeBirchForestMutated());
+        a(156, "tall_birch_hills", new BiomeBirchForestHillsMutated());
+        a(157, "dark_forest_hills", new BiomeRoofedForestMutated());
+        a(158, "snowy_taiga_mountains", new BiomeColdTaigaMutated());
+        a(160, "giant_spruce_taiga", new BiomeMegaSpruceTaiga());
+        a(161, "giant_spruce_taiga_hills", new BiomeRedwoodTaigaHillsMutated());
+        a(162, "modified_gravelly_mountains", new BiomeExtremeHillsWithTreesMutated());
+        a(163, "shattered_savanna", new BiomeSavannaMutated());
+        a(164, "shattered_savanna_plateau", new BiomeSavannaPlateauMutated());
+        a(165, "eroded_badlands", new BiomeMesaBryce());
+        a(166, "modified_wooded_badlands_plateau", new BiomeMesaPlateauMutated());
+        a(167, "modified_badlands_plateau", new BiomeMesaPlateauClearMutated());
+        Collections.addAll(BiomeBase.aG, new BiomeBase[] { Biomes.OCEAN, Biomes.PLAINS, Biomes.DESERT, Biomes.MOUNTAINS, Biomes.FOREST, Biomes.TAIGA, Biomes.SWAMP, Biomes.RIVER, Biomes.FROZEN_RIVER, Biomes.SNOWY_TUNDRA, Biomes.SNOWY_MOUNTAINS, Biomes.MUSHROOM_FIELDS, Biomes.MUSHROOM_FIELD_SHORE, Biomes.BEACH, Biomes.DESERT_HILLS, Biomes.WOODED_HILLS, Biomes.TAIGA_HILLS, Biomes.JUNGLE, Biomes.JUNGLE_HILLS, Biomes.JUNGLE_EDGE, Biomes.DEEP_OCEAN, Biomes.STONE_SHORE, Biomes.SNOWY_BEACH, Biomes.BIRCH_FOREST, Biomes.BIRCH_FOREST_HILLS, Biomes.DARK_FOREST, Biomes.SNOWY_TAIGA, Biomes.SNOWY_TAIGA_HILLS, Biomes.GIANT_TREE_TAIGA, Biomes.GIANT_TREE_TAIGA_HILLS, Biomes.WOODED_MOUNTAINS, Biomes.SAVANNA, Biomes.SAVANNA_PLATEAU, Biomes.BADLANDS, Biomes.WOODED_BADLANDS_PLATEAU, Biomes.BADLANDS_PLATEAU});
+    }
+
+    private static void a(int i, String s, BiomeBase biomebase) {
+        IRegistry.BIOME.a(i, new MinecraftKey(s), biomebase);
+        if (biomebase.b()) {
+            BiomeBase.aH.a(biomebase, IRegistry.BIOME.a(IRegistry.BIOME.get(new MinecraftKey(biomebase.aR))));
+        }
+
+    }
+
+    // Paper start - keep track of data in a pair set to give O(1) contains calls - we have to hook removals incase plugins mess with it
+    public static class MobList extends java.util.ArrayList<BiomeMeta> {
+        java.util.Set<BiomeMeta> biomes = new java.util.HashSet<>();
+
+        @Override
+        public boolean contains(Object o) {
+            return biomes.contains(o);
+        }
+
+        @Override
+        public boolean add(BiomeMeta biomeMeta) {
+            biomes.add(biomeMeta);
+            return super.add(biomeMeta);
+        }
+
+        @Override
+        public BiomeMeta remove(int index) {
+            BiomeMeta removed = super.remove(index);
+            if (removed != null) {
+                biomes.remove(removed);
+            }
+            return removed;
+        }
+
+        @Override
+        public void clear() {
+            biomes.clear();
+            super.clear();
+        }
+    }
+    // Paper end
+
+    public static class a {
+
+        @Nullable
+        private WorldGenSurfaceComposite<?> a;
+        @Nullable
+        private BiomeBase.Precipitation b;
+        @Nullable
+        private BiomeBase.Geography c;
+        @Nullable
+        private Float d;
+        @Nullable
+        private Float e;
+        @Nullable
+        private Float f;
+        @Nullable
+        private Float g;
+        @Nullable
+        private Integer h;
+        @Nullable
+        private Integer i;
+        @Nullable
+        private String j;
+
+        public a() {}
+
+        public BiomeBase.a a(WorldGenSurfaceComposite<?> worldgensurfacecomposite) {
+            this.a = worldgensurfacecomposite;
+            return this;
+        }
+
+        public BiomeBase.a a(BiomeBase.Precipitation biomebase_precipitation) {
+            this.b = biomebase_precipitation;
+            return this;
+        }
+
+        public BiomeBase.a a(BiomeBase.Geography biomebase_geography) {
+            this.c = biomebase_geography;
+            return this;
+        }
+
+        public BiomeBase.a a(float f) {
+            this.d = f;
+            return this;
+        }
+
+        public BiomeBase.a b(float f) {
+            this.e = f;
+            return this;
+        }
+
+        public BiomeBase.a c(float f) {
+            this.f = f;
+            return this;
+        }
+
+        public BiomeBase.a d(float f) {
+            this.g = f;
+            return this;
+        }
+
+        public BiomeBase.a a(int i) {
+            this.h = i;
+            return this;
+        }
+
+        public BiomeBase.a b(int i) {
+            this.i = i;
+            return this;
+        }
+
+        public BiomeBase.a a(@Nullable String s) {
+            this.j = s;
+            return this;
+        }
+
+        public String toString() {
+            return "BiomeBuilder{\nsurfaceBuilder=" + this.a + ",\nprecipitation=" + this.b + ",\nbiomeCategory=" + this.c + ",\ndepth=" + this.d + ",\nscale=" + this.e + ",\ntemperature=" + this.f + ",\ndownfall=" + this.g + ",\nwaterColor=" + this.h + ",\nwaterFogColor=" + this.i + ",\nparent='" + this.j + '\'' + "\n" + '}';
+        }
+    }
+
+    public static class BiomeMeta extends WeightedRandom.WeightedRandomChoice {
+
+        public EntityTypes<? extends EntityInsentient> b;
+        public int c;
+        public int d;
+
+        public BiomeMeta(EntityTypes<? extends EntityInsentient> entitytypes, int i, int j, int k) {
+            super(i);
+            this.b = entitytypes;
+            this.c = j;
+            this.d = k;
+        }
+
+        public String toString() {
+            return EntityTypes.getName(this.b) + "*(" + this.c + "-" + this.d + "):" + this.a;
+        }
+    }
+
+    public static enum Precipitation {
+
+        NONE, RAIN, SNOW;
+
+        private Precipitation() {}
+    }
+
+    public static enum Geography {
+
+        NONE, TAIGA, EXTREME_HILLS, JUNGLE, MESA, PLAINS, SAVANNA, ICY, THEEND, BEACH, FOREST, OCEAN, DESERT, RIVER, SWAMP, MUSHROOM, NETHER;
+
+        private Geography() {}
+    }
+
+    public static enum EnumTemperature {
+
+        OCEAN, COLD, MEDIUM, WARM;
+
+        private EnumTemperature() {}
+    }
+}

src/main/java/net/minecraft/server/BlockBeacon.java

@@ -0,0 +1,78 @@
+package net.minecraft.server;
+
+public class BlockBeacon extends BlockTileEntity {
+
+    public BlockBeacon(Block.Info block_info) {
+        super(block_info);
+    }
+
+    public TileEntity a(IBlockAccess iblockaccess) {
+        return new TileEntityBeacon();
+    }
+
+    public boolean interact(IBlockData iblockdata, World world, BlockPosition blockposition, EntityHuman entityhuman, EnumHand enumhand, EnumDirection enumdirection, float f, float f1, float f2) {
+        if (world.isClientSide) {
+            return true;
+        } else {
+            TileEntity tileentity = world.getTileEntity(blockposition);
+
+            if (tileentity instanceof TileEntityBeacon) {
+                entityhuman.openContainer((TileEntityBeacon) tileentity);
+                entityhuman.a(StatisticList.INTERACT_WITH_BEACON);
+            }
+
+            return true;
+        }
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public EnumRenderType c(IBlockData iblockdata) {
+        return EnumRenderType.MODEL;
+    }
+
+    public void postPlace(World world, BlockPosition blockposition, IBlockData iblockdata, EntityLiving entityliving, ItemStack itemstack) {
+        if (itemstack.hasName()) {
+            TileEntity tileentity = world.getTileEntity(blockposition);
+
+            if (tileentity instanceof TileEntityBeacon) {
+                ((TileEntityBeacon) tileentity).setCustomName(itemstack.getName());
+            }
+        }
+
+    }
+
+    public TextureType c() {
+        return TextureType.CUTOUT;
+    }
+
+    public static void a(World world, BlockPosition blockposition) {
+        //HttpUtilities.a.submit(() -> { // Paper
+            Chunk chunk = world.getChunkAtWorldCoords(blockposition);
+
+            for (int i = blockposition.getY() - 1; i >= 0; --i) {
+                BlockPosition blockposition1 = new BlockPosition(blockposition.getX(), i, blockposition.getZ());
+
+                if (!chunk.c(blockposition1)) {
+                    break;
+                }
+
+                IBlockData iblockdata = world.getType(blockposition1);
+
+                if (iblockdata.getBlock() == Blocks.BEACON) {
+                    ((WorldServer) world).postToMainThread(() -> {
+                        TileEntity tileentity = world.getTileEntity(blockposition1);
+
+                        if (tileentity instanceof TileEntityBeacon) {
+                            ((TileEntityBeacon) tileentity).p();
+                            world.playBlockAction(blockposition1, Blocks.BEACON, 1, 0);
+                        }
+
+                    });
+                }
+            }
+     //   }); // Paper
+    }
+}

src/main/java/net/minecraft/server/BlockBed.java

@@ -0,0 +1,310 @@
+package net.minecraft.server;
+
+import java.util.Iterator;
+import javax.annotation.Nullable;
+
+public class BlockBed extends BlockFacingHorizontal implements ITileEntity {
+
+    public static final BlockStateEnum<BlockPropertyBedPart> PART = BlockProperties.ao;
+    public static final BlockStateBoolean OCCUPIED = BlockProperties.q;
+    protected static final VoxelShape c = Block.a(0.0D, 0.0D, 0.0D, 16.0D, 9.0D, 16.0D);
+    private final EnumColor color;
+
+    public BlockBed(EnumColor enumcolor, Block.Info block_info) {
+        super(block_info);
+        this.color = enumcolor;
+        this.v((IBlockData) ((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockBed.PART, BlockPropertyBedPart.FOOT)).set(BlockBed.OCCUPIED, false));
+    }
+
+    public MaterialMapColor c(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return iblockdata.get(BlockBed.PART) == BlockPropertyBedPart.FOOT ? this.color.e() : MaterialMapColor.e;
+    }
+
+    public boolean interact(IBlockData iblockdata, World world, BlockPosition blockposition, EntityHuman entityhuman, EnumHand enumhand, EnumDirection enumdirection, float f, float f1, float f2) {
+        if (world.isClientSide) {
+            return true;
+        } else {
+            if (iblockdata.get(BlockBed.PART) != BlockPropertyBedPart.HEAD) {
+                blockposition = blockposition.shift((EnumDirection) iblockdata.get(BlockBed.FACING));
+                iblockdata = world.getType(blockposition);
+                if (iblockdata.getBlock() != this) {
+                    return true;
+                }
+            }
+
+            // CraftBukkit - moved world and biome check into EntityHuman
+            if (true || world.worldProvider.canRespawn() && world.getBiome(blockposition) != Biomes.NETHER) {
+                if ((Boolean) iblockdata.get(BlockBed.OCCUPIED)) {
+                    EntityHuman entityhuman1 = this.a(world, blockposition);
+
+                    if (entityhuman1 != null) {
+                        entityhuman.a((IChatBaseComponent) (new ChatMessage("block.minecraft.bed.occupied", new Object[0])), true);
+                        return true;
+                    }
+
+                    iblockdata = (IBlockData) iblockdata.set(BlockBed.OCCUPIED, false);
+                    world.setTypeAndData(blockposition, iblockdata, 4);
+                }
+
+                EntityHuman.EnumBedResult entityhuman_enumbedresult = entityhuman.a(blockposition);
+
+                if (entityhuman_enumbedresult == EntityHuman.EnumBedResult.OK) {
+                    iblockdata = (IBlockData) iblockdata.set(BlockBed.OCCUPIED, true);
+                    world.setTypeAndData(blockposition, iblockdata, 4);
+                    return true;
+                } else {
+                    if (entityhuman_enumbedresult == EntityHuman.EnumBedResult.NOT_POSSIBLE_NOW) {
+                        entityhuman.a((IChatBaseComponent) (new ChatMessage("block.minecraft.bed.no_sleep", new Object[0])), true);
+                    } else if (entityhuman_enumbedresult == EntityHuman.EnumBedResult.NOT_SAFE) {
+                        entityhuman.a((IChatBaseComponent) (new ChatMessage("block.minecraft.bed.not_safe", new Object[0])), true);
+                    } else if (entityhuman_enumbedresult == EntityHuman.EnumBedResult.TOO_FAR_AWAY) {
+                        entityhuman.a((IChatBaseComponent) (new ChatMessage("block.minecraft.bed.too_far_away", new Object[0])), true);
+                    }
+                    // CraftBukkit start - handling bed explosion from below here
+                    else if (entityhuman_enumbedresult == EntityHuman.EnumBedResult.NOT_POSSIBLE_HERE) {
+                        this.explodeBed(iblockdata, world, blockposition);
+                    }
+                    // CraftBukkit end
+
+                    return true;
+                }
+                // CraftBukkit start - moved bed explosion into separate method
+            } else {
+                return true;
+            }
+        }
+    }
+
+    private boolean explodeBed(IBlockData iblockdata, World world, BlockPosition blockposition) {
+                world.setAir(blockposition);
+                BlockPosition blockposition1 = blockposition.shift(((EnumDirection) iblockdata.get(BlockBed.FACING)).opposite());
+
+                if (world.getType(blockposition1).getBlock() == this) {
+                    world.setAir(blockposition1);
+                }
+
+                world.createExplosion((Entity) null, DamageSource.a(), (double) blockposition.getX() + 0.5D, (double) blockposition.getY() + 0.5D, (double) blockposition.getZ() + 0.5D, 5.0F, true, true);
+                return true;
+                // CraftBukkit end
+    }
+
+    @Nullable
+    private EntityHuman a(World world, BlockPosition blockposition) {
+        Iterator iterator = world.players.iterator();
+
+        EntityHuman entityhuman;
+
+        do {
+            if (!iterator.hasNext()) {
+                return null;
+            }
+
+            entityhuman = (EntityHuman) iterator.next();
+        } while (!entityhuman.isSleeping() || !entityhuman.bedPosition.equals(blockposition));
+
+        return entityhuman;
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public void fallOn(World world, BlockPosition blockposition, Entity entity, float f) {
+        super.fallOn(world, blockposition, entity, f * 0.5F);
+    }
+
+    public void a(IBlockAccess iblockaccess, Entity entity) {
+        if (entity.isSneaking()) {
+            super.a(iblockaccess, entity);
+        } else if (entity.motY < 0.0D) {
+            entity.motY = -entity.motY * 0.6600000262260437D;
+            if (!(entity instanceof EntityLiving)) {
+                entity.motY *= 0.8D;
+            }
+        }
+
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        return enumdirection == a((BlockPropertyBedPart) iblockdata.get(BlockBed.PART), (EnumDirection) iblockdata.get(BlockBed.FACING)) ? (iblockdata1.getBlock() == this && iblockdata1.get(BlockBed.PART) != iblockdata.get(BlockBed.PART) ? (IBlockData) iblockdata.set(BlockBed.OCCUPIED, iblockdata1.get(BlockBed.OCCUPIED)) : Blocks.AIR.getBlockData()) : super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
+    }
+
+    private static EnumDirection a(BlockPropertyBedPart blockpropertybedpart, EnumDirection enumdirection) {
+        return blockpropertybedpart == BlockPropertyBedPart.FOOT ? enumdirection : enumdirection.opposite();
+    }
+
+    public void a(World world, EntityHuman entityhuman, BlockPosition blockposition, IBlockData iblockdata, @Nullable TileEntity tileentity, ItemStack itemstack) {
+        super.a(world, entityhuman, blockposition, Blocks.AIR.getBlockData(), tileentity, itemstack);
+    }
+
+    public void remove(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1, boolean flag) {
+        if (iblockdata.getBlock() != iblockdata1.getBlock()) {
+            super.remove(iblockdata, world, blockposition, iblockdata1, flag);
+            world.n(blockposition);
+        }
+    }
+
+    public void a(World world, BlockPosition blockposition, IBlockData iblockdata, EntityHuman entityhuman) {
+        BlockPropertyBedPart blockpropertybedpart = (BlockPropertyBedPart) iblockdata.get(BlockBed.PART);
+        boolean flag = blockpropertybedpart == BlockPropertyBedPart.HEAD;
+        BlockPosition blockposition1 = blockposition.shift(a(blockpropertybedpart, (EnumDirection) iblockdata.get(BlockBed.FACING)));
+        IBlockData iblockdata1 = world.getType(blockposition1);
+
+        if (iblockdata1.getBlock() == this && iblockdata1.get(BlockBed.PART) != blockpropertybedpart) {
+            world.setTypeAndData(blockposition1, Blocks.AIR.getBlockData(), 35);
+            world.a(entityhuman, 2001, blockposition1, Block.getCombinedId(iblockdata1));
+            if (!world.isClientSide && !entityhuman.u()) {
+                if (flag) {
+                    iblockdata.a(world, blockposition, 0);
+                } else {
+                    iblockdata1.a(world, blockposition1, 0);
+                }
+            }
+
+            entityhuman.b(StatisticList.BLOCK_MINED.b(this));
+        }
+
+        super.a(world, blockposition, iblockdata, entityhuman);
+    }
+
+    @Nullable
+    public IBlockData getPlacedState(BlockActionContext blockactioncontext) {
+        EnumDirection enumdirection = blockactioncontext.f();
+        BlockPosition blockposition = blockactioncontext.getClickPosition();
+        BlockPosition blockposition1 = blockposition.shift(enumdirection);
+
+        return blockactioncontext.getWorld().getType(blockposition1).a(blockactioncontext) ? (IBlockData) this.getBlockData().set(BlockBed.FACING, enumdirection) : null;
+    }
+
+    public IMaterial getDropType(IBlockData iblockdata, World world, BlockPosition blockposition, int i) {
+        return (IMaterial) (iblockdata.get(BlockBed.PART) == BlockPropertyBedPart.FOOT ? Items.AIR : super.getDropType(iblockdata, world, blockposition, i));
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return BlockBed.c;
+    }
+
+    @Nullable
+    public static BlockPosition a(IBlockAccess iblockaccess, BlockPosition blockposition, int i) {
+        EnumDirection enumdirection = (EnumDirection) iblockaccess.getType(blockposition).get(BlockBed.FACING);
+        // Paper - replace whole method
+        World world = (World) iblockaccess;
+        int radius = world.paperConfig.bedSearchRadius;
+        for (int r = 1; r <= radius; r++) {
+            int x = -r;
+            int z = r;
+
+            // Iterates the edge of half of the box; then negates for other half.
+            while (x <= r && z > -r) {
+                for (int y = -1; y <= 1; y++) {
+                    BlockPosition pos = blockposition.add(x, y, z);
+                    if (isSafeRespawn(world, pos)) {
+                        if (i-- <= 0) {
+                            return pos;
+                        }
+                    }
+                    pos = blockposition.add(-x, y, -z);
+                    if (isSafeRespawn(world, pos)) {
+                        if (i-- <= 0) {
+                            return pos;
+                        }
+                    }
+
+                    pos = blockposition.add(enumdirection.getAdjacentX() + x, y, enumdirection.getAdjacentZ() + z);
+                    if (isSafeRespawn(world, pos)) {
+                        if (i-- <= 0) {
+                            return pos;
+                        }
+                    }
+
+                    pos = blockposition.add(enumdirection.getAdjacentX() - x, y, enumdirection.getAdjacentZ() - z);
+                    if (isSafeRespawn(world, pos)) {
+                        if (i-- <= 0) {
+                            return pos;
+                        }
+                    }
+                }
+                if (x < r) {
+                    x++;
+                } else {
+                    z--;
+                }
+            }
+        }
+
+        return null; /* // Paper comment out
+        int j = blockposition.getX();
+        int k = blockposition.getY();
+        int l = blockposition.getZ();
+
+        for (int i1 = 0; i1 <= 1; ++i1) {
+            int j1 = j - enumdirection.getAdjacentX() * i1 - 1;
+            int k1 = l - enumdirection.getAdjacentZ() * i1 - 1;
+            int l1 = j1 + 2;
+            int i2 = k1 + 2;
+
+            for (int j2 = j1; j2 <= l1; ++j2) {
+                for (int k2 = k1; k2 <= i2; ++k2) {
+                    BlockPosition blockposition1 = new BlockPosition(j2, k, k2);
+
+                    if (a(iblockaccess, blockposition1)) {
+                        if (i <= 0) {
+                            return blockposition1;
+                        }
+
+                        --i;
+                    }
+                }
+            }
+        }
+
+        return null;*/ // Paper
+    }
+
+    protected static boolean isSafeRespawn(IBlockAccess iblockaccess, BlockPosition blockposition) { // Paper - OBFHELPER + behavior improvement
+        return a(iblockaccess, blockposition) && iblockaccess.getType(blockposition.down()).getMaterial().isBuildable(); // Paper - ensure solid block
+    }
+    protected static boolean a(IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return iblockaccess.getType(blockposition.down()).q() && !iblockaccess.getType(blockposition).getMaterial().isBuildable() && !iblockaccess.getType(blockposition.up()).getMaterial().isBuildable();
+    }
+
+    public EnumPistonReaction getPushReaction(IBlockData iblockdata) {
+        return EnumPistonReaction.DESTROY;
+    }
+
+    public TextureType c() {
+        return TextureType.CUTOUT;
+    }
+
+    public EnumRenderType c(IBlockData iblockdata) {
+        return EnumRenderType.ENTITYBLOCK_ANIMATED;
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return EnumBlockFaceShape.UNDEFINED;
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockBed.FACING, BlockBed.PART, BlockBed.OCCUPIED);
+    }
+
+    public TileEntity a(IBlockAccess iblockaccess) {
+        return new TileEntityBed(this.color);
+    }
+
+    public void postPlace(World world, BlockPosition blockposition, IBlockData iblockdata, @Nullable EntityLiving entityliving, ItemStack itemstack) {
+        super.postPlace(world, blockposition, iblockdata, entityliving, itemstack);
+        if (!world.isClientSide) {
+            BlockPosition blockposition1 = blockposition.shift((EnumDirection) iblockdata.get(BlockBed.FACING));
+
+            world.setTypeAndData(blockposition1, (IBlockData) iblockdata.set(BlockBed.PART, BlockPropertyBedPart.HEAD), 3);
+            world.update(blockposition, Blocks.AIR);
+            iblockdata.a((GeneratorAccess) world, blockposition, 3);
+        }
+
+    }
+
+    public boolean a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, PathMode pathmode) {
+        return false;
+    }
+}

src/main/java/net/minecraft/server/BlockButtonAbstract.java

@@ -0,0 +1,224 @@
+package net.minecraft.server;
+
+import java.util.List;
+import java.util.Random;
+import javax.annotation.Nullable;
+
+// CraftBukkit start
+import org.bukkit.event.block.BlockRedstoneEvent;
+import org.bukkit.event.entity.EntityInteractEvent;
+// CraftBukkit end
+
+public abstract class BlockButtonAbstract extends BlockAttachable {
+
+    public static final BlockStateBoolean POWERED = BlockProperties.t;
+    protected static final VoxelShape b = Block.a(6.0D, 14.0D, 5.0D, 10.0D, 16.0D, 11.0D);
+    protected static final VoxelShape c = Block.a(5.0D, 14.0D, 6.0D, 11.0D, 16.0D, 10.0D);
+    protected static final VoxelShape o = Block.a(6.0D, 0.0D, 5.0D, 10.0D, 2.0D, 11.0D);
+    protected static final VoxelShape p = Block.a(5.0D, 0.0D, 6.0D, 11.0D, 2.0D, 10.0D);
+    protected static final VoxelShape q = Block.a(5.0D, 6.0D, 14.0D, 11.0D, 10.0D, 16.0D);
+    protected static final VoxelShape r = Block.a(5.0D, 6.0D, 0.0D, 11.0D, 10.0D, 2.0D);
+    protected static final VoxelShape s = Block.a(14.0D, 6.0D, 5.0D, 16.0D, 10.0D, 11.0D);
+    protected static final VoxelShape t = Block.a(0.0D, 6.0D, 5.0D, 2.0D, 10.0D, 11.0D);
+    protected static final VoxelShape u = Block.a(6.0D, 15.0D, 5.0D, 10.0D, 16.0D, 11.0D);
+    protected static final VoxelShape v = Block.a(5.0D, 15.0D, 6.0D, 11.0D, 16.0D, 10.0D);
+    protected static final VoxelShape w = Block.a(6.0D, 0.0D, 5.0D, 10.0D, 1.0D, 11.0D);
+    protected static final VoxelShape x = Block.a(5.0D, 0.0D, 6.0D, 11.0D, 1.0D, 10.0D);
+    protected static final VoxelShape y = Block.a(5.0D, 6.0D, 15.0D, 11.0D, 10.0D, 16.0D);
+    protected static final VoxelShape z = Block.a(5.0D, 6.0D, 0.0D, 11.0D, 10.0D, 1.0D);
+    protected static final VoxelShape A = Block.a(15.0D, 6.0D, 5.0D, 16.0D, 10.0D, 11.0D);
+    protected static final VoxelShape B = Block.a(0.0D, 6.0D, 5.0D, 1.0D, 10.0D, 11.0D);
+    private final boolean E;
+
+    protected BlockButtonAbstract(boolean flag, Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockButtonAbstract.FACING, EnumDirection.NORTH)).set(BlockButtonAbstract.POWERED, false)).set(BlockButtonAbstract.FACE, BlockPropertyAttachPosition.WALL));
+        this.E = flag;
+    }
+
+    public int a(IWorldReader iworldreader) {
+        return this.E ? 30 : 20;
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        EnumDirection enumdirection = (EnumDirection) iblockdata.get(BlockButtonAbstract.FACING);
+        boolean flag = (Boolean) iblockdata.get(BlockButtonAbstract.POWERED);
+
+        switch ((BlockPropertyAttachPosition) iblockdata.get(BlockButtonAbstract.FACE)) {
+        case FLOOR:
+            if (enumdirection.k() == EnumDirection.EnumAxis.X) {
+                return flag ? BlockButtonAbstract.w : BlockButtonAbstract.o;
+            }
+
+            return flag ? BlockButtonAbstract.x : BlockButtonAbstract.p;
+        case WALL:
+            switch (enumdirection) {
+            case EAST:
+                return flag ? BlockButtonAbstract.B : BlockButtonAbstract.t;
+            case WEST:
+                return flag ? BlockButtonAbstract.A : BlockButtonAbstract.s;
+            case SOUTH:
+                return flag ? BlockButtonAbstract.z : BlockButtonAbstract.r;
+            case NORTH:
+            default:
+                return flag ? BlockButtonAbstract.y : BlockButtonAbstract.q;
+            }
+        case CEILING:
+        default:
+            return enumdirection.k() == EnumDirection.EnumAxis.X ? (flag ? BlockButtonAbstract.u : BlockButtonAbstract.b) : (flag ? BlockButtonAbstract.v : BlockButtonAbstract.c);
+        }
+    }
+
+    public boolean interact(IBlockData iblockdata, World world, BlockPosition blockposition, EntityHuman entityhuman, EnumHand enumhand, EnumDirection enumdirection, float f, float f1, float f2) {
+        if ((Boolean) iblockdata.get(BlockButtonAbstract.POWERED)) {
+            return true;
+        } else {
+            // CraftBukkit start
+            boolean powered = ((Boolean) iblockdata.get(POWERED));
+            org.bukkit.block.Block block = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
+            int old = (powered) ? 15 : 0;
+            int current = (!powered) ? 15 : 0;
+
+            BlockRedstoneEvent eventRedstone = new BlockRedstoneEvent(block, old, current);
+            world.getServer().getPluginManager().callEvent(eventRedstone);
+
+            if ((eventRedstone.getNewCurrent() > 0) != (!powered)) {
+                return true;
+            }
+            // CraftBukkit end
+            world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockButtonAbstract.POWERED, true), 3);
+            this.a(entityhuman, world, blockposition, true);
+            this.c(iblockdata, world, blockposition);
+            world.getBlockTickList().a(blockposition, this, this.a((IWorldReader) world));
+            return true;
+        }
+    }
+
+    protected void a(@Nullable EntityHuman entityhuman, GeneratorAccess generatoraccess, BlockPosition blockposition, boolean flag) {
+        generatoraccess.a(flag ? entityhuman : null, blockposition, this.a(flag), SoundCategory.BLOCKS, 0.3F, flag ? 0.6F : 0.5F);
+    }
+
+    protected abstract SoundEffect a(boolean flag);
+
+    public void remove(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1, boolean flag) {
+        if (!flag && iblockdata.getBlock() != iblockdata1.getBlock()) {
+            if ((Boolean) iblockdata.get(BlockButtonAbstract.POWERED)) {
+                this.c(iblockdata, world, blockposition);
+            }
+
+            super.remove(iblockdata, world, blockposition, iblockdata1, flag);
+        }
+    }
+
+    public int a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, EnumDirection enumdirection) {
+        return (Boolean) iblockdata.get(BlockButtonAbstract.POWERED) ? 15 : 0;
+    }
+
+    public int b(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, EnumDirection enumdirection) {
+        return (Boolean) iblockdata.get(BlockButtonAbstract.POWERED) && k(iblockdata) == enumdirection ? 15 : 0;
+    }
+
+    public boolean isPowerSource(IBlockData iblockdata) {
+        return true;
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if (!world.isClientSide && (Boolean) iblockdata.get(BlockButtonAbstract.POWERED)) {
+            if (this.E) {
+                this.b(iblockdata, world, blockposition);
+            } else {
+                // CraftBukkit start
+                org.bukkit.block.Block block = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
+
+                BlockRedstoneEvent eventRedstone = new BlockRedstoneEvent(block, 15, 0);
+                world.getServer().getPluginManager().callEvent(eventRedstone);
+
+                if (eventRedstone.getNewCurrent() > 0) {
+                    return;
+                }
+                // CraftBukkit end
+                world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockButtonAbstract.POWERED, false), 3);
+                this.c(iblockdata, world, blockposition);
+                this.a((EntityHuman) null, world, blockposition, false);
+            }
+
+        }
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
+        if (!world.isClientSide && this.E && !(Boolean) iblockdata.get(BlockButtonAbstract.POWERED)) {
+            this.b(iblockdata, world, blockposition);
+        }
+    }
+
+    private void b(IBlockData iblockdata, World world, BlockPosition blockposition) {
+        List<? extends Entity> list = world.a(EntityArrow.class, iblockdata.getShape(world, blockposition).getBoundingBox().a(blockposition));
+        boolean flag = !list.isEmpty();
+        boolean flag1 = (Boolean) iblockdata.get(BlockButtonAbstract.POWERED);
+
+        // CraftBukkit start - Call interact event when arrows turn on wooden buttons
+        if (flag1 != flag && flag) {
+            org.bukkit.block.Block block = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
+            boolean allowed = false;
+
+            // If all of the events are cancelled block the button press, else allow
+            for (Object object : list) {
+                if (object != null) {
+                    EntityInteractEvent event = new EntityInteractEvent(((Entity) object).getBukkitEntity(), block);
+                    world.getServer().getPluginManager().callEvent(event);
+
+                    if (!event.isCancelled()) {
+                        allowed = true;
+                        break;
+                    }
+                }
+            }
+
+            if (!allowed) {
+                return;
+            }
+        }
+        // CraftBukkit end
+
+        if (flag != flag1) {
+            // CraftBukkit start
+            boolean powered = flag1;
+            org.bukkit.block.Block block = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
+            int old = (powered) ? 15 : 0;
+            int current = (!powered) ? 15 : 0;
+
+            BlockRedstoneEvent eventRedstone = new BlockRedstoneEvent(block, old, current);
+            world.getServer().getPluginManager().callEvent(eventRedstone);
+
+            if ((flag && eventRedstone.getNewCurrent() <= 0) || (!flag && eventRedstone.getNewCurrent() > 0)) {
+                return;
+            }
+            // CraftBukkit end
+            world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockButtonAbstract.POWERED, flag), 3);
+            this.c(iblockdata, world, blockposition);
+            this.a((EntityHuman) null, world, blockposition, flag);
+        }
+
+        if (flag) {
+            world.getBlockTickList().a(new BlockPosition(blockposition), this, this.a((IWorldReader) world));
+        }
+
+    }
+
+    private void c(IBlockData iblockdata, World world, BlockPosition blockposition) {
+        world.applyPhysics(blockposition, this);
+        world.applyPhysics(blockposition.shift(k(iblockdata).opposite()), this);
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockButtonAbstract.FACING, BlockButtonAbstract.POWERED, BlockButtonAbstract.FACE);
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return EnumBlockFaceShape.UNDEFINED;
+    }
+}

src/main/java/net/minecraft/server/BlockCactus.java

@@ -0,0 +1,117 @@
+package net.minecraft.server;
+
+import java.util.Iterator;
+import java.util.Random;
+
+import org.bukkit.craftbukkit.event.CraftEventFactory; // CraftBukkit
+
+public class BlockCactus extends Block {
+
+    public static final BlockStateInteger AGE = BlockProperties.X;
+    protected static final VoxelShape b = Block.a(1.0D, 0.0D, 1.0D, 15.0D, 15.0D, 15.0D);
+    protected static final VoxelShape c = Block.a(1.0D, 0.0D, 1.0D, 15.0D, 16.0D, 15.0D);
+
+    protected BlockCactus(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockCactus.AGE, 0));
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if (!iblockdata.canPlace(world, blockposition)) {
+            world.setAir(blockposition, true);
+        } else {
+            BlockPosition blockposition1 = blockposition.up();
+
+            if (world.isEmpty(blockposition1)) {
+                int i;
+
+                for (i = 1; world.getType(blockposition.down(i)).getBlock() == this; ++i) {
+                    ;
+                }
+
+            if (i < world.paperConfig.cactusMaxHeight) { // Paper - Configurable growth height
+                    int j = (Integer) iblockdata.get(BlockCactus.AGE);
+
+                    if (j >= (byte) range(3, ((100.0F / world.spigotConfig.cactusModifier) * 15) + 0.5F, 15)) { // Spigot
+                        CraftEventFactory.handleBlockGrowEvent(world, blockposition1, this.getBlockData()); // CraftBukkit
+                        IBlockData iblockdata1 = (IBlockData) iblockdata.set(BlockCactus.AGE, 0);
+
+                        world.setTypeAndData(blockposition, iblockdata1, 4);
+                        iblockdata1.doPhysics(world, blockposition1, this, blockposition);
+                    } else {
+                        world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockCactus.AGE, j + 1), 4);
+                    }
+
+                }
+            }
+        }
+    }
+
+    public VoxelShape f(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return BlockCactus.b;
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return BlockCactus.c;
+    }
+
+    public boolean f(IBlockData iblockdata) {
+        return true;
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        if (!iblockdata.canPlace(generatoraccess, blockposition)) {
+            generatoraccess.getBlockTickList().a(blockposition, this, 1);
+        }
+
+        return super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
+    }
+
+    public boolean canPlace(IBlockData iblockdata, IWorldReader iworldreader, BlockPosition blockposition) {
+        Iterator iterator = EnumDirection.EnumDirectionLimit.HORIZONTAL.iterator();
+
+        EnumDirection enumdirection;
+        Material material;
+
+        do {
+            if (!iterator.hasNext()) {
+                Block block = iworldreader.getType(blockposition.down()).getBlock();
+
+                return (block == Blocks.CACTUS || block == Blocks.SAND || block == Blocks.RED_SAND) && !iworldreader.getType(blockposition.up()).getMaterial().isLiquid();
+            }
+
+            enumdirection = (EnumDirection) iterator.next();
+            IBlockData iblockdata1 = iworldreader.getType(blockposition.shift(enumdirection));
+
+            material = iblockdata1.getMaterial();
+        } while (!material.isBuildable() && !iworldreader.getFluid(blockposition.shift(enumdirection)).a(TagsFluid.LAVA));
+
+        return false;
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
+        CraftEventFactory.blockDamage = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ()); // CraftBukkit
+        entity.damageEntity(DamageSource.CACTUS, 1.0F);
+        CraftEventFactory.blockDamage = null; // CraftBukkit
+    }
+
+    public TextureType c() {
+        return TextureType.CUTOUT;
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockCactus.AGE);
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return EnumBlockFaceShape.UNDEFINED;
+    }
+
+    public boolean a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, PathMode pathmode) {
+        return false;
+    }
+}

src/main/java/net/minecraft/server/BlockCake.java

@@ -0,0 +1,91 @@
+package net.minecraft.server;
+
+public class BlockCake extends Block {
+
+    public static final BlockStateInteger BITES = BlockProperties.Z;
+    protected static final VoxelShape[] b = new VoxelShape[] { Block.a(1.0D, 0.0D, 1.0D, 15.0D, 8.0D, 15.0D), Block.a(3.0D, 0.0D, 1.0D, 15.0D, 8.0D, 15.0D), Block.a(5.0D, 0.0D, 1.0D, 15.0D, 8.0D, 15.0D), Block.a(7.0D, 0.0D, 1.0D, 15.0D, 8.0D, 15.0D), Block.a(9.0D, 0.0D, 1.0D, 15.0D, 8.0D, 15.0D), Block.a(11.0D, 0.0D, 1.0D, 15.0D, 8.0D, 15.0D), Block.a(13.0D, 0.0D, 1.0D, 15.0D, 8.0D, 15.0D)};
+
+    protected BlockCake(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockCake.BITES, 0));
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return BlockCake.b[(Integer) iblockdata.get(BlockCake.BITES)];
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public boolean interact(IBlockData iblockdata, World world, BlockPosition blockposition, EntityHuman entityhuman, EnumHand enumhand, EnumDirection enumdirection, float f, float f1, float f2) {
+        if (!world.isClientSide) {
+            return this.a((GeneratorAccess) world, blockposition, iblockdata, entityhuman);
+        } else {
+            ItemStack itemstack = entityhuman.b(enumhand);
+
+            return this.a((GeneratorAccess) world, blockposition, iblockdata, entityhuman) || itemstack.isEmpty();
+        }
+    }
+
+    private boolean a(GeneratorAccess generatoraccess, BlockPosition blockposition, IBlockData iblockdata, EntityHuman entityhuman) {
+        if (!entityhuman.q(false)) {
+            return false;
+        } else {
+            entityhuman.a(StatisticList.EAT_CAKE_SLICE);
+            // CraftBukkit start
+            // entityhuman.getFoodData().eat(2, 0.1F);
+            int oldFoodLevel = entityhuman.getFoodData().foodLevel;
+
+            org.bukkit.event.entity.FoodLevelChangeEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callFoodLevelChangeEvent(entityhuman, 2 + oldFoodLevel);
+
+            if (!event.isCancelled()) {
+                entityhuman.getFoodData().eat(event.getFoodLevel() - oldFoodLevel, 0.1F);
+            }
+
+            ((EntityPlayer) entityhuman).getBukkitEntity().sendHealthUpdate();
+            // CraftBukkit end
+            int i = (Integer) iblockdata.get(BlockCake.BITES);
+
+            if (i < 6) {
+                generatoraccess.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockCake.BITES, i + 1), 3);
+            } else {
+                generatoraccess.setAir(blockposition);
+            }
+
+            return true;
+        }
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        return enumdirection == EnumDirection.DOWN && !iblockdata.canPlace(generatoraccess, blockposition) ? Blocks.AIR.getBlockData() : super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
+    }
+
+    public boolean canPlace(IBlockData iblockdata, IWorldReader iworldreader, BlockPosition blockposition) {
+        return iworldreader.getType(blockposition.down()).getMaterial().isBuildable();
+    }
+
+    public IMaterial getDropType(IBlockData iblockdata, World world, BlockPosition blockposition, int i) {
+        return Items.AIR;
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockCake.BITES);
+    }
+
+    public int a(IBlockData iblockdata, World world, BlockPosition blockposition) {
+        return (7 - (Integer) iblockdata.get(BlockCake.BITES)) * 2;
+    }
+
+    public boolean isComplexRedstone(IBlockData iblockdata) {
+        return true;
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return EnumBlockFaceShape.UNDEFINED;
+    }
+
+    public boolean a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, PathMode pathmode) {
+        return false;
+    }
+}

src/main/java/net/minecraft/server/BlockCauldron.java

@@ -0,0 +1,267 @@
+package net.minecraft.server;
+
+import org.bukkit.event.block.CauldronLevelChangeEvent; // CraftBukkit
+
+public class BlockCauldron extends Block {
+
+    public static final BlockStateInteger LEVEL = BlockProperties.af;
+    protected static final VoxelShape b = Block.a(2.0D, 4.0D, 2.0D, 14.0D, 16.0D, 14.0D);
+    protected static final VoxelShape c = VoxelShapes.a(VoxelShapes.b(), BlockCauldron.b, OperatorBoolean.ONLY_FIRST);
+
+    public BlockCauldron(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockCauldron.LEVEL, 0));
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return BlockCauldron.c;
+    }
+
+    public boolean f(IBlockData iblockdata) {
+        return false;
+    }
+
+    public VoxelShape h(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return BlockCauldron.b;
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
+        int i = (Integer) iblockdata.get(BlockCauldron.LEVEL);
+        float f = (float) blockposition.getY() + (6.0F + (float) (3 * i)) / 16.0F;
+
+        if (!world.isClientSide && entity.isBurning() && i > 0 && entity.getBoundingBox().minY <= (double) f) {
+            // CraftBukkit start
+            if (!this.changeLevel(world, blockposition, iblockdata, i - 1, entity, CauldronLevelChangeEvent.ChangeReason.EXTINGUISH)) {
+                return;
+            }
+            entity.extinguish();
+            // this.a(world, blockposition, iblockdata, i - 1);
+            // CraftBukkit end
+        }
+
+    }
+
+    public boolean interact(IBlockData iblockdata, World world, BlockPosition blockposition, EntityHuman entityhuman, EnumHand enumhand, EnumDirection enumdirection, float f, float f1, float f2) {
+        ItemStack itemstack = entityhuman.b(enumhand);
+
+        if (itemstack.isEmpty()) {
+            return true;
+        } else {
+            int i = (Integer) iblockdata.get(BlockCauldron.LEVEL);
+            Item item = itemstack.getItem();
+
+            if (item == Items.WATER_BUCKET) {
+                if (i < 3 && !world.isClientSide) {
+                    // CraftBukkit start
+                    if (!this.changeLevel(world, blockposition, iblockdata, 3, entityhuman, CauldronLevelChangeEvent.ChangeReason.BUCKET_EMPTY)) {
+                        return true;
+                    }
+                    if (!entityhuman.abilities.canInstantlyBuild) {
+                        entityhuman.a(enumhand, new ItemStack(Items.BUCKET));
+                    }
+
+                    entityhuman.a(StatisticList.FILL_CAULDRON);
+                    // this.a(world, blockposition, iblockdata, 3);
+                    // CraftBukkit end
+                    world.a((EntityHuman) null, blockposition, SoundEffects.ITEM_BUCKET_EMPTY, SoundCategory.BLOCKS, 1.0F, 1.0F);
+                }
+
+                return true;
+            } else if (item == Items.BUCKET) {
+                if (i == 3 && !world.isClientSide) {
+                    // CraftBukkit start
+                    if (!this.changeLevel(world, blockposition, iblockdata, 0, entityhuman, CauldronLevelChangeEvent.ChangeReason.BUCKET_FILL)) {
+                        return true;
+                    }
+                    if (!entityhuman.abilities.canInstantlyBuild) {
+                        itemstack.subtract(1);
+                        if (itemstack.isEmpty()) {
+                            entityhuman.a(enumhand, new ItemStack(Items.WATER_BUCKET));
+                        } else if (!entityhuman.inventory.pickup(new ItemStack(Items.WATER_BUCKET))) {
+                            entityhuman.drop(new ItemStack(Items.WATER_BUCKET), false);
+                        }
+                    }
+
+                    entityhuman.a(StatisticList.USE_CAULDRON);
+                    // this.a(world, blockposition, iblockdata, 0);
+                    // CraftBukkit end
+                    world.a((EntityHuman) null, blockposition, SoundEffects.ITEM_BUCKET_FILL, SoundCategory.BLOCKS, 1.0F, 1.0F);
+                }
+
+                return true;
+            } else {
+                ItemStack itemstack1;
+
+                if (item == Items.GLASS_BOTTLE) {
+                    if (i > 0 && !world.isClientSide) {
+                        // CraftBukkit start
+                        if (!this.changeLevel(world, blockposition, iblockdata, i - 1, entityhuman, CauldronLevelChangeEvent.ChangeReason.BOTTLE_FILL)) {
+                            return true;
+                        }
+                        if (!entityhuman.abilities.canInstantlyBuild) {
+                            itemstack1 = PotionUtil.a(new ItemStack(Items.POTION), Potions.b);
+                            entityhuman.a(StatisticList.USE_CAULDRON);
+                            itemstack.subtract(1);
+                            if (itemstack.isEmpty()) {
+                                entityhuman.a(enumhand, itemstack1);
+                            } else if (!entityhuman.inventory.pickup(itemstack1)) {
+                                entityhuman.drop(itemstack1, false);
+                            } else if (entityhuman instanceof EntityPlayer) {
+                                ((EntityPlayer) entityhuman).updateInventory(entityhuman.defaultContainer);
+                            }
+                        }
+
+                        world.a((EntityHuman) null, blockposition, SoundEffects.ITEM_BOTTLE_FILL, SoundCategory.BLOCKS, 1.0F, 1.0F);
+                        // this.a(world, blockposition, iblockdata, i - 1);
+                        // CraftBukkit end
+                    }
+
+                    return true;
+                } else if (item == Items.POTION && PotionUtil.d(itemstack) == Potions.b) {
+                    if (i < 3 && !world.isClientSide) {
+                        // CraftBukkit start
+                        if (!this.changeLevel(world, blockposition, iblockdata, i + 1, entityhuman, CauldronLevelChangeEvent.ChangeReason.BOTTLE_EMPTY)) {
+                            return true;
+                        }
+                        if (!entityhuman.abilities.canInstantlyBuild) {
+                            itemstack1 = new ItemStack(Items.GLASS_BOTTLE);
+                            entityhuman.a(StatisticList.USE_CAULDRON);
+                            entityhuman.a(enumhand, itemstack1);
+                            if (entityhuman instanceof EntityPlayer) {
+                                ((EntityPlayer) entityhuman).updateInventory(entityhuman.defaultContainer);
+                            }
+                        }
+
+                        world.a((EntityHuman) null, blockposition, SoundEffects.ITEM_BOTTLE_EMPTY, SoundCategory.BLOCKS, 1.0F, 1.0F);
+                        // this.a(world, blockposition, iblockdata, i + 1);
+                        // CraftBukkit end
+                    }
+
+                    return true;
+                } else {
+                    if (i > 0 && item instanceof ItemArmorColorable) {
+                        ItemArmorColorable itemarmorcolorable = (ItemArmorColorable) item;
+
+                        if (itemarmorcolorable.e(itemstack) && !world.isClientSide) {
+                            // CraftBukkit start
+                            if (!this.changeLevel(world, blockposition, iblockdata, i - 1, entityhuman, CauldronLevelChangeEvent.ChangeReason.ARMOR_WASH)) {
+                                return true;
+                            }
+                            itemarmorcolorable.g(itemstack);
+                            // this.a(world, blockposition, iblockdata, i - 1);
+                            // CraftBukkit end
+                            entityhuman.a(StatisticList.CLEAN_ARMOR);
+                            return true;
+                        }
+                    }
+
+                    if (i > 0 && item instanceof ItemBanner) {
+                        if (TileEntityBanner.a(itemstack) > 0 && !world.isClientSide) {
+                            // CraftBukkit start
+                            if (!this.changeLevel(world, blockposition, iblockdata, i - 1, entityhuman, CauldronLevelChangeEvent.ChangeReason.BANNER_WASH)) {
+                                return true;
+                            }
+                            itemstack1 = itemstack.cloneItemStack();
+                            itemstack1.setCount(1);
+                            TileEntityBanner.b(itemstack1);
+                            entityhuman.a(StatisticList.CLEAN_BANNER);
+                            if (!entityhuman.abilities.canInstantlyBuild) {
+                                itemstack.subtract(1);
+                                // this.a(world, blockposition, iblockdata, i - 1);
+                                // CraftBukkit end
+                            }
+
+                            if (itemstack.isEmpty()) {
+                                entityhuman.a(enumhand, itemstack1);
+                            } else if (!entityhuman.inventory.pickup(itemstack1)) {
+                                entityhuman.drop(itemstack1, false);
+                            } else if (entityhuman instanceof EntityPlayer) {
+                                ((EntityPlayer) entityhuman).updateInventory(entityhuman.defaultContainer);
+                            }
+                        }
+
+                        return true;
+                    } else if (i > 0 && item instanceof ItemBlock) {
+                        Block block = ((ItemBlock) item).getBlock();
+
+                        if (block instanceof BlockShulkerBox && !world.e()) {
+                            ItemStack itemstack2 = new ItemStack(Blocks.SHULKER_BOX, 1);
+
+                            if (itemstack.hasTag()) {
+                                itemstack2.setTag(itemstack.getTag().clone());
+                            }
+
+                            entityhuman.a(enumhand, itemstack2);
+                            this.a(world, blockposition, iblockdata, i - 1);
+                            entityhuman.a(StatisticList.CLEAN_SHULKER_BOX);
+                        }
+
+                        return true;
+                    } else {
+                        return false;
+                    }
+                }
+            }
+        }
+    }
+
+    // CraftBukkit start
+    public void a(World world, BlockPosition blockposition, IBlockData iblockdata, int i) {
+        this.changeLevel(world, blockposition, iblockdata, i, null, CauldronLevelChangeEvent.ChangeReason.UNKNOWN);
+    }
+
+    private boolean changeLevel(World world, BlockPosition blockposition, IBlockData iblockdata, int i, Entity entity, CauldronLevelChangeEvent.ChangeReason reason) {
+        int newLevel = Integer.valueOf(MathHelper.clamp(i, 0, 3));
+        CauldronLevelChangeEvent event = new CauldronLevelChangeEvent(
+                world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ()),
+                (entity == null) ? null : entity.getBukkitEntity(), reason, iblockdata.get(BlockCauldron.LEVEL), newLevel
+        );
+        world.getServer().getPluginManager().callEvent(event);
+        if (event.isCancelled()) {
+            return false;
+        }
+        world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockCauldron.LEVEL, event.getNewLevel()), 2);
+        world.updateAdjacentComparators(blockposition, this);
+        return true;
+        // CraftBukkit end
+    }
+
+    public void c(World world, BlockPosition blockposition) {
+        if (world.random.nextInt(20) == 1) {
+            float f = world.getBiome(blockposition).getAdjustedTemperature(blockposition);
+
+            if (f >= 0.15F) {
+                IBlockData iblockdata = world.getType(blockposition);
+
+                if ((Integer) iblockdata.get(BlockCauldron.LEVEL) < 3) {
+                    this.a(world, blockposition, (IBlockData) iblockdata.a((IBlockState) BlockCauldron.LEVEL), 2); // CraftBukkit
+                }
+
+            }
+        }
+    }
+
+    public boolean isComplexRedstone(IBlockData iblockdata) {
+        return true;
+    }
+
+    public int a(IBlockData iblockdata, World world, BlockPosition blockposition) {
+        return (Integer) iblockdata.get(BlockCauldron.LEVEL);
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockCauldron.LEVEL);
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return enumdirection == EnumDirection.UP ? EnumBlockFaceShape.BOWL : (enumdirection == EnumDirection.DOWN ? EnumBlockFaceShape.UNDEFINED : EnumBlockFaceShape.SOLID);
+    }
+
+    public boolean a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, PathMode pathmode) {
+        return false;
+    }
+}

src/main/java/net/minecraft/server/BlockChest.java

@@ -0,0 +1,289 @@
+package net.minecraft.server;
+
+import java.util.Iterator;
+import java.util.List;
+import javax.annotation.Nullable;
+
+public class BlockChest extends BlockTileEntity implements IFluidSource, IFluidContainer {
+
+    public static final BlockStateDirection FACING = BlockFacingHorizontal.FACING;
+    public static final BlockStateEnum<BlockPropertyChestType> b = BlockProperties.ap;
+    public static final BlockStateBoolean c = BlockProperties.y;
+    protected static final VoxelShape o = Block.a(1.0D, 0.0D, 0.0D, 15.0D, 14.0D, 15.0D);
+    protected static final VoxelShape p = Block.a(1.0D, 0.0D, 1.0D, 15.0D, 14.0D, 16.0D);
+    protected static final VoxelShape q = Block.a(0.0D, 0.0D, 1.0D, 15.0D, 14.0D, 15.0D);
+    protected static final VoxelShape r = Block.a(1.0D, 0.0D, 1.0D, 16.0D, 14.0D, 15.0D);
+    protected static final VoxelShape s = Block.a(1.0D, 0.0D, 1.0D, 15.0D, 14.0D, 15.0D);
+
+    protected BlockChest(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockChest.FACING, EnumDirection.NORTH)).set(BlockChest.b, BlockPropertyChestType.SINGLE)).set(BlockChest.c, false));
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public EnumRenderType c(IBlockData iblockdata) {
+        return EnumRenderType.ENTITYBLOCK_ANIMATED;
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        if ((Boolean) iblockdata.get(BlockChest.c)) {
+            generatoraccess.getFluidTickList().a(blockposition, FluidTypes.WATER, FluidTypes.WATER.a((IWorldReader) generatoraccess));
+        }
+
+        if (iblockdata1.getBlock() == this && enumdirection.k().c()) {
+            BlockPropertyChestType blockpropertychesttype = (BlockPropertyChestType) iblockdata1.get(BlockChest.b);
+
+            if (iblockdata.get(BlockChest.b) == BlockPropertyChestType.SINGLE && blockpropertychesttype != BlockPropertyChestType.SINGLE && iblockdata.get(BlockChest.FACING) == iblockdata1.get(BlockChest.FACING) && k(iblockdata1) == enumdirection.opposite()) {
+                return (IBlockData) iblockdata.set(BlockChest.b, blockpropertychesttype.a());
+            }
+        } else if (k(iblockdata) == enumdirection) {
+            return (IBlockData) iblockdata.set(BlockChest.b, BlockPropertyChestType.SINGLE);
+        }
+
+        return super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        if (iblockdata.get(BlockChest.b) == BlockPropertyChestType.SINGLE) {
+            return BlockChest.s;
+        } else {
+            switch (k(iblockdata)) {
+            case NORTH:
+            default:
+                return BlockChest.o;
+            case SOUTH:
+                return BlockChest.p;
+            case WEST:
+                return BlockChest.q;
+            case EAST:
+                return BlockChest.r;
+            }
+        }
+    }
+
+    public static EnumDirection k(IBlockData iblockdata) {
+        EnumDirection enumdirection = (EnumDirection) iblockdata.get(BlockChest.FACING);
+
+        return iblockdata.get(BlockChest.b) == BlockPropertyChestType.LEFT ? enumdirection.e() : enumdirection.f();
+    }
+
+    public IBlockData getPlacedState(BlockActionContext blockactioncontext) {
+        BlockPropertyChestType blockpropertychesttype = BlockPropertyChestType.SINGLE;
+        EnumDirection enumdirection = blockactioncontext.f().opposite();
+        Fluid fluid = blockactioncontext.getWorld().getFluid(blockactioncontext.getClickPosition());
+        boolean flag = blockactioncontext.isSneaking();
+        EnumDirection enumdirection1 = blockactioncontext.getClickedFace();
+
+        if (enumdirection1.k().c() && flag) {
+            EnumDirection enumdirection2 = this.a(blockactioncontext, enumdirection1.opposite());
+
+            if (enumdirection2 != null && enumdirection2.k() != enumdirection1.k()) {
+                enumdirection = enumdirection2;
+                blockpropertychesttype = enumdirection2.f() == enumdirection1.opposite() ? BlockPropertyChestType.RIGHT : BlockPropertyChestType.LEFT;
+            }
+        }
+
+        if (blockpropertychesttype == BlockPropertyChestType.SINGLE && !flag) {
+            if (enumdirection == this.a(blockactioncontext, enumdirection.e())) {
+                blockpropertychesttype = BlockPropertyChestType.LEFT;
+            } else if (enumdirection == this.a(blockactioncontext, enumdirection.f())) {
+                blockpropertychesttype = BlockPropertyChestType.RIGHT;
+            }
+        }
+
+        return (IBlockData) ((IBlockData) ((IBlockData) this.getBlockData().set(BlockChest.FACING, enumdirection)).set(BlockChest.b, blockpropertychesttype)).set(BlockChest.c, fluid.c() == FluidTypes.WATER);
+    }
+
+    public FluidType removeFluid(GeneratorAccess generatoraccess, BlockPosition blockposition, IBlockData iblockdata) {
+        if ((Boolean) iblockdata.get(BlockChest.c)) {
+            generatoraccess.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockChest.c, false), 3);
+            return FluidTypes.WATER;
+        } else {
+            return FluidTypes.EMPTY;
+        }
+    }
+
+    public Fluid h(IBlockData iblockdata) {
+        return (Boolean) iblockdata.get(BlockChest.c) ? FluidTypes.WATER.a(false) : super.h(iblockdata);
+    }
+
+    public boolean canPlace(IBlockAccess iblockaccess, BlockPosition blockposition, IBlockData iblockdata, FluidType fluidtype) {
+        return !(Boolean) iblockdata.get(BlockChest.c) && fluidtype == FluidTypes.WATER;
+    }
+
+    public boolean place(GeneratorAccess generatoraccess, BlockPosition blockposition, IBlockData iblockdata, Fluid fluid) {
+        if (!(Boolean) iblockdata.get(BlockChest.c) && fluid.c() == FluidTypes.WATER) {
+            if (!generatoraccess.e()) {
+                generatoraccess.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockChest.c, true), 3);
+                generatoraccess.getFluidTickList().a(blockposition, FluidTypes.WATER, FluidTypes.WATER.a((IWorldReader) generatoraccess));
+            }
+
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    @Nullable
+    private EnumDirection a(BlockActionContext blockactioncontext, EnumDirection enumdirection) {
+        IBlockData iblockdata = blockactioncontext.getWorld().getType(blockactioncontext.getClickPosition().shift(enumdirection));
+
+        return iblockdata.getBlock() == this && iblockdata.get(BlockChest.b) == BlockPropertyChestType.SINGLE ? (EnumDirection) iblockdata.get(BlockChest.FACING) : null;
+    }
+
+    public void postPlace(World world, BlockPosition blockposition, IBlockData iblockdata, EntityLiving entityliving, ItemStack itemstack) {
+        if (itemstack.hasName()) {
+            TileEntity tileentity = world.getTileEntity(blockposition);
+
+            if (tileentity instanceof TileEntityChest) {
+                ((TileEntityChest) tileentity).setCustomName(itemstack.getName());
+            }
+        }
+
+    }
+
+    public void remove(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1, boolean flag) {
+        if (iblockdata.getBlock() != iblockdata1.getBlock()) {
+            TileEntity tileentity = world.getTileEntity(blockposition);
+
+            if (tileentity instanceof IInventory) {
+                InventoryUtils.dropInventory(world, blockposition, (IInventory) tileentity);
+                world.updateAdjacentComparators(blockposition, this);
+            }
+
+            super.remove(iblockdata, world, blockposition, iblockdata1, flag);
+        }
+    }
+
+    public boolean interact(IBlockData iblockdata, World world, BlockPosition blockposition, EntityHuman entityhuman, EnumHand enumhand, EnumDirection enumdirection, float f, float f1, float f2) {
+        if (world.isClientSide) {
+            return true;
+        } else {
+            ITileInventory itileinventory = this.getInventory(iblockdata, world, blockposition, false);
+
+            if (itileinventory != null) {
+                entityhuman.openContainer(itileinventory);
+                entityhuman.b(this.d());
+            }
+
+            return true;
+        }
+    }
+
+    protected Statistic<MinecraftKey> d() {
+        return StatisticList.CUSTOM.b(StatisticList.OPEN_CHEST);
+    }
+
+    @Nullable
+    public ITileInventory getInventory(IBlockData iblockdata, World world, BlockPosition blockposition, boolean flag) {
+        TileEntity tileentity = world.getTileEntity(blockposition);
+
+        if (!(tileentity instanceof TileEntityChest)) {
+            return null;
+        } else if (!flag && this.a(world, blockposition)) {
+            return null;
+        } else {
+            Object object = (TileEntityChest) tileentity;
+            BlockPropertyChestType blockpropertychesttype = (BlockPropertyChestType) iblockdata.get(BlockChest.b);
+
+            if (blockpropertychesttype == BlockPropertyChestType.SINGLE) {
+                return (ITileInventory) object;
+            } else {
+                BlockPosition blockposition1 = blockposition.shift(k(iblockdata));
+                // Paper start - don't load chunks if the other side of the chest is in unloaded chunk
+                final IBlockData iblockdata1 = world.getTypeIfLoaded(blockposition1); // Paper
+                if (iblockdata1 ==  null) {
+                    return null;
+                }
+                // Paper end
+
+                if (iblockdata1.getBlock() == this) {
+                    BlockPropertyChestType blockpropertychesttype1 = (BlockPropertyChestType) iblockdata1.get(BlockChest.b);
+
+                    if (blockpropertychesttype1 != BlockPropertyChestType.SINGLE && blockpropertychesttype != blockpropertychesttype1 && iblockdata1.get(BlockChest.FACING) == iblockdata.get(BlockChest.FACING)) {
+                        if (!flag && this.a(world, blockposition1)) {
+                            return null;
+                        }
+
+                        TileEntity tileentity1 = world.getTileEntity(blockposition1);
+
+                        if (tileentity1 instanceof TileEntityChest) {
+                            Object object1 = blockpropertychesttype == BlockPropertyChestType.RIGHT ? object : (ITileInventory) tileentity1;
+                            Object object2 = blockpropertychesttype == BlockPropertyChestType.RIGHT ? (ITileInventory) tileentity1 : object;
+
+                            object = new InventoryLargeChest(new ChatMessage("container.chestDouble", new Object[0]), (ITileInventory) object1, (ITileInventory) object2);
+                        }
+                    }
+                }
+
+                return (ITileInventory) object;
+            }
+        }
+    }
+
+    public TileEntity a(IBlockAccess iblockaccess) {
+        return new TileEntityChest();
+    }
+
+    private boolean a(World world, BlockPosition blockposition) {
+        return this.a((IBlockAccess) world, blockposition) || this.b(world, blockposition);
+    }
+
+    private boolean a(IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return iblockaccess.getType(blockposition.up()).isOccluding();
+    }
+
+    private boolean b(World world, BlockPosition blockposition) {
+        // Paper start - Option to disable chest cat detection
+        if (world.paperConfig.disableChestCatDetection) {
+            return false;
+        }
+        // Paper end
+        List<EntityOcelot> list = world.a(EntityOcelot.class, new AxisAlignedBB((double) blockposition.getX(), (double) (blockposition.getY() + 1), (double) blockposition.getZ(), (double) (blockposition.getX() + 1), (double) (blockposition.getY() + 2), (double) (blockposition.getZ() + 1)));
+
+        if (!list.isEmpty()) {
+            Iterator iterator = list.iterator();
+
+            while (iterator.hasNext()) {
+                EntityOcelot entityocelot = (EntityOcelot) iterator.next();
+
+                if (entityocelot.isSitting()) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    public boolean isComplexRedstone(IBlockData iblockdata) {
+        return true;
+    }
+
+    public int a(IBlockData iblockdata, World world, BlockPosition blockposition) {
+        return Container.b((IInventory) this.getInventory(iblockdata, world, blockposition, false));
+    }
+
+    public IBlockData a(IBlockData iblockdata, EnumBlockRotation enumblockrotation) {
+        return (IBlockData) iblockdata.set(BlockChest.FACING, enumblockrotation.a((EnumDirection) iblockdata.get(BlockChest.FACING)));
+    }
+
+    public IBlockData a(IBlockData iblockdata, EnumBlockMirror enumblockmirror) {
+        return iblockdata.a(enumblockmirror.a((EnumDirection) iblockdata.get(BlockChest.FACING)));
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockChest.FACING, BlockChest.b, BlockChest.c);
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return EnumBlockFaceShape.UNDEFINED;
+    }
+
+    public boolean a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, PathMode pathmode) {
+        return false;
+    }
+}

src/main/java/net/minecraft/server/BlockChorusFlower.java

@@ -0,0 +1,259 @@
+package net.minecraft.server;
+
+import java.util.Iterator;
+import java.util.Random;
+import javax.annotation.Nullable;
+
+import org.bukkit.craftbukkit.event.CraftEventFactory; // CraftBukkit
+
+public class BlockChorusFlower extends Block {
+
+    public static final BlockStateInteger AGE = BlockProperties.V;
+    private final BlockChorusFruit b;
+
+    protected BlockChorusFlower(BlockChorusFruit blockchorusfruit, Block.Info block_info) {
+        super(block_info);
+        this.b = blockchorusfruit;
+        this.v((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockChorusFlower.AGE, 0));
+    }
+
+    public IMaterial getDropType(IBlockData iblockdata, World world, BlockPosition blockposition, int i) {
+        return Items.AIR;
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if (!iblockdata.canPlace(world, blockposition)) {
+            world.setAir(blockposition, true);
+        } else {
+            BlockPosition blockposition1 = blockposition.up();
+
+            if (world.isEmpty(blockposition1) && blockposition1.getY() < 256) {
+                int i = (Integer) iblockdata.get(BlockChorusFlower.AGE);
+
+                if (i < 5) {
+                    boolean flag = false;
+                    boolean flag1 = false;
+                    IBlockData iblockdata1 = world.getType(blockposition.down());
+                    Block block = iblockdata1.getBlock();
+                    int j;
+
+                    if (block == Blocks.END_STONE) {
+                        flag = true;
+                    } else if (block == this.b) {
+                        j = 1;
+
+                        for (int k = 0; k < 4; ++k) {
+                            Block block1 = world.getType(blockposition.down(j + 1)).getBlock();
+
+                            if (block1 != this.b) {
+                                if (block1 == Blocks.END_STONE) {
+                                    flag1 = true;
+                                }
+                                break;
+                            }
+
+                            ++j;
+                        }
+
+                        if (j < 2 || j <= random.nextInt(flag1 ? 5 : 4)) {
+                            flag = true;
+                        }
+                    } else if (iblockdata1.isAir()) {
+                        flag = true;
+                    }
+
+                    if (flag && a((IWorldReader) world, blockposition1, (EnumDirection) null) && world.isEmpty(blockposition.up(2))) {
+                        // CraftBukkit start - add event
+                        if (CraftEventFactory.handleBlockSpreadEvent(world, blockposition, blockposition1, this.getBlockData().set(BlockChorusFlower.AGE, Integer.valueOf(i)), 2)) {
+                            world.setTypeAndData(blockposition, this.b.a((IBlockAccess) world, blockposition), 2);
+                            this.b(world, blockposition1, i);
+                        }
+                        // CraftBukkit end
+                    } else if (i < 4) {
+                        j = random.nextInt(4);
+                        if (flag1) {
+                            ++j;
+                        }
+
+                        boolean flag2 = false;
+
+                        for (int l = 0; l < j; ++l) {
+                            EnumDirection enumdirection = EnumDirection.EnumDirectionLimit.HORIZONTAL.a(random);
+                            BlockPosition blockposition2 = blockposition.shift(enumdirection);
+
+                            if (world.isEmpty(blockposition2) && world.isEmpty(blockposition2.down()) && a((IWorldReader) world, blockposition2, enumdirection.opposite())) {
+                                // CraftBukkit start - add event
+                                if (CraftEventFactory.handleBlockSpreadEvent(world, blockposition, blockposition2, this.getBlockData().set(BlockChorusFlower.AGE, Integer.valueOf(i + 1)), 2)) {
+                                    this.b(world, blockposition2, i + 1);
+                                    flag2 = true;
+                                }
+                                // CraftBukkit end
+                            }
+                        }
+
+                        if (flag2) {
+                            world.setTypeAndData(blockposition, this.b.a((IBlockAccess) world, blockposition), 2);
+                        } else {
+                            // CraftBukkit - add event
+                            if (CraftEventFactory.handleBlockGrowEvent(world, blockposition, this.getBlockData().set(BlockChorusFlower.AGE, Integer.valueOf(5)), 2)) {
+                                this.a(world, blockposition);
+                            }
+                            // CraftBukkit end
+                        }
+                    } else {
+                        // CraftBukkit - add event
+                        if (CraftEventFactory.handleBlockGrowEvent(world, blockposition, this.getBlockData().set(BlockChorusFlower.AGE, Integer.valueOf(5)), 2)) {
+                            this.a(world, blockposition);
+                        }
+                        // CraftBukkit end
+                    }
+
+                }
+            }
+        }
+    }
+
+    private void b(World world, BlockPosition blockposition, int i) {
+        world.setTypeAndData(blockposition, (IBlockData) this.getBlockData().set(BlockChorusFlower.AGE, i), 2);
+        world.triggerEffect(1033, blockposition, 0);
+    }
+
+    private void a(World world, BlockPosition blockposition) {
+        world.setTypeAndData(blockposition, (IBlockData) this.getBlockData().set(BlockChorusFlower.AGE, 5), 2);
+        world.triggerEffect(1034, blockposition, 0);
+    }
+
+    private static boolean a(IWorldReader iworldreader, BlockPosition blockposition, @Nullable EnumDirection enumdirection) {
+        Iterator iterator = EnumDirection.EnumDirectionLimit.HORIZONTAL.iterator();
+
+        EnumDirection enumdirection1;
+
+        do {
+            if (!iterator.hasNext()) {
+                return true;
+            }
+
+            enumdirection1 = (EnumDirection) iterator.next();
+        } while (enumdirection1 == enumdirection || iworldreader.isEmpty(blockposition.shift(enumdirection1)));
+
+        return false;
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        if (enumdirection != EnumDirection.UP && !iblockdata.canPlace(generatoraccess, blockposition)) {
+            generatoraccess.getBlockTickList().a(blockposition, this, 1);
+        }
+
+        return super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
+    }
+
+    public boolean canPlace(IBlockData iblockdata, IWorldReader iworldreader, BlockPosition blockposition) {
+        IBlockData iblockdata1 = iworldreader.getType(blockposition.down());
+        Block block = iblockdata1.getBlock();
+
+        if (block != this.b && block != Blocks.END_STONE) {
+            if (!iblockdata1.isAir()) {
+                return false;
+            } else {
+                boolean flag = false;
+                Iterator iterator = EnumDirection.EnumDirectionLimit.HORIZONTAL.iterator();
+
+                while (iterator.hasNext()) {
+                    EnumDirection enumdirection = (EnumDirection) iterator.next();
+                    IBlockData iblockdata2 = iworldreader.getType(blockposition.shift(enumdirection));
+
+                    if (iblockdata2.getBlock() == this.b) {
+                        if (flag) {
+                            return false;
+                        }
+
+                        flag = true;
+                    } else if (!iblockdata2.isAir()) {
+                        return false;
+                    }
+                }
+
+                return flag;
+            }
+        } else {
+            return true;
+        }
+    }
+
+    public void a(World world, EntityHuman entityhuman, BlockPosition blockposition, IBlockData iblockdata, @Nullable TileEntity tileentity, ItemStack itemstack) {
+        super.a(world, entityhuman, blockposition, iblockdata, tileentity, itemstack);
+        a(world, blockposition, new ItemStack(this));
+    }
+
+    protected ItemStack t(IBlockData iblockdata) {
+        return ItemStack.a;
+    }
+
+    public TextureType c() {
+        return TextureType.CUTOUT;
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockChorusFlower.AGE);
+    }
+
+    public static void a(GeneratorAccess generatoraccess, BlockPosition blockposition, Random random, int i) {
+        generatoraccess.setTypeAndData(blockposition, ((BlockChorusFruit) Blocks.CHORUS_PLANT).a((IBlockAccess) generatoraccess, blockposition), 2);
+        a(generatoraccess, blockposition, random, blockposition, i, 0);
+    }
+
+    private static void a(GeneratorAccess generatoraccess, BlockPosition blockposition, Random random, BlockPosition blockposition1, int i, int j) {
+        BlockChorusFruit blockchorusfruit = (BlockChorusFruit) Blocks.CHORUS_PLANT;
+        int k = random.nextInt(4) + 1;
+
+        if (j == 0) {
+            ++k;
+        }
+
+        for (int l = 0; l < k; ++l) {
+            BlockPosition blockposition2 = blockposition.up(l + 1);
+
+            if (!a((IWorldReader) generatoraccess, blockposition2, (EnumDirection) null)) {
+                return;
+            }
+
+            generatoraccess.setTypeAndData(blockposition2, blockchorusfruit.a((IBlockAccess) generatoraccess, blockposition2), 2);
+            generatoraccess.setTypeAndData(blockposition2.down(), blockchorusfruit.a((IBlockAccess) generatoraccess, blockposition2.down()), 2);
+        }
+
+        boolean flag = false;
+
+        if (j < 4) {
+            int i1 = random.nextInt(4);
+
+            if (j == 0) {
+                ++i1;
+            }
+
+            for (int j1 = 0; j1 < i1; ++j1) {
+                EnumDirection enumdirection = EnumDirection.EnumDirectionLimit.HORIZONTAL.a(random);
+                BlockPosition blockposition3 = blockposition.up(k).shift(enumdirection);
+
+                if (Math.abs(blockposition3.getX() - blockposition1.getX()) < i && Math.abs(blockposition3.getZ() - blockposition1.getZ()) < i && generatoraccess.isEmpty(blockposition3) && generatoraccess.isEmpty(blockposition3.down()) && a((IWorldReader) generatoraccess, blockposition3, enumdirection.opposite())) {
+                    flag = true;
+                    generatoraccess.setTypeAndData(blockposition3, blockchorusfruit.a((IBlockAccess) generatoraccess, blockposition3), 2);
+                    generatoraccess.setTypeAndData(blockposition3.shift(enumdirection.opposite()), blockchorusfruit.a((IBlockAccess) generatoraccess, blockposition3.shift(enumdirection.opposite())), 2);
+                    a(generatoraccess, blockposition3, random, blockposition1, i, j + 1);
+                }
+            }
+        }
+
+        if (!flag) {
+            generatoraccess.setTypeAndData(blockposition.up(k), (IBlockData) Blocks.CHORUS_FLOWER.getBlockData().set(BlockChorusFlower.AGE, 5), 2);
+        }
+
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return EnumBlockFaceShape.UNDEFINED;
+    }
+}

src/main/java/net/minecraft/server/BlockCocoa.java

@@ -0,0 +1,125 @@
+package net.minecraft.server;
+
+import java.util.Random;
+import javax.annotation.Nullable;
+
+import org.bukkit.craftbukkit.event.CraftEventFactory; // CraftBukkit
+
+public class BlockCocoa extends BlockFacingHorizontal implements IBlockFragilePlantElement {
+
+    public static final BlockStateInteger AGE = BlockProperties.T;
+    protected static final VoxelShape[] b = new VoxelShape[] { Block.a(11.0D, 7.0D, 6.0D, 15.0D, 12.0D, 10.0D), Block.a(9.0D, 5.0D, 5.0D, 15.0D, 12.0D, 11.0D), Block.a(7.0D, 3.0D, 4.0D, 15.0D, 12.0D, 12.0D)};
+    protected static final VoxelShape[] c = new VoxelShape[] { Block.a(1.0D, 7.0D, 6.0D, 5.0D, 12.0D, 10.0D), Block.a(1.0D, 5.0D, 5.0D, 7.0D, 12.0D, 11.0D), Block.a(1.0D, 3.0D, 4.0D, 9.0D, 12.0D, 12.0D)};
+    protected static final VoxelShape[] o = new VoxelShape[] { Block.a(6.0D, 7.0D, 1.0D, 10.0D, 12.0D, 5.0D), Block.a(5.0D, 5.0D, 1.0D, 11.0D, 12.0D, 7.0D), Block.a(4.0D, 3.0D, 1.0D, 12.0D, 12.0D, 9.0D)};
+    protected static final VoxelShape[] p = new VoxelShape[] { Block.a(6.0D, 7.0D, 11.0D, 10.0D, 12.0D, 15.0D), Block.a(5.0D, 5.0D, 9.0D, 11.0D, 12.0D, 15.0D), Block.a(4.0D, 3.0D, 7.0D, 12.0D, 12.0D, 15.0D)};
+
+    public BlockCocoa(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockCocoa.FACING, EnumDirection.NORTH)).set(BlockCocoa.AGE, 0));
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if (world.random.nextInt(Math.max(1, (int) (100.0F / world.spigotConfig.cocoaModifier) * 5)) == 0) { // Spigot
+            int i = (Integer) iblockdata.get(BlockCocoa.AGE);
+
+            if (i < 2) {
+                CraftEventFactory.handleBlockGrowEvent(world, blockposition, (IBlockData) iblockdata.set(BlockCocoa.AGE, i + 1), 2); // CraftBukkkit
+            }
+        }
+
+    }
+
+    public boolean canPlace(IBlockData iblockdata, IWorldReader iworldreader, BlockPosition blockposition) {
+        Block block = iworldreader.getType(blockposition.shift((EnumDirection) iblockdata.get(BlockCocoa.FACING))).getBlock();
+
+        return block.a(TagsBlock.JUNGLE_LOGS);
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        int i = (Integer) iblockdata.get(BlockCocoa.AGE);
+
+        switch ((EnumDirection) iblockdata.get(BlockCocoa.FACING)) {
+        case SOUTH:
+            return BlockCocoa.p[i];
+        case NORTH:
+        default:
+            return BlockCocoa.o[i];
+        case WEST:
+            return BlockCocoa.c[i];
+        case EAST:
+            return BlockCocoa.b[i];
+        }
+    }
+
+    @Nullable
+    public IBlockData getPlacedState(BlockActionContext blockactioncontext) {
+        IBlockData iblockdata = this.getBlockData();
+        World world = blockactioncontext.getWorld();
+        BlockPosition blockposition = blockactioncontext.getClickPosition();
+        EnumDirection[] aenumdirection = blockactioncontext.e();
+        int i = aenumdirection.length;
+
+        for (int j = 0; j < i; ++j) {
+            EnumDirection enumdirection = aenumdirection[j];
+
+            if (enumdirection.k().c()) {
+                iblockdata = (IBlockData) iblockdata.set(BlockCocoa.FACING, enumdirection);
+                if (iblockdata.canPlace(world, blockposition)) {
+                    return iblockdata;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        return enumdirection == iblockdata.get(BlockCocoa.FACING) && !iblockdata.canPlace(generatoraccess, blockposition) ? Blocks.AIR.getBlockData() : super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
+    }
+
+    public void dropNaturally(IBlockData iblockdata, World world, BlockPosition blockposition, float f, int i) {
+        int j = (Integer) iblockdata.get(BlockCocoa.AGE);
+        byte b0 = 1;
+
+        if (j >= 2) {
+            b0 = 3;
+        }
+
+        for (int k = 0; k < b0; ++k) {
+            a(world, blockposition, new ItemStack(Items.COCOA_BEANS));
+        }
+
+    }
+
+    public ItemStack a(IBlockAccess iblockaccess, BlockPosition blockposition, IBlockData iblockdata) {
+        return new ItemStack(Items.COCOA_BEANS);
+    }
+
+    public boolean a(IBlockAccess iblockaccess, BlockPosition blockposition, IBlockData iblockdata, boolean flag) {
+        return (Integer) iblockdata.get(BlockCocoa.AGE) < 2;
+    }
+
+    public boolean a(World world, Random random, BlockPosition blockposition, IBlockData iblockdata) {
+        return true;
+    }
+
+    public void b(World world, Random random, BlockPosition blockposition, IBlockData iblockdata) {
+        CraftEventFactory.handleBlockGrowEvent(world, blockposition, (IBlockData) iblockdata.set(BlockCocoa.AGE, (Integer) iblockdata.get(BlockCocoa.AGE) + 1), 2); // CraftBukkit
+    }
+
+    public TextureType c() {
+        return TextureType.CUTOUT;
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockCocoa.FACING, BlockCocoa.AGE);
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return EnumBlockFaceShape.UNDEFINED;
+    }
+}

src/main/java/net/minecraft/server/BlockCommand.java

@@ -0,0 +1,229 @@
+package net.minecraft.server;
+
+import java.util.Random;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import org.bukkit.event.block.BlockRedstoneEvent; // CraftBukkit
+
+public class BlockCommand extends BlockTileEntity {
+
+    private static final Logger c = LogManager.getLogger();
+    public static final BlockStateDirection a = BlockDirectional.FACING;
+    public static final BlockStateBoolean b = BlockProperties.b;
+
+    public BlockCommand(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockCommand.a, EnumDirection.NORTH)).set(BlockCommand.b, false));
+    }
+
+    public TileEntity a(IBlockAccess iblockaccess) {
+        TileEntityCommand tileentitycommand = new TileEntityCommand();
+
+        tileentitycommand.b(this == Blocks.CHAIN_COMMAND_BLOCK);
+        return tileentitycommand;
+    }
+
+    public void doPhysics(IBlockData iblockdata, World world, BlockPosition blockposition, Block block, BlockPosition blockposition1) {
+        if (!world.isClientSide) {
+            TileEntity tileentity = world.getTileEntity(blockposition);
+
+            if (tileentity instanceof TileEntityCommand) {
+                TileEntityCommand tileentitycommand = (TileEntityCommand) tileentity;
+                boolean flag = world.isBlockIndirectlyPowered(blockposition);
+                boolean flag1 = tileentitycommand.d();
+                // CraftBukkit start
+                org.bukkit.block.Block bukkitBlock = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
+                int old = flag1 ? 15 : 0;
+                int current = flag ? 15 : 0;
+
+                BlockRedstoneEvent eventRedstone = new BlockRedstoneEvent(bukkitBlock, old, current);
+                world.getServer().getPluginManager().callEvent(eventRedstone);
+                flag = eventRedstone.getNewCurrent() > 0;
+                // CraftBukkit end
+
+                tileentitycommand.a(flag);
+                if (!flag1 && !tileentitycommand.e() && tileentitycommand.j() != TileEntityCommand.Type.SEQUENCE) {
+                    if (flag) {
+                        tileentitycommand.h();
+                        world.getBlockTickList().a(blockposition, this, this.a((IWorldReader) world));
+                    }
+
+                }
+            }
+        }
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if (!world.isClientSide) {
+            TileEntity tileentity = world.getTileEntity(blockposition);
+
+            if (tileentity instanceof TileEntityCommand) {
+                TileEntityCommand tileentitycommand = (TileEntityCommand) tileentity;
+                CommandBlockListenerAbstract commandblocklistenerabstract = tileentitycommand.getCommandBlock();
+                boolean flag = !UtilColor.b(commandblocklistenerabstract.getCommand());
+                TileEntityCommand.Type tileentitycommand_type = tileentitycommand.j();
+                boolean flag1 = tileentitycommand.f();
+
+                if (tileentitycommand_type == TileEntityCommand.Type.AUTO) {
+                    tileentitycommand.h();
+                    if (flag1) {
+                        this.a(iblockdata, world, blockposition, commandblocklistenerabstract, flag);
+                    } else if (tileentitycommand.k()) {
+                        commandblocklistenerabstract.a(0);
+                    }
+
+                    if (tileentitycommand.d() || tileentitycommand.e()) {
+                        world.getBlockTickList().a(blockposition, this, this.a((IWorldReader) world));
+                    }
+                } else if (tileentitycommand_type == TileEntityCommand.Type.REDSTONE) {
+                    if (flag1) {
+                        this.a(iblockdata, world, blockposition, commandblocklistenerabstract, flag);
+                    } else if (tileentitycommand.k()) {
+                        commandblocklistenerabstract.a(0);
+                    }
+                }
+
+                world.updateAdjacentComparators(blockposition, this);
+            }
+
+        }
+    }
+
+    private void a(IBlockData iblockdata, World world, BlockPosition blockposition, CommandBlockListenerAbstract commandblocklistenerabstract, boolean flag) {
+        if (flag) {
+            commandblocklistenerabstract.a(world);
+        } else {
+            commandblocklistenerabstract.a(0);
+        }
+
+        a(world, blockposition, (EnumDirection) iblockdata.get(BlockCommand.a));
+    }
+
+    public int a(IWorldReader iworldreader) {
+        return 1;
+    }
+
+    public boolean interact(IBlockData iblockdata, World world, BlockPosition blockposition, EntityHuman entityhuman, EnumHand enumhand, EnumDirection enumdirection, float f, float f1, float f2) {
+        TileEntity tileentity = world.getTileEntity(blockposition);
+
+        if (tileentity instanceof TileEntityCommand && entityhuman.isCreativeAndOp()) {
+            entityhuman.a((TileEntityCommand) tileentity);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public boolean isComplexRedstone(IBlockData iblockdata) {
+        return true;
+    }
+
+    public int a(IBlockData iblockdata, World world, BlockPosition blockposition) {
+        TileEntity tileentity = world.getTileEntity(blockposition);
+
+        return tileentity instanceof TileEntityCommand ? ((TileEntityCommand) tileentity).getCommandBlock().i() : 0;
+    }
+
+    public void postPlace(World world, BlockPosition blockposition, IBlockData iblockdata, EntityLiving entityliving, ItemStack itemstack) {
+        TileEntity tileentity = world.getTileEntity(blockposition);
+
+        if (tileentity instanceof TileEntityCommand) {
+            TileEntityCommand tileentitycommand = (TileEntityCommand) tileentity;
+            CommandBlockListenerAbstract commandblocklistenerabstract = tileentitycommand.getCommandBlock();
+
+            if (itemstack.hasName()) {
+                commandblocklistenerabstract.setName(itemstack.getName());
+            }
+
+            if (!world.isClientSide) {
+                if (itemstack.b("BlockEntityTag") == null) {
+                    commandblocklistenerabstract.a(world.getGameRules().getBoolean("sendCommandFeedback"));
+                    tileentitycommand.b(this == Blocks.CHAIN_COMMAND_BLOCK);
+                }
+
+                if (tileentitycommand.j() == TileEntityCommand.Type.SEQUENCE) {
+                    boolean flag = world.isBlockIndirectlyPowered(blockposition);
+
+                    tileentitycommand.a(flag);
+                }
+            }
+
+        }
+    }
+
+    public int a(IBlockData iblockdata, Random random) {
+        return 0;
+    }
+
+    public EnumRenderType c(IBlockData iblockdata) {
+        return EnumRenderType.MODEL;
+    }
+
+    public IBlockData a(IBlockData iblockdata, EnumBlockRotation enumblockrotation) {
+        return (IBlockData) iblockdata.set(BlockCommand.a, enumblockrotation.a((EnumDirection) iblockdata.get(BlockCommand.a)));
+    }
+
+    public IBlockData a(IBlockData iblockdata, EnumBlockMirror enumblockmirror) {
+        return iblockdata.a(enumblockmirror.a((EnumDirection) iblockdata.get(BlockCommand.a)));
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockCommand.a, BlockCommand.b);
+    }
+
+    public IBlockData getPlacedState(BlockActionContext blockactioncontext) {
+        return (IBlockData) this.getBlockData().set(BlockCommand.a, blockactioncontext.d().opposite());
+    }
+
+    private static void a(World world, BlockPosition blockposition, EnumDirection enumdirection) {
+        BlockPosition.MutableBlockPosition blockposition_mutableblockposition = new BlockPosition.MutableBlockPosition(blockposition);
+        GameRules gamerules = world.getGameRules();
+
+        IBlockData iblockdata;
+        int i;
+
+        for (i = gamerules.c("maxCommandChainLength"); i-- > 0; enumdirection = (EnumDirection) iblockdata.get(BlockCommand.a)) {
+            blockposition_mutableblockposition.c(enumdirection);
+            iblockdata = world.getType(blockposition_mutableblockposition);
+            Block block = iblockdata.getBlock();
+
+            if (block != Blocks.CHAIN_COMMAND_BLOCK) {
+                break;
+            }
+
+            TileEntity tileentity = world.getTileEntity(blockposition_mutableblockposition);
+
+            if (!(tileentity instanceof TileEntityCommand)) {
+                break;
+            }
+
+            TileEntityCommand tileentitycommand = (TileEntityCommand) tileentity;
+
+            if (tileentitycommand.j() != TileEntityCommand.Type.SEQUENCE) {
+                break;
+            }
+
+            if (tileentitycommand.d() || tileentitycommand.e()) {
+                CommandBlockListenerAbstract commandblocklistenerabstract = tileentitycommand.getCommandBlock();
+
+                if (tileentitycommand.h()) {
+                    if (!commandblocklistenerabstract.a(world)) {
+                        break;
+                    }
+
+                    world.updateAdjacentComparators(blockposition_mutableblockposition, block);
+                } else if (tileentitycommand.k()) {
+                    commandblocklistenerabstract.a(0);
+                }
+            }
+        }
+
+        if (i <= 0) {
+            int j = Math.max(gamerules.c("maxCommandChainLength"), 0);
+
+            BlockCommand.c.warn("Command Block chain tried to execute more than {} steps!", j);
+        }
+
+    }
+}

src/main/java/net/minecraft/server/BlockConcretePowder.java

@@ -0,0 +1,92 @@
+package net.minecraft.server;
+
+// CraftBukkit start
+import org.bukkit.craftbukkit.block.CraftBlockState;
+import org.bukkit.event.block.BlockFormEvent;
+// CraftBukkit end
+
+public class BlockConcretePowder extends BlockFalling {
+
+    private final IBlockData a;
+
+    public BlockConcretePowder(Block block, Block.Info block_info) {
+        super(block_info);
+        this.a = block.getBlockData();
+    }
+
+    public void a(World world, BlockPosition blockposition, IBlockData iblockdata, IBlockData iblockdata1) {
+        if (x(iblockdata1)) {
+            org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockFormEvent(world, blockposition, this.a, 3); // CraftBukkit
+        }
+
+    }
+
+    public IBlockData getPlacedState(BlockActionContext blockactioncontext) {
+        World world = blockactioncontext.getWorld();
+        BlockPosition blockposition = blockactioncontext.getClickPosition();
+
+        // CraftBukkit start
+        if (!x(world.getType(blockposition)) && !a((IBlockAccess) world, blockposition)) {
+            return super.getPlacedState(blockactioncontext);
+        }
+
+        // TODO: An event factory call for methods like this
+        CraftBlockState blockState = CraftBlockState.getBlockState(world, blockposition);
+        blockState.setData(this.a);
+
+        BlockFormEvent event = new BlockFormEvent(blockState.getBlock(), blockState);
+        world.getMinecraftServer().server.getPluginManager().callEvent(event);
+
+        if (!event.isCancelled()) {
+            return blockState.getHandle();
+        }
+
+        return super.getPlacedState(blockactioncontext);
+        // CraftBukkit end
+    }
+
+    private static boolean a(IBlockAccess iblockaccess, BlockPosition blockposition) {
+        boolean flag = false;
+        BlockPosition.MutableBlockPosition blockposition_mutableblockposition = new BlockPosition.MutableBlockPosition(blockposition);
+        EnumDirection[] aenumdirection = EnumDirection.values();
+        int i = aenumdirection.length;
+
+        for (int j = 0; j < i; ++j) {
+            EnumDirection enumdirection = aenumdirection[j];
+            IBlockData iblockdata = iblockaccess.getType(blockposition_mutableblockposition);
+
+            if (enumdirection != EnumDirection.DOWN || x(iblockdata)) {
+                blockposition_mutableblockposition.g(blockposition).c(enumdirection);
+                iblockdata = iblockaccess.getType(blockposition_mutableblockposition);
+                if (x(iblockdata) && !Block.a(iblockdata.getCollisionShape(iblockaccess, blockposition), enumdirection.opposite())) {
+                    flag = true;
+                    break;
+                }
+            }
+        }
+
+        return flag;
+    }
+
+    private static boolean x(IBlockData iblockdata) {
+        return iblockdata.s().a(TagsFluid.WATER);
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        // CraftBukkit start
+        if (a((IBlockAccess) generatoraccess, blockposition)) {
+            CraftBlockState blockState = CraftBlockState.getBlockState(generatoraccess, blockposition);
+            blockState.setData(this.a);
+
+            BlockFormEvent event = new BlockFormEvent(blockState.getBlock(), blockState);
+            generatoraccess.getMinecraftWorld().getMinecraftServer().server.getPluginManager().callEvent(event);
+
+            if (!event.isCancelled()) {
+                return blockState.getHandle();
+            }
+        }
+
+        return super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
+        // CraftBukkit end
+    }
+}

src/main/java/net/minecraft/server/BlockCoral.java

@@ -0,0 +1,67 @@
+package net.minecraft.server;
+
+import java.util.Random;
+import javax.annotation.Nullable;
+
+public class BlockCoral extends Block {
+
+    private final Block a;
+
+    public BlockCoral(Block block, Block.Info block_info) {
+        super(block_info);
+        this.a = block;
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if (!this.a((IBlockAccess) world, blockposition)) {
+            // CraftBukkit start
+            if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockFadeEvent(world, blockposition, this.a.getBlockData()).isCancelled()) {
+                return;
+            }
+            // CraftBukkit end
+            world.setTypeAndData(blockposition, this.a.getBlockData(), 2);
+        }
+
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        if (!this.a((IBlockAccess) generatoraccess, blockposition)) {
+            generatoraccess.getBlockTickList().a(blockposition, this, 60 + generatoraccess.m().nextInt(40));
+        }
+
+        return super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
+    }
+
+    protected boolean a(IBlockAccess iblockaccess, BlockPosition blockposition) {
+        EnumDirection[] aenumdirection = EnumDirection.values();
+        int i = aenumdirection.length;
+
+        for (int j = 0; j < i; ++j) {
+            EnumDirection enumdirection = aenumdirection[j];
+            Fluid fluid = iblockaccess.getFluid(blockposition.shift(enumdirection));
+
+            if (fluid.a(TagsFluid.WATER)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    @Nullable
+    public IBlockData getPlacedState(BlockActionContext blockactioncontext) {
+        if (!this.a((IBlockAccess) blockactioncontext.getWorld(), blockactioncontext.getClickPosition())) {
+            blockactioncontext.getWorld().getBlockTickList().a(blockactioncontext.getClickPosition(), this, 60 + blockactioncontext.getWorld().m().nextInt(40));
+        }
+
+        return this.getBlockData();
+    }
+
+    protected boolean X_() {
+        return true;
+    }
+
+    public IMaterial getDropType(IBlockData iblockdata, World world, BlockPosition blockposition, int i) {
+        return this.a;
+    }
+}

src/main/java/net/minecraft/server/BlockCoralFan.java

@@ -0,0 +1,42 @@
+package net.minecraft.server;
+
+import java.util.Random;
+
+public class BlockCoralFan extends BlockCoralFanAbstract {
+
+    private final Block a;
+
+    protected BlockCoralFan(Block block, Block.Info block_info) {
+        super(block_info);
+        this.a = block;
+    }
+
+    public void onPlace(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1) {
+        this.a(iblockdata, (GeneratorAccess) world, blockposition);
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if (!b_(iblockdata, world, blockposition)) {
+            // CraftBukkit start
+            if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockFadeEvent(world, blockposition, this.a.getBlockData().set(BlockCoralFan.b, false)).isCancelled()) {
+                return;
+            }
+            // CraftBukkit end
+            world.setTypeAndData(blockposition, (IBlockData) this.a.getBlockData().set(BlockCoralFan.b, false), 2);
+        }
+
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        if (enumdirection == EnumDirection.DOWN && !iblockdata.canPlace(generatoraccess, blockposition)) {
+            return Blocks.AIR.getBlockData();
+        } else {
+            this.a(iblockdata, generatoraccess, blockposition);
+            if ((Boolean) iblockdata.get(BlockCoralFan.b)) {
+                generatoraccess.getFluidTickList().a(blockposition, FluidTypes.WATER, FluidTypes.WATER.a((IWorldReader) generatoraccess));
+            }
+
+            return super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
+        }
+    }
+}

src/main/java/net/minecraft/server/BlockCoralFanWall.java

@@ -0,0 +1,42 @@
+package net.minecraft.server;
+
+import java.util.Random;
+
+public class BlockCoralFanWall extends BlockCoralFanWallAbstract {
+
+    private final Block c;
+
+    protected BlockCoralFanWall(Block block, Block.Info block_info) {
+        super(block_info);
+        this.c = block;
+    }
+
+    public void onPlace(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1) {
+        this.a(iblockdata, (GeneratorAccess) world, blockposition);
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if (!b_(iblockdata, world, blockposition)) {
+            // CraftBukkit start
+            if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockFadeEvent(world, blockposition, this.c.getBlockData().set(BlockCoralFanWall.b, false).set(BlockCoralFanWall.a, iblockdata.get(BlockCoralFanWall.a))).isCancelled()) {
+                return;
+            }
+            // CraftBukkit end
+            world.setTypeAndData(blockposition, (IBlockData) ((IBlockData) this.c.getBlockData().set(BlockCoralFanWall.b, false)).set(BlockCoralFanWall.a, iblockdata.get(BlockCoralFanWall.a)), 2);
+        }
+
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        if (enumdirection.opposite() == iblockdata.get(BlockCoralFanWall.a) && !iblockdata.canPlace(generatoraccess, blockposition)) {
+            return Blocks.AIR.getBlockData();
+        } else {
+            if ((Boolean) iblockdata.get(BlockCoralFanWall.b)) {
+                generatoraccess.getFluidTickList().a(blockposition, FluidTypes.WATER, FluidTypes.WATER.a((IWorldReader) generatoraccess));
+            }
+
+            this.a(iblockdata, generatoraccess, blockposition);
+            return super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
+        }
+    }
+}

src/main/java/net/minecraft/server/BlockCoralPlant.java

@@ -0,0 +1,47 @@
+package net.minecraft.server;
+
+import java.util.Random;
+
+public class BlockCoralPlant extends BlockCoralBase {
+
+    private final Block c;
+    protected static final VoxelShape a = Block.a(2.0D, 0.0D, 2.0D, 14.0D, 15.0D, 14.0D);
+
+    protected BlockCoralPlant(Block block, Block.Info block_info) {
+        super(block_info);
+        this.c = block;
+    }
+
+    public void onPlace(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1) {
+        this.a(iblockdata, (GeneratorAccess) world, blockposition);
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if (!b_(iblockdata, world, blockposition)) {
+            // CraftBukkit start
+            if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockFadeEvent(world, blockposition, this.c.getBlockData().set(BlockCoralPlant.b, false)).isCancelled()) {
+                return;
+            }
+            // CraftBukkit end
+            world.setTypeAndData(blockposition, (IBlockData) this.c.getBlockData().set(BlockCoralPlant.b, false), 2);
+        }
+
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        if (enumdirection == EnumDirection.DOWN && !iblockdata.canPlace(generatoraccess, blockposition)) {
+            return Blocks.AIR.getBlockData();
+        } else {
+            this.a(iblockdata, generatoraccess, blockposition);
+            if ((Boolean) iblockdata.get(BlockCoralPlant.b)) {
+                generatoraccess.getFluidTickList().a(blockposition, FluidTypes.WATER, FluidTypes.WATER.a((IWorldReader) generatoraccess));
+            }
+
+            return super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
+        }
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return BlockCoralPlant.a;
+    }
+}

src/main/java/net/minecraft/server/BlockCrops.java

@@ -0,0 +1,186 @@
+package net.minecraft.server;
+
+import java.util.Random;
+
+import org.bukkit.craftbukkit.event.CraftEventFactory; // CraftBukkit
+
+public class BlockCrops extends BlockPlant implements IBlockFragilePlantElement {
+
+    public static final BlockStateInteger AGE = BlockProperties.W;
+    private static final VoxelShape[] a = new VoxelShape[] { Block.a(0.0D, 0.0D, 0.0D, 16.0D, 2.0D, 16.0D), Block.a(0.0D, 0.0D, 0.0D, 16.0D, 4.0D, 16.0D), Block.a(0.0D, 0.0D, 0.0D, 16.0D, 6.0D, 16.0D), Block.a(0.0D, 0.0D, 0.0D, 16.0D, 8.0D, 16.0D), Block.a(0.0D, 0.0D, 0.0D, 16.0D, 10.0D, 16.0D), Block.a(0.0D, 0.0D, 0.0D, 16.0D, 12.0D, 16.0D), Block.a(0.0D, 0.0D, 0.0D, 16.0D, 14.0D, 16.0D), Block.a(0.0D, 0.0D, 0.0D, 16.0D, 16.0D, 16.0D)};
+
+    protected BlockCrops(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(this.d(), 0));
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return BlockCrops.a[(Integer) iblockdata.get(this.d())];
+    }
+
+    protected boolean b(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return iblockdata.getBlock() == Blocks.FARMLAND;
+    }
+
+    public BlockStateInteger d() {
+        return BlockCrops.AGE;
+    }
+
+    public int e() {
+        return 7;
+    }
+
+    protected int k(IBlockData iblockdata) {
+        return (Integer) iblockdata.get(this.d());
+    }
+
+    public IBlockData setAge(int i) {
+        return (IBlockData) this.getBlockData().set(this.d(), i);
+    }
+
+    public boolean w(IBlockData iblockdata) {
+        return (Integer) iblockdata.get(this.d()) >= this.e();
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        super.a(iblockdata, world, blockposition, random);
+        if (world.isLightLevel(blockposition.up(), 9)) { // Paper
+            int i = this.k(iblockdata);
+
+            if (i < this.e()) {
+                float f = a((Block) this, (IBlockAccess) world, blockposition);
+
+                // Spigot start
+                int modifier;
+                if (this == Blocks.BEETROOTS) {
+                    modifier = world.spigotConfig.beetrootModifier;
+                } else if (this == Blocks.CARROTS) {
+                    modifier = world.spigotConfig.carrotModifier;
+                } else if (this == Blocks.POTATOES) {
+                    modifier = world.spigotConfig.potatoModifier;
+                } else {
+                    modifier = world.spigotConfig.wheatModifier;
+                }
+
+                if (random.nextInt((int) ((100.0F / modifier) * (25.0F / f)) + 1) == 0) {
+                    // Spigot end
+                    CraftEventFactory.handleBlockGrowEvent(world, blockposition, this.setAge(i + 1), 2); // CraftBukkit
+                }
+            }
+        }
+
+    }
+
+    public void a(World world, BlockPosition blockposition, IBlockData iblockdata) {
+        int i = this.k(iblockdata) + this.a(world);
+        int j = this.e();
+
+        if (i > j) {
+            i = j;
+        }
+
+        CraftEventFactory.handleBlockGrowEvent(world, blockposition, this.setAge(i), 2); // CraftBukkit
+    }
+
+    protected int a(World world) {
+        return MathHelper.nextInt(world.random, 2, 5);
+    }
+
+    protected static float a(Block block, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        float f = 1.0F;
+        BlockPosition blockposition1 = blockposition.down();
+
+        for (int i = -1; i <= 1; ++i) {
+            for (int j = -1; j <= 1; ++j) {
+                float f1 = 0.0F;
+                IBlockData iblockdata = iblockaccess.getType(blockposition1.a(i, 0, j));
+
+                if (iblockdata.getBlock() == Blocks.FARMLAND) {
+                    f1 = 1.0F;
+                    if ((Integer) iblockdata.get(BlockSoil.MOISTURE) > 0) {
+                        f1 = 3.0F;
+                    }
+                }
+
+                if (i != 0 || j != 0) {
+                    f1 /= 4.0F;
+                }
+
+                f += f1;
+            }
+        }
+
+        BlockPosition blockposition2 = blockposition.north();
+        BlockPosition blockposition3 = blockposition.south();
+        BlockPosition blockposition4 = blockposition.west();
+        BlockPosition blockposition5 = blockposition.east();
+        boolean flag = block == iblockaccess.getType(blockposition4).getBlock() || block == iblockaccess.getType(blockposition5).getBlock();
+        boolean flag1 = block == iblockaccess.getType(blockposition2).getBlock() || block == iblockaccess.getType(blockposition3).getBlock();
+
+        if (flag && flag1) {
+            f /= 2.0F;
+        } else {
+            boolean flag2 = block == iblockaccess.getType(blockposition4.north()).getBlock() || block == iblockaccess.getType(blockposition5.north()).getBlock() || block == iblockaccess.getType(blockposition5.south()).getBlock() || block == iblockaccess.getType(blockposition4.south()).getBlock();
+
+            if (flag2) {
+                f /= 2.0F;
+            }
+        }
+
+        return f;
+    }
+
+    public boolean canPlace(IBlockData iblockdata, IWorldReader iworldreader, BlockPosition blockposition) {
+        return (iworldreader.getLightLevel(blockposition, 0) >= 8 || iworldreader.e(blockposition)) && super.canPlace(iblockdata, iworldreader, blockposition);
+    }
+
+    protected IMaterial f() {
+        return Items.WHEAT_SEEDS;
+    }
+
+    protected IMaterial g() {
+        return Items.WHEAT;
+    }
+
+    public void dropNaturally(IBlockData iblockdata, World world, BlockPosition blockposition, float f, int i) {
+        super.dropNaturally(iblockdata, world, blockposition, f, 0);
+        if (!world.isClientSide) {
+            int j = this.k(iblockdata);
+
+            if (j >= this.e()) {
+                int k = 3 + i;
+
+                for (int l = 0; l < k; ++l) {
+                    if (world.random.nextInt(2 * this.e()) <= j) {
+                        a(world, blockposition, new ItemStack(this.f()));
+                    }
+                }
+            }
+
+        }
+    }
+
+    public IMaterial getDropType(IBlockData iblockdata, World world, BlockPosition blockposition, int i) {
+        return this.w(iblockdata) ? this.g() : this.f();
+    }
+
+    public ItemStack a(IBlockAccess iblockaccess, BlockPosition blockposition, IBlockData iblockdata) {
+        return new ItemStack(this.f());
+    }
+
+    public boolean a(IBlockAccess iblockaccess, BlockPosition blockposition, IBlockData iblockdata, boolean flag) {
+        return !this.w(iblockdata);
+    }
+
+    public boolean a(World world, Random random, BlockPosition blockposition, IBlockData iblockdata) {
+        return true;
+    }
+
+    public void b(World world, Random random, BlockPosition blockposition, IBlockData iblockdata) {
+        this.a(world, blockposition, iblockdata);
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockCrops.AGE);
+    }
+}

src/main/java/net/minecraft/server/BlockData.java

@@ -0,0 +1,25 @@
+package net.minecraft.server;
+
+import com.google.common.collect.ImmutableMap;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+public class BlockData extends BlockDataAbstract<Block, IBlockData> implements IBlockData {
+
+    public BlockData(Block block, ImmutableMap<IBlockState<?>, Comparable<?>> immutablemap) {
+        super(block, immutablemap);
+    }
+
+    public Block getBlock() {
+        return (Block) this.e_;
+    }
+
+    // Paper start - impl cached craft block data, lazy load to fix issue with loading at the wrong time
+    private CraftBlockData cachedCraftBlockData;
+
+    @Override
+    public CraftBlockData createCraftBlockData() {
+        if(cachedCraftBlockData == null) cachedCraftBlockData = CraftBlockData.createData(this);
+        return (CraftBlockData) cachedCraftBlockData.clone();
+    }
+    // Paper end
+}

src/main/java/net/minecraft/server/BlockDaylightDetector.java

@@ -0,0 +1,85 @@
+package net.minecraft.server;
+
+public class BlockDaylightDetector extends BlockTileEntity {
+
+    public static final BlockStateInteger POWER = BlockProperties.al;
+    public static final BlockStateBoolean b = BlockProperties.m;
+    protected static final VoxelShape c = Block.a(0.0D, 0.0D, 0.0D, 16.0D, 6.0D, 16.0D);
+
+    public BlockDaylightDetector(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockDaylightDetector.POWER, 0)).set(BlockDaylightDetector.b, false));
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return BlockDaylightDetector.c;
+    }
+
+    public int a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, EnumDirection enumdirection) {
+        return (Integer) iblockdata.get(BlockDaylightDetector.POWER);
+    }
+
+    public static void b(IBlockData iblockdata, World world, BlockPosition blockposition) {
+        if (world.worldProvider.g()) {
+            int i = world.getBrightness(EnumSkyBlock.SKY, blockposition) - world.c();
+            float f = world.c(1.0F);
+            boolean flag = (Boolean) iblockdata.get(BlockDaylightDetector.b);
+
+            if (flag) {
+                i = 15 - i;
+            } else if (i > 0) {
+                float f1 = f < 3.1415927F ? 0.0F : 6.2831855F;
+
+                f += (f1 - f) * 0.2F;
+                i = Math.round((float) i * MathHelper.cos(f));
+            }
+
+            i = MathHelper.clamp(i, 0, 15);
+            if ((Integer) iblockdata.get(BlockDaylightDetector.POWER) != i) {
+                i = org.bukkit.craftbukkit.event.CraftEventFactory.callRedstoneChange(world, blockposition, ((Integer) iblockdata.get(POWER)), i).getNewCurrent(); // CraftBukkit - Call BlockRedstoneEvent
+                world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockDaylightDetector.POWER, i), 3);
+            }
+
+        }
+    }
+
+    public boolean interact(IBlockData iblockdata, World world, BlockPosition blockposition, EntityHuman entityhuman, EnumHand enumhand, EnumDirection enumdirection, float f, float f1, float f2) {
+        if (entityhuman.dy()) {
+            if (world.isClientSide) {
+                return true;
+            } else {
+                IBlockData iblockdata1 = (IBlockData) iblockdata.a((IBlockState) BlockDaylightDetector.b);
+
+                world.setTypeAndData(blockposition, iblockdata1, 4);
+                b(iblockdata1, world, blockposition);
+                return true;
+            }
+        } else {
+            return super.interact(iblockdata, world, blockposition, entityhuman, enumhand, enumdirection, f, f1, f2);
+        }
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public EnumRenderType c(IBlockData iblockdata) {
+        return EnumRenderType.MODEL;
+    }
+
+    public boolean isPowerSource(IBlockData iblockdata) {
+        return true;
+    }
+
+    public TileEntity a(IBlockAccess iblockaccess) {
+        return new TileEntityLightDetector();
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockDaylightDetector.POWER, BlockDaylightDetector.b);
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return enumdirection == EnumDirection.DOWN ? EnumBlockFaceShape.SOLID : EnumBlockFaceShape.UNDEFINED;
+    }
+}

src/main/java/net/minecraft/server/BlockDiodeAbstract.java

@@ -0,0 +1,207 @@
+package net.minecraft.server;
+
+import java.util.Random;
+
+import org.bukkit.craftbukkit.event.CraftEventFactory; // CraftBukkit
+
+public abstract class BlockDiodeAbstract extends BlockFacingHorizontal {
+
+    protected static final VoxelShape b = Block.a(0.0D, 0.0D, 0.0D, 16.0D, 2.0D, 16.0D);
+    public static final BlockStateBoolean c = BlockProperties.t;
+
+    protected BlockDiodeAbstract(Block.Info block_info) {
+        super(block_info);
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return BlockDiodeAbstract.b;
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public boolean canPlace(IBlockData iblockdata, IWorldReader iworldreader, BlockPosition blockposition) {
+        return iworldreader.getType(blockposition.down()).q();
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if (!this.a((IWorldReader) world, blockposition, iblockdata)) {
+            boolean flag = (Boolean) iblockdata.get(BlockDiodeAbstract.c);
+            boolean flag1 = this.a(world, blockposition, iblockdata);
+
+            if (flag && !flag1) {
+                // CraftBukkit start
+                if (CraftEventFactory.callRedstoneChange(world, blockposition, 15, 0).getNewCurrent() != 0) {
+                    return;
+                }
+                // CraftBukkit end
+                world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockDiodeAbstract.c, false), 2);
+            } else if (!flag) {
+                // CraftBukkit start
+                if (CraftEventFactory.callRedstoneChange(world, blockposition, 0, 15).getNewCurrent() != 15) {
+                    return;
+                }
+                // CraftBukkit end
+                world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockDiodeAbstract.c, true), 2);
+                if (!flag1) {
+                    world.getBlockTickList().a(blockposition, this, this.k(iblockdata), TickListPriority.HIGH);
+                }
+            }
+
+        }
+    }
+
+    public int b(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, EnumDirection enumdirection) {
+        return iblockdata.a(iblockaccess, blockposition, enumdirection);
+    }
+
+    public int a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, EnumDirection enumdirection) {
+        return !(Boolean) iblockdata.get(BlockDiodeAbstract.c) ? 0 : (iblockdata.get(BlockDiodeAbstract.FACING) == enumdirection ? this.b(iblockaccess, blockposition, iblockdata) : 0);
+    }
+
+    public void doPhysics(IBlockData iblockdata, World world, BlockPosition blockposition, Block block, BlockPosition blockposition1) {
+        if (iblockdata.canPlace(world, blockposition)) {
+            this.c(world, blockposition, iblockdata);
+        } else {
+            iblockdata.a(world, blockposition, 0);
+            world.setAir(blockposition);
+            EnumDirection[] aenumdirection = EnumDirection.values();
+            int i = aenumdirection.length;
+
+            for (int j = 0; j < i; ++j) {
+                EnumDirection enumdirection = aenumdirection[j];
+
+                world.applyPhysics(blockposition.shift(enumdirection), this);
+            }
+
+        }
+    }
+
+    protected void c(World world, BlockPosition blockposition, IBlockData iblockdata) {
+        if (!this.a((IWorldReader) world, blockposition, iblockdata)) {
+            boolean flag = (Boolean) iblockdata.get(BlockDiodeAbstract.c);
+            boolean flag1 = this.a(world, blockposition, iblockdata);
+
+            if (flag != flag1 && !world.getBlockTickList().b(blockposition, this)) {
+                TickListPriority ticklistpriority = TickListPriority.HIGH;
+
+                if (this.c((IBlockAccess) world, blockposition, iblockdata)) {
+                    ticklistpriority = TickListPriority.EXTREMELY_HIGH;
+                } else if (flag) {
+                    ticklistpriority = TickListPriority.VERY_HIGH;
+                }
+
+                world.getBlockTickList().a(blockposition, this, this.k(iblockdata), ticklistpriority);
+            }
+
+        }
+    }
+
+    public boolean a(IWorldReader iworldreader, BlockPosition blockposition, IBlockData iblockdata) {
+        return false;
+    }
+
+    protected boolean a(World world, BlockPosition blockposition, IBlockData iblockdata) {
+        return this.b(world, blockposition, iblockdata) > 0;
+    }
+
+    protected int b(World world, BlockPosition blockposition, IBlockData iblockdata) {
+        EnumDirection enumdirection = (EnumDirection) iblockdata.get(BlockDiodeAbstract.FACING);
+        BlockPosition blockposition1 = blockposition.shift(enumdirection);
+        int i = world.getBlockFacePower(blockposition1, enumdirection);
+
+        if (i >= 15) {
+            return i;
+        } else {
+            IBlockData iblockdata1 = world.getType(blockposition1);
+
+            return Math.max(i, iblockdata1.getBlock() == Blocks.REDSTONE_WIRE ? (Integer) iblockdata1.get(BlockRedstoneWire.POWER) : 0);
+        }
+    }
+
+    protected int b(IWorldReader iworldreader, BlockPosition blockposition, IBlockData iblockdata) {
+        EnumDirection enumdirection = (EnumDirection) iblockdata.get(BlockDiodeAbstract.FACING);
+        EnumDirection enumdirection1 = enumdirection.e();
+        EnumDirection enumdirection2 = enumdirection.f();
+
+        return Math.max(this.a(iworldreader, blockposition.shift(enumdirection1), enumdirection1), this.a(iworldreader, blockposition.shift(enumdirection2), enumdirection2));
+    }
+
+    protected int a(IWorldReader iworldreader, BlockPosition blockposition, EnumDirection enumdirection) {
+        IBlockData iblockdata = iworldreader.getType(blockposition);
+        Block block = iblockdata.getBlock();
+
+        return this.w(iblockdata) ? (block == Blocks.REDSTONE_BLOCK ? 15 : (block == Blocks.REDSTONE_WIRE ? (Integer) iblockdata.get(BlockRedstoneWire.POWER) : iworldreader.a(blockposition, enumdirection))) : 0;
+    }
+
+    public boolean isPowerSource(IBlockData iblockdata) {
+        return true;
+    }
+
+    public IBlockData getPlacedState(BlockActionContext blockactioncontext) {
+        return (IBlockData) this.getBlockData().set(BlockDiodeAbstract.FACING, blockactioncontext.f().opposite());
+    }
+
+    public void postPlace(World world, BlockPosition blockposition, IBlockData iblockdata, EntityLiving entityliving, ItemStack itemstack) {
+        if (this.a(world, blockposition, iblockdata)) {
+            world.getBlockTickList().a(blockposition, this, 1);
+        }
+
+    }
+
+    public void onPlace(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1) {
+        this.d(world, blockposition, iblockdata);
+    }
+
+    public void remove(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1, boolean flag) {
+        if (!flag && iblockdata.getBlock() != iblockdata1.getBlock()) {
+            super.remove(iblockdata, world, blockposition, iblockdata1, flag);
+            this.a(world, blockposition);
+            this.d(world, blockposition, iblockdata);
+        }
+    }
+
+    protected void a(World world, BlockPosition blockposition) {}
+
+    protected void d(World world, BlockPosition blockposition, IBlockData iblockdata) {
+        EnumDirection enumdirection = (EnumDirection) iblockdata.get(BlockDiodeAbstract.FACING);
+        BlockPosition blockposition1 = blockposition.shift(enumdirection.opposite());
+
+        world.a(blockposition1, (Block) this, blockposition);
+        world.a(blockposition1, (Block) this, enumdirection);
+    }
+
+    protected boolean w(IBlockData iblockdata) {
+        return iblockdata.isPowerSource();
+    }
+
+    protected int b(IBlockAccess iblockaccess, BlockPosition blockposition, IBlockData iblockdata) {
+        return 15;
+    }
+
+    public static boolean isDiode(IBlockData iblockdata) {
+        return iblockdata.getBlock() instanceof BlockDiodeAbstract;
+    }
+
+    public boolean c(IBlockAccess iblockaccess, BlockPosition blockposition, IBlockData iblockdata) {
+        EnumDirection enumdirection = ((EnumDirection) iblockdata.get(BlockDiodeAbstract.FACING)).opposite();
+        IBlockData iblockdata1 = iblockaccess.getType(blockposition.shift(enumdirection));
+
+        return isDiode(iblockdata1) && iblockdata1.get(BlockDiodeAbstract.FACING) != enumdirection;
+    }
+
+    protected abstract int k(IBlockData iblockdata);
+
+    public TextureType c() {
+        return TextureType.CUTOUT;
+    }
+
+    public boolean f(IBlockData iblockdata) {
+        return true;
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return enumdirection == EnumDirection.DOWN ? EnumBlockFaceShape.SOLID : EnumBlockFaceShape.UNDEFINED;
+    }
+}

src/main/java/net/minecraft/server/BlockDirtSnowSpreadable.java

@@ -0,0 +1,51 @@
+package net.minecraft.server;
+
+import java.util.Random;
+
+public abstract class BlockDirtSnowSpreadable extends BlockDirtSnow {
+
+    protected BlockDirtSnowSpreadable(Block.Info block_info) {
+        super(block_info);
+    }
+
+    private static boolean a(IWorldReader iworldreader, BlockPosition blockposition) {
+        BlockPosition blockposition1 = blockposition.up();
+
+        return iworldreader.getLightLevel(blockposition1) >= 4 || iworldreader.getType(blockposition1).b(iworldreader, blockposition1) < iworldreader.K();
+    }
+
+    private static boolean b(IWorldReader iworldreader, BlockPosition blockposition) {
+        BlockPosition blockposition1 = blockposition.up();
+
+        return iworldreader.getLightLevel(blockposition1) >= 4 && iworldreader.getType(blockposition1).b(iworldreader, blockposition1) < iworldreader.K() && !iworldreader.getFluid(blockposition1).a(TagsFluid.WATER);
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if (this instanceof BlockGrass && world.paperConfig.grassUpdateRate != 1 && (world.paperConfig.grassUpdateRate < 1 || (MinecraftServer.currentTick + blockposition.hashCode()) % world.paperConfig.grassUpdateRate != 0)) { return; } // Paper
+        if (!world.isClientSide) {
+            if (!a((IWorldReader) world, blockposition)) {
+                // CraftBukkit start
+                if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockFadeEvent(world, blockposition, Blocks.DIRT.getBlockData()).isCancelled()) {
+                    return;
+                }
+                // CraftBukkit end
+                world.setTypeUpdate(blockposition, Blocks.DIRT.getBlockData());
+            } else {
+                if (world.getLightLevel(blockposition.up()) >= 9) {
+                    for (int i = 0; i < 4; ++i) {
+                        BlockPosition blockposition1 = blockposition.a(random.nextInt(3) - 1, random.nextInt(5) - 3, random.nextInt(3) - 1);
+
+                        if (!world.p(blockposition1)) {
+                            return;
+                        }
+
+                        if (world.getType(blockposition1).getBlock() == Blocks.DIRT && b(world, blockposition1)) {
+                            org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockSpreadEvent(world, blockposition, blockposition1, this.getBlockData()); // CraftBukkit
+                        }
+                    }
+                }
+
+            }
+        }
+    }
+}

src/main/java/net/minecraft/server/BlockDispenser.java

@@ -0,0 +1,155 @@
+package net.minecraft.server;
+
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
+import java.util.Map;
+import java.util.Random;
+
+public class BlockDispenser extends BlockTileEntity {
+
+    public static final BlockStateDirection FACING = BlockDirectional.FACING;
+    public static final BlockStateBoolean TRIGGERED = BlockProperties.w;
+    public static final Map<Item, IDispenseBehavior> REGISTRY = (Map) SystemUtils.a((new Object2ObjectOpenHashMap()), (object2objectopenhashmap) -> { // CraftBukkit - decompile error
+        object2objectopenhashmap.defaultReturnValue(new DispenseBehaviorItem());
+    });
+    public static boolean eventFired = false; // CraftBukkit
+
+    public static void a(IMaterial imaterial, IDispenseBehavior idispensebehavior) {
+        BlockDispenser.REGISTRY.put(imaterial.getItem(), idispensebehavior);
+    }
+
+    protected BlockDispenser(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockDispenser.FACING, EnumDirection.NORTH)).set(BlockDispenser.TRIGGERED, false));
+    }
+
+    public int a(IWorldReader iworldreader) {
+        return 4;
+    }
+
+    public boolean interact(IBlockData iblockdata, World world, BlockPosition blockposition, EntityHuman entityhuman, EnumHand enumhand, EnumDirection enumdirection, float f, float f1, float f2) {
+        if (world.isClientSide) {
+            return true;
+        } else {
+            TileEntity tileentity = world.getTileEntity(blockposition);
+
+            if (tileentity instanceof TileEntityDispenser) {
+                entityhuman.openContainer((TileEntityDispenser) tileentity);
+                if (tileentity instanceof TileEntityDropper) {
+                    entityhuman.a(StatisticList.INSPECT_DROPPER);
+                } else {
+                    entityhuman.a(StatisticList.INSPECT_DISPENSER);
+                }
+            }
+
+            return true;
+        }
+    }
+
+    public void dispense(World world, BlockPosition blockposition) {
+        SourceBlock sourceblock = new SourceBlock(world, blockposition);
+        TileEntityDispenser tileentitydispenser = (TileEntityDispenser) sourceblock.getTileEntity();
+        int i = tileentitydispenser.p();
+
+        if (i < 0) {
+            world.triggerEffect(1001, blockposition, 0);
+        } else {
+            ItemStack itemstack = tileentitydispenser.getItem(i);
+            IDispenseBehavior idispensebehavior = this.a(itemstack);
+
+            if (idispensebehavior != IDispenseBehavior.NONE) {
+                eventFired = false; // CraftBukkit - reset event status
+                tileentitydispenser.setItem(i, idispensebehavior.dispense(sourceblock, itemstack));
+            }
+
+        }
+    }
+
+    protected IDispenseBehavior a(ItemStack itemstack) {
+        return (IDispenseBehavior) BlockDispenser.REGISTRY.get(itemstack.getItem());
+    }
+
+    public void doPhysics(IBlockData iblockdata, World world, BlockPosition blockposition, Block block, BlockPosition blockposition1) {
+        boolean flag = world.isBlockIndirectlyPowered(blockposition) || world.isBlockIndirectlyPowered(blockposition.up());
+        boolean flag1 = (Boolean) iblockdata.get(BlockDispenser.TRIGGERED);
+
+        if (flag && !flag1) {
+            world.getBlockTickList().a(blockposition, this, this.a((IWorldReader) world));
+            world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockDispenser.TRIGGERED, true), 4);
+        } else if (!flag && flag1) {
+            world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockDispenser.TRIGGERED, false), 4);
+        }
+
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if (!world.isClientSide) {
+            this.dispense(world, blockposition);
+        }
+
+    }
+
+    public TileEntity a(IBlockAccess iblockaccess) {
+        return new TileEntityDispenser();
+    }
+
+    public IBlockData getPlacedState(BlockActionContext blockactioncontext) {
+        return (IBlockData) this.getBlockData().set(BlockDispenser.FACING, blockactioncontext.d().opposite());
+    }
+
+    public void postPlace(World world, BlockPosition blockposition, IBlockData iblockdata, EntityLiving entityliving, ItemStack itemstack) {
+        if (itemstack.hasName()) {
+            TileEntity tileentity = world.getTileEntity(blockposition);
+
+            if (tileentity instanceof TileEntityDispenser) {
+                ((TileEntityDispenser) tileentity).setCustomName(itemstack.getName());
+            }
+        }
+
+    }
+
+    public void remove(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1, boolean flag) {
+        if (iblockdata.getBlock() != iblockdata1.getBlock()) {
+            TileEntity tileentity = world.getTileEntity(blockposition);
+
+            if (tileentity instanceof TileEntityDispenser) {
+                InventoryUtils.dropInventory(world, blockposition, (TileEntityDispenser) tileentity);
+                world.updateAdjacentComparators(blockposition, this);
+            }
+
+            super.remove(iblockdata, world, blockposition, iblockdata1, flag);
+        }
+    }
+
+    public static IPosition a(ISourceBlock isourceblock) {
+        EnumDirection enumdirection = (EnumDirection) isourceblock.e().get(BlockDispenser.FACING);
+        double d0 = isourceblock.getX() + 0.7D * (double) enumdirection.getAdjacentX();
+        double d1 = isourceblock.getY() + 0.7D * (double) enumdirection.getAdjacentY();
+        double d2 = isourceblock.getZ() + 0.7D * (double) enumdirection.getAdjacentZ();
+
+        return new Position(d0, d1, d2);
+    }
+
+    public boolean isComplexRedstone(IBlockData iblockdata) {
+        return true;
+    }
+
+    public int a(IBlockData iblockdata, World world, BlockPosition blockposition) {
+        return Container.a(world.getTileEntity(blockposition));
+    }
+
+    public EnumRenderType c(IBlockData iblockdata) {
+        return EnumRenderType.MODEL;
+    }
+
+    public IBlockData a(IBlockData iblockdata, EnumBlockRotation enumblockrotation) {
+        return (IBlockData) iblockdata.set(BlockDispenser.FACING, enumblockrotation.a((EnumDirection) iblockdata.get(BlockDispenser.FACING)));
+    }
+
+    public IBlockData a(IBlockData iblockdata, EnumBlockMirror enumblockmirror) {
+        return iblockdata.a(enumblockmirror.a((EnumDirection) iblockdata.get(BlockDispenser.FACING)));
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockDispenser.FACING, BlockDispenser.TRIGGERED);
+    }
+}

src/main/java/net/minecraft/server/BlockDoor.java

@@ -0,0 +1,232 @@
+package net.minecraft.server;
+
+import javax.annotation.Nullable;
+
+import org.bukkit.event.block.BlockRedstoneEvent; // CraftBukkit
+
+public class BlockDoor extends Block {
+
+    public static final BlockStateDirection FACING = BlockFacingHorizontal.FACING;
+    public static final BlockStateBoolean OPEN = BlockProperties.r;
+    public static final BlockStateEnum<BlockPropertyDoorHinge> HINGE = BlockProperties.ar;
+    public static final BlockStateBoolean POWERED = BlockProperties.t;
+    public static final BlockStateEnum<BlockPropertyDoubleBlockHalf> HALF = BlockProperties.P;
+    protected static final VoxelShape q = Block.a(0.0D, 0.0D, 0.0D, 16.0D, 16.0D, 3.0D);
+    protected static final VoxelShape r = Block.a(0.0D, 0.0D, 13.0D, 16.0D, 16.0D, 16.0D);
+    protected static final VoxelShape s = Block.a(13.0D, 0.0D, 0.0D, 16.0D, 16.0D, 16.0D);
+    protected static final VoxelShape t = Block.a(0.0D, 0.0D, 0.0D, 3.0D, 16.0D, 16.0D);
+
+    protected BlockDoor(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockDoor.FACING, EnumDirection.NORTH)).set(BlockDoor.OPEN, false)).set(BlockDoor.HINGE, BlockPropertyDoorHinge.LEFT)).set(BlockDoor.POWERED, false)).set(BlockDoor.HALF, BlockPropertyDoubleBlockHalf.LOWER));
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        EnumDirection enumdirection = (EnumDirection) iblockdata.get(BlockDoor.FACING);
+        boolean flag = !(Boolean) iblockdata.get(BlockDoor.OPEN);
+        boolean flag1 = iblockdata.get(BlockDoor.HINGE) == BlockPropertyDoorHinge.RIGHT;
+
+        switch (enumdirection) {
+        case EAST:
+        default:
+            return flag ? BlockDoor.t : (flag1 ? BlockDoor.r : BlockDoor.q);
+        case SOUTH:
+            return flag ? BlockDoor.q : (flag1 ? BlockDoor.t : BlockDoor.s);
+        case WEST:
+            return flag ? BlockDoor.s : (flag1 ? BlockDoor.q : BlockDoor.r);
+        case NORTH:
+            return flag ? BlockDoor.r : (flag1 ? BlockDoor.s : BlockDoor.t);
+        }
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        BlockPropertyDoubleBlockHalf blockpropertydoubleblockhalf = (BlockPropertyDoubleBlockHalf) iblockdata.get(BlockDoor.HALF);
+
+        return enumdirection.k() == EnumDirection.EnumAxis.Y && blockpropertydoubleblockhalf == BlockPropertyDoubleBlockHalf.LOWER == (enumdirection == EnumDirection.UP) ? (iblockdata1.getBlock() == this && iblockdata1.get(BlockDoor.HALF) != blockpropertydoubleblockhalf ? (IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) iblockdata.set(BlockDoor.FACING, iblockdata1.get(BlockDoor.FACING))).set(BlockDoor.OPEN, iblockdata1.get(BlockDoor.OPEN))).set(BlockDoor.HINGE, iblockdata1.get(BlockDoor.HINGE))).set(BlockDoor.POWERED, iblockdata1.get(BlockDoor.POWERED)) : Blocks.AIR.getBlockData()) : (blockpropertydoubleblockhalf == BlockPropertyDoubleBlockHalf.LOWER && enumdirection == EnumDirection.DOWN && !iblockdata.canPlace(generatoraccess, blockposition) ? Blocks.AIR.getBlockData() : super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1));
+    }
+
+    public void a(World world, EntityHuman entityhuman, BlockPosition blockposition, IBlockData iblockdata, @Nullable TileEntity tileentity, ItemStack itemstack) {
+        super.a(world, entityhuman, blockposition, Blocks.AIR.getBlockData(), tileentity, itemstack);
+    }
+
+    public void a(World world, BlockPosition blockposition, IBlockData iblockdata, EntityHuman entityhuman) {
+        BlockPropertyDoubleBlockHalf blockpropertydoubleblockhalf = (BlockPropertyDoubleBlockHalf) iblockdata.get(BlockDoor.HALF);
+        boolean flag = blockpropertydoubleblockhalf == BlockPropertyDoubleBlockHalf.LOWER;
+        BlockPosition blockposition1 = flag ? blockposition.up() : blockposition.down();
+        IBlockData iblockdata1 = world.getType(blockposition1);
+
+        if (iblockdata1.getBlock() == this && iblockdata1.get(BlockDoor.HALF) != blockpropertydoubleblockhalf) {
+            world.setTypeAndData(blockposition1, Blocks.AIR.getBlockData(), 35);
+            world.a(entityhuman, 2001, blockposition1, Block.getCombinedId(iblockdata1));
+            if (!world.isClientSide && !entityhuman.u()) {
+                if (flag) {
+                    iblockdata.a(world, blockposition, 0);
+                } else {
+                    iblockdata1.a(world, blockposition1, 0);
+                }
+            }
+        }
+
+        super.a(world, blockposition, iblockdata, entityhuman);
+    }
+
+    public boolean a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, PathMode pathmode) {
+        switch (pathmode) {
+        case LAND:
+            return (Boolean) iblockdata.get(BlockDoor.OPEN);
+        case WATER:
+            return false;
+        case AIR:
+            return (Boolean) iblockdata.get(BlockDoor.OPEN);
+        default:
+            return false;
+        }
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    private int d() {
+        return this.material == Material.ORE ? 1011 : 1012;
+    }
+
+    private int e() {
+        return this.material == Material.ORE ? 1005 : 1006;
+    }
+
+    @Nullable
+    public IBlockData getPlacedState(BlockActionContext blockactioncontext) {
+        BlockPosition blockposition = blockactioncontext.getClickPosition();
+
+        if (blockposition.getY() < 255 && blockactioncontext.getWorld().getType(blockposition.up()).a(blockactioncontext)) {
+            World world = blockactioncontext.getWorld();
+            boolean flag = world.isBlockIndirectlyPowered(blockposition) || world.isBlockIndirectlyPowered(blockposition.up());
+
+            return (IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) this.getBlockData().set(BlockDoor.FACING, blockactioncontext.f())).set(BlockDoor.HINGE, this.b(blockactioncontext))).set(BlockDoor.POWERED, flag)).set(BlockDoor.OPEN, flag)).set(BlockDoor.HALF, BlockPropertyDoubleBlockHalf.LOWER);
+        } else {
+            return null;
+        }
+    }
+
+    public void postPlace(World world, BlockPosition blockposition, IBlockData iblockdata, EntityLiving entityliving, ItemStack itemstack) {
+        world.setTypeAndData(blockposition.up(), (IBlockData) iblockdata.set(BlockDoor.HALF, BlockPropertyDoubleBlockHalf.UPPER), 3);
+    }
+
+    private BlockPropertyDoorHinge b(BlockActionContext blockactioncontext) {
+        World world = blockactioncontext.getWorld();
+        BlockPosition blockposition = blockactioncontext.getClickPosition();
+        EnumDirection enumdirection = blockactioncontext.f();
+        BlockPosition blockposition1 = blockposition.up();
+        EnumDirection enumdirection1 = enumdirection.f();
+        IBlockData iblockdata = world.getType(blockposition.shift(enumdirection1));
+        IBlockData iblockdata1 = world.getType(blockposition1.shift(enumdirection1));
+        EnumDirection enumdirection2 = enumdirection.e();
+        IBlockData iblockdata2 = world.getType(blockposition.shift(enumdirection2));
+        IBlockData iblockdata3 = world.getType(blockposition1.shift(enumdirection2));
+        int i = (iblockdata.k() ? -1 : 0) + (iblockdata1.k() ? -1 : 0) + (iblockdata2.k() ? 1 : 0) + (iblockdata3.k() ? 1 : 0);
+        boolean flag = iblockdata.getBlock() == this && iblockdata.get(BlockDoor.HALF) == BlockPropertyDoubleBlockHalf.LOWER;
+        boolean flag1 = iblockdata2.getBlock() == this && iblockdata2.get(BlockDoor.HALF) == BlockPropertyDoubleBlockHalf.LOWER;
+
+        if ((!flag || flag1) && i <= 0) {
+            if ((!flag1 || flag) && i >= 0) {
+                int j = enumdirection.getAdjacentX();
+                int k = enumdirection.getAdjacentZ();
+                float f = blockactioncontext.m();
+                float f1 = blockactioncontext.o();
+
+                return (j >= 0 || f1 >= 0.5F) && (j <= 0 || f1 <= 0.5F) && (k >= 0 || f <= 0.5F) && (k <= 0 || f >= 0.5F) ? BlockPropertyDoorHinge.LEFT : BlockPropertyDoorHinge.RIGHT;
+            } else {
+                return BlockPropertyDoorHinge.LEFT;
+            }
+        } else {
+            return BlockPropertyDoorHinge.RIGHT;
+        }
+    }
+
+    public boolean interact(IBlockData iblockdata, World world, BlockPosition blockposition, EntityHuman entityhuman, EnumHand enumhand, EnumDirection enumdirection, float f, float f1, float f2) {
+        if (this.material == Material.ORE) {
+            return false;
+        } else {
+            iblockdata = (IBlockData) iblockdata.a((IBlockState) BlockDoor.OPEN);
+            world.setTypeAndData(blockposition, iblockdata, 10);
+            world.a(entityhuman, (Boolean) iblockdata.get(BlockDoor.OPEN) ? this.e() : this.d(), blockposition, 0);
+            return true;
+        }
+    }
+
+    public void setDoor(World world, BlockPosition blockposition, boolean flag) {
+        IBlockData iblockdata = world.getType(blockposition);
+
+        if (iblockdata.getBlock() == this && (Boolean) iblockdata.get(BlockDoor.OPEN) != flag) {
+            world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockDoor.OPEN, flag), 10);
+            this.b(world, blockposition, flag);
+        }
+    }
+
+    public void doPhysics(IBlockData iblockdata, World world, BlockPosition blockposition, Block block, BlockPosition blockposition1) {
+        // CraftBukkit start
+        BlockPosition otherHalf = blockposition.shift(iblockdata.get(BlockDoor.HALF) == BlockPropertyDoubleBlockHalf.LOWER ? EnumDirection.UP : EnumDirection.DOWN);
+
+        org.bukkit.World bworld = world.getWorld();
+        org.bukkit.block.Block bukkitBlock = bworld.getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
+        org.bukkit.block.Block blockTop = bworld.getBlockAt(otherHalf.getX(), otherHalf.getY(), otherHalf.getZ());
+
+        int power = bukkitBlock.getBlockPower();
+        int powerTop = blockTop.getBlockPower();
+        if (powerTop > power) power = powerTop;
+        int oldPower = (Boolean) iblockdata.get(BlockDoor.POWERED) ? 15 : 0;
+
+        if (oldPower == 0 ^ power == 0) {
+            BlockRedstoneEvent eventRedstone = new BlockRedstoneEvent(bukkitBlock, oldPower, power);
+            world.getServer().getPluginManager().callEvent(eventRedstone);
+
+            boolean flag = eventRedstone.getNewCurrent() > 0;
+            // CraftBukkit end
+            if (flag != (Boolean) iblockdata.get(BlockDoor.OPEN)) {
+                this.b(world, blockposition, flag);
+            }
+
+            world.setTypeAndData(blockposition, (IBlockData) ((IBlockData) iblockdata.set(BlockDoor.POWERED, flag)).set(BlockDoor.OPEN, flag), 2);
+        }
+
+    }
+
+    public boolean canPlace(IBlockData iblockdata, IWorldReader iworldreader, BlockPosition blockposition) {
+        IBlockData iblockdata1 = iworldreader.getType(blockposition.down());
+
+        return iblockdata.get(BlockDoor.HALF) == BlockPropertyDoubleBlockHalf.LOWER ? iblockdata1.q() : iblockdata1.getBlock() == this;
+    }
+
+    private void b(World world, BlockPosition blockposition, boolean flag) {
+        world.a((EntityHuman) null, flag ? this.e() : this.d(), blockposition, 0);
+    }
+
+    public IMaterial getDropType(IBlockData iblockdata, World world, BlockPosition blockposition, int i) {
+        return (IMaterial) (iblockdata.get(BlockDoor.HALF) == BlockPropertyDoubleBlockHalf.UPPER ? Items.AIR : super.getDropType(iblockdata, world, blockposition, i));
+    }
+
+    public EnumPistonReaction getPushReaction(IBlockData iblockdata) {
+        return EnumPistonReaction.DESTROY;
+    }
+
+    public TextureType c() {
+        return TextureType.CUTOUT;
+    }
+
+    public IBlockData a(IBlockData iblockdata, EnumBlockRotation enumblockrotation) {
+        return (IBlockData) iblockdata.set(BlockDoor.FACING, enumblockrotation.a((EnumDirection) iblockdata.get(BlockDoor.FACING)));
+    }
+
+    public IBlockData a(IBlockData iblockdata, EnumBlockMirror enumblockmirror) {
+        return enumblockmirror == EnumBlockMirror.NONE ? iblockdata : (IBlockData) iblockdata.a(enumblockmirror.a((EnumDirection) iblockdata.get(BlockDoor.FACING))).a((IBlockState) BlockDoor.HINGE);
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockDoor.HALF, BlockDoor.FACING, BlockDoor.OPEN, BlockDoor.HINGE, BlockDoor.POWERED);
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return EnumBlockFaceShape.UNDEFINED;
+    }
+}

src/main/java/net/minecraft/server/BlockDragonEgg.java

@@ -0,0 +1,81 @@
+package net.minecraft.server;
+
+import org.bukkit.event.block.BlockFromToEvent; // CraftBukkit
+
+public class BlockDragonEgg extends BlockFalling {
+
+    protected static final VoxelShape a = Block.a(1.0D, 0.0D, 1.0D, 15.0D, 16.0D, 15.0D);
+
+    public BlockDragonEgg(Block.Info block_info) {
+        super(block_info);
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return BlockDragonEgg.a;
+    }
+
+    public boolean interact(IBlockData iblockdata, World world, BlockPosition blockposition, EntityHuman entityhuman, EnumHand enumhand, EnumDirection enumdirection, float f, float f1, float f2) {
+        this.b(iblockdata, world, blockposition);
+        return true;
+    }
+
+    public void attack(IBlockData iblockdata, World world, BlockPosition blockposition, EntityHuman entityhuman) {
+        this.b(iblockdata, world, blockposition);
+    }
+
+    private void b(IBlockData iblockdata, World world, BlockPosition blockposition) {
+        for (int i = 0; i < 1000; ++i) {
+            BlockPosition blockposition1 = blockposition.a(world.random.nextInt(16) - world.random.nextInt(16), world.random.nextInt(8) - world.random.nextInt(8), world.random.nextInt(16) - world.random.nextInt(16));
+
+            if (world.getType(blockposition1).isAir()) {
+                // CraftBukkit start
+                org.bukkit.block.Block from = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
+                org.bukkit.block.Block to = world.getWorld().getBlockAt(blockposition1.getX(), blockposition1.getY(), blockposition1.getZ());
+                BlockFromToEvent event = new BlockFromToEvent(from, to);
+                org.bukkit.Bukkit.getPluginManager().callEvent(event);
+
+                if (event.isCancelled()) {
+                    return;
+                }
+
+                blockposition1 = new BlockPosition(event.getToBlock().getX(), event.getToBlock().getY(), event.getToBlock().getZ());
+                // CraftBukkit end
+                if (world.isClientSide) {
+                    for (int j = 0; j < 128; ++j) {
+                        double d0 = world.random.nextDouble();
+                        float f = (world.random.nextFloat() - 0.5F) * 0.2F;
+                        float f1 = (world.random.nextFloat() - 0.5F) * 0.2F;
+                        float f2 = (world.random.nextFloat() - 0.5F) * 0.2F;
+                        double d1 = (double) blockposition1.getX() + (double) (blockposition.getX() - blockposition1.getX()) * d0 + (world.random.nextDouble() - 0.5D) + 0.5D;
+                        double d2 = (double) blockposition1.getY() + (double) (blockposition.getY() - blockposition1.getY()) * d0 + world.random.nextDouble() - 0.5D;
+                        double d3 = (double) blockposition1.getZ() + (double) (blockposition.getZ() - blockposition1.getZ()) * d0 + (world.random.nextDouble() - 0.5D) + 0.5D;
+
+                        world.addParticle(Particles.K, d1, d2, d3, (double) f, (double) f1, (double) f2);
+                    }
+                } else {
+                    world.setTypeAndData(blockposition1, iblockdata, 2);
+                    world.setAir(blockposition);
+                }
+
+                return;
+            }
+        }
+
+    }
+
+    public int a(IWorldReader iworldreader) {
+        return 5;
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return EnumBlockFaceShape.UNDEFINED;
+    }
+
+    public boolean a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, PathMode pathmode) {
+        return false;
+    }
+}

src/main/java/net/minecraft/server/BlockDropper.java

@@ -0,0 +1,72 @@
+package net.minecraft.server;
+
+// CraftBukkit start
+import org.bukkit.craftbukkit.inventory.CraftItemStack;
+import org.bukkit.event.inventory.InventoryMoveItemEvent;
+// CraftBukkit end
+
+public class BlockDropper extends BlockDispenser {
+
+    private static final IDispenseBehavior c = new DispenseBehaviorItem();
+
+    public BlockDropper(Block.Info block_info) {
+        super(block_info);
+    }
+
+    protected IDispenseBehavior a(ItemStack itemstack) {
+        return BlockDropper.c;
+    }
+
+    public TileEntity a(IBlockAccess iblockaccess) {
+        return new TileEntityDropper();
+    }
+
+    public void dispense(World world, BlockPosition blockposition) {
+        SourceBlock sourceblock = new SourceBlock(world, blockposition);
+        TileEntityDispenser tileentitydispenser = (TileEntityDispenser) sourceblock.getTileEntity();
+        int i = tileentitydispenser.p();
+
+        if (i < 0) {
+            world.triggerEffect(1001, blockposition, 0);
+        } else {
+            ItemStack itemstack = tileentitydispenser.getItem(i);
+
+            if (!itemstack.isEmpty()) {
+                EnumDirection enumdirection = (EnumDirection) world.getType(blockposition).get(BlockDropper.FACING);
+                IInventory iinventory = TileEntityHopper.a(world, blockposition.shift(enumdirection));
+                ItemStack itemstack1;
+
+                if (iinventory == null) {
+                    itemstack1 = BlockDropper.c.dispense(sourceblock, itemstack);
+                } else {
+                    // CraftBukkit start - Fire event when pushing items into other inventories
+                    CraftItemStack oitemstack = CraftItemStack.asCraftMirror(itemstack.cloneItemStack().cloneAndSubtract(1));
+
+                    org.bukkit.inventory.Inventory destinationInventory;
+                    // Have to special case large chests as they work oddly
+                    if (iinventory instanceof InventoryLargeChest) {
+                        destinationInventory = new org.bukkit.craftbukkit.inventory.CraftInventoryDoubleChest((InventoryLargeChest) iinventory);
+                    } else {
+                        destinationInventory = iinventory.getOwner().getInventory();
+                    }
+
+                    InventoryMoveItemEvent event = new InventoryMoveItemEvent(tileentitydispenser.getOwner().getInventory(), oitemstack.clone(), destinationInventory, true);
+                    world.getServer().getPluginManager().callEvent(event);
+                    if (event.isCancelled()) {
+                        return;
+                    }
+                    itemstack1 = TileEntityHopper.addItem(tileentitydispenser, iinventory, CraftItemStack.asNMSCopy(event.getItem()), enumdirection.opposite());
+                    if (event.getItem().equals(oitemstack) && itemstack1.isEmpty()) {
+                        // CraftBukkit end
+                        itemstack1 = itemstack.cloneItemStack();
+                        itemstack1.subtract(1);
+                    } else {
+                        itemstack1 = itemstack.cloneItemStack();
+                    }
+                }
+
+                tileentitydispenser.setItem(i, itemstack1);
+            }
+        }
+    }
+}

src/main/java/net/minecraft/server/BlockEnderPortal.java

@@ -0,0 +1,49 @@
+package net.minecraft.server;
+
+import java.util.Random;
+
+import org.bukkit.event.entity.EntityPortalEnterEvent; // CraftBukkit
+
+public class BlockEnderPortal extends BlockTileEntity {
+
+    protected static final VoxelShape a = Block.a(0.0D, 0.0D, 0.0D, 16.0D, 12.0D, 16.0D);
+
+    protected BlockEnderPortal(Block.Info block_info) {
+        super(block_info);
+    }
+
+    public TileEntity a(IBlockAccess iblockaccess) {
+        return new TileEntityEnderPortal();
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return BlockEnderPortal.a;
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public int a(IBlockData iblockdata, Random random) {
+        return 0;
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
+        if (!world.isClientSide && !entity.isPassenger() && !entity.isVehicle() && entity.bm() && VoxelShapes.c(VoxelShapes.a(entity.getBoundingBox().d((double) (-blockposition.getX()), (double) (-blockposition.getY()), (double) (-blockposition.getZ()))), iblockdata.getShape(world, blockposition), OperatorBoolean.AND)) {
+            // CraftBukkit start - Entity in portal
+            EntityPortalEnterEvent event = new EntityPortalEnterEvent(entity.getBukkitEntity(), new org.bukkit.Location(world.getWorld(), blockposition.getX(), blockposition.getY(), blockposition.getZ()));
+            world.getServer().getPluginManager().callEvent(event);
+            // CraftBukkit end
+            entity.a(DimensionManager.THE_END);
+        }
+
+    }
+
+    public ItemStack a(IBlockAccess iblockaccess, BlockPosition blockposition, IBlockData iblockdata) {
+        return ItemStack.a;
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return EnumBlockFaceShape.UNDEFINED;
+    }
+}

src/main/java/net/minecraft/server/BlockFire.java

@@ -0,0 +1,459 @@
+package net.minecraft.server;
+
+import it.unimi.dsi.fastutil.objects.Object2IntMap;
+import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
+import com.destroystokyo.paper.event.block.TNTPrimeEvent; // Paper - TNTPrimeEvent
+import java.util.Map;
+import java.util.Random;
+import java.util.Map.Entry;
+import javax.annotation.Nullable;
+
+// CraftBukkit start
+
+import org.bukkit.Bukkit;
+import org.bukkit.craftbukkit.block.CraftBlockState;
+import org.bukkit.craftbukkit.event.CraftEventFactory;
+import org.bukkit.event.block.BlockBurnEvent;
+import org.bukkit.event.block.BlockFadeEvent;
+import org.bukkit.event.block.BlockSpreadEvent;
+// CraftBukkit end
+
+public class BlockFire extends Block {
+
+    public static final BlockStateInteger AGE = BlockProperties.X;
+    public static final BlockStateBoolean NORTH = BlockSprawling.a;
+    public static final BlockStateBoolean EAST = BlockSprawling.b;
+    public static final BlockStateBoolean SOUTH = BlockSprawling.c;
+    public static final BlockStateBoolean WEST = BlockSprawling.o;
+    public static final BlockStateBoolean UPPER = BlockSprawling.p;
+    private static final Map<EnumDirection, BlockStateBoolean> r = (Map) BlockSprawling.r.entrySet().stream().filter((entry) -> {
+        return entry.getKey() != EnumDirection.DOWN;
+    }).collect(SystemUtils.a());
+    private final Object2IntMap<Block> flameChances = new Object2IntOpenHashMap();
+    private final Object2IntMap<Block> t = new Object2IntOpenHashMap();
+
+    protected BlockFire(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockFire.AGE, 0)).set(BlockFire.NORTH, false)).set(BlockFire.EAST, false)).set(BlockFire.SOUTH, false)).set(BlockFire.WEST, false)).set(BlockFire.UPPER, false));
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return VoxelShapes.a();
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        // CraftBukkit start
+        if (!iblockdata.canPlace(generatoraccess, blockposition)) {
+            CraftBlockState blockState = CraftBlockState.getBlockState(generatoraccess, blockposition);
+            blockState.setData(Blocks.AIR.getBlockData());
+
+            BlockFadeEvent event = new BlockFadeEvent(blockState.getBlock(), blockState);
+            generatoraccess.getMinecraftWorld().getMinecraftServer().server.getPluginManager().callEvent(event);
+
+            if (!event.isCancelled()) {
+                return blockState.getHandle();
+            }
+        }
+        return this.a((IBlockAccess) generatoraccess, blockposition).set(BlockFire.AGE, iblockdata.get(BlockFire.AGE));
+        // CraftBukkit end
+    }
+
+    @Nullable
+    public IBlockData getPlacedState(BlockActionContext blockactioncontext) {
+        return this.a((IBlockAccess) blockactioncontext.getWorld(), blockactioncontext.getClickPosition());
+    }
+
+    public IBlockData a(IBlockAccess iblockaccess, BlockPosition blockposition) {
+        IBlockData iblockdata = iblockaccess.getType(blockposition.down());
+
+        if (!iblockdata.q() && !this.k(iblockdata)) {
+            IBlockData iblockdata1 = this.getBlockData();
+            EnumDirection[] aenumdirection = EnumDirection.values();
+            int i = aenumdirection.length;
+
+            for (int j = 0; j < i; ++j) {
+                EnumDirection enumdirection = aenumdirection[j];
+                BlockStateBoolean blockstateboolean = (BlockStateBoolean) BlockFire.r.get(enumdirection);
+
+                if (blockstateboolean != null) {
+                    iblockdata1 = (IBlockData) iblockdata1.set(blockstateboolean, this.k(iblockaccess.getType(blockposition.shift(enumdirection))));
+                }
+            }
+
+            return iblockdata1;
+        } else {
+            return this.getBlockData();
+        }
+    }
+
+    public boolean canPlace(IBlockData iblockdata, IWorldReader iworldreader, BlockPosition blockposition) {
+        return iworldreader.getType(blockposition.down()).q() || this.d(iworldreader, blockposition);
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public int a(IBlockData iblockdata, Random random) {
+        return 0;
+    }
+
+    public int a(IWorldReader iworldreader) {
+        return 30;
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if (world.getGameRules().getBoolean("doFireTick")) {
+            if (!iblockdata.canPlace(world, blockposition)) {
+                fireExtinguished(world, blockposition); // CraftBukkit - invalid place location
+            }
+
+            Block block = world.getType(blockposition.down()).getBlock();
+            boolean flag = world.worldProvider instanceof WorldProviderTheEnd && block == Blocks.BEDROCK || block == Blocks.NETHERRACK || block == Blocks.MAGMA_BLOCK;
+            int i = (Integer) iblockdata.get(BlockFire.AGE);
+
+            if (!flag && world.isRaining() && this.a(world, blockposition) && random.nextFloat() < 0.2F + (float) i * 0.03F) {
+                fireExtinguished(world, blockposition); // CraftBukkit - extinguished by rain
+            } else {
+                int j = Math.min(15, i + random.nextInt(3) / 2);
+
+                if (i != j) {
+                    iblockdata = (IBlockData) iblockdata.set(BlockFire.AGE, j);
+                    world.setTypeAndData(blockposition, iblockdata, 4);
+                }
+
+                if (!flag) {
+                    world.getBlockTickList().a(blockposition, this, this.a((IWorldReader) world) + random.nextInt(10));
+                    if (!this.d(world, blockposition)) {
+                        if (!world.getType(blockposition.down()).q() || i > 3) {
+                            fireExtinguished(world, blockposition); // CraftBukkit
+                        }
+
+                        return;
+                    }
+
+                    if (i == 15 && random.nextInt(4) == 0 && !this.k(world.getType(blockposition.down()))) {
+                        fireExtinguished(world, blockposition); // CraftBukkit
+                        return;
+                    }
+                }
+
+                boolean flag1 = world.x(blockposition);
+                int k = flag1 ? -50 : 0;
+
+                // CraftBukkit start - add source blockposition to burn calls
+                this.a(world, blockposition.east(), 300 + k, random, i, blockposition);
+                this.a(world, blockposition.west(), 300 + k, random, i, blockposition);
+                this.a(world, blockposition.down(), 250 + k, random, i, blockposition);
+                this.a(world, blockposition.up(), 250 + k, random, i, blockposition);
+                this.a(world, blockposition.north(), 300 + k, random, i, blockposition);
+                this.a(world, blockposition.south(), 300 + k, random, i, blockposition);
+                // CraftBukkit end
+                BlockPosition.MutableBlockPosition blockposition_mutableblockposition = new BlockPosition.MutableBlockPosition();
+
+                for (int l = -1; l <= 1; ++l) {
+                    for (int i1 = -1; i1 <= 1; ++i1) {
+                        for (int j1 = -1; j1 <= 4; ++j1) {
+                            if (l != 0 || j1 != 0 || i1 != 0) {
+                                int k1 = 100;
+
+                                if (j1 > 1) {
+                                    k1 += (j1 - 1) * 100;
+                                }
+
+                                blockposition_mutableblockposition.g(blockposition).d(l, j1, i1);
+                                if (!world.isLoaded(blockposition_mutableblockposition)) continue; // Paper
+                                int l1 = this.a((IWorldReader) world, (BlockPosition) blockposition_mutableblockposition);
+
+                                if (l1 > 0) {
+                                    int i2 = (l1 + 40 + world.getDifficulty().a() * 7) / (i + 30);
+
+                                    if (flag1) {
+                                        i2 /= 2;
+                                    }
+
+                                    if (i2 > 0 && random.nextInt(k1) <= i2 && (!world.isRaining() || !this.a(world, (BlockPosition) blockposition_mutableblockposition))) {
+                                        int j2 = Math.min(15, i + random.nextInt(5) / 4);
+
+                                        // CraftBukkit start - Call to stop spread of fire
+                                        if (world.getType(blockposition_mutableblockposition) != Blocks.FIRE) {
+                                            if (CraftEventFactory.callBlockIgniteEvent(world, blockposition_mutableblockposition, blockposition).isCancelled()) {
+                                                continue;
+                                            }
+
+                                            CraftEventFactory.handleBlockSpreadEvent(world, blockposition, blockposition_mutableblockposition, (IBlockData) this.a((IBlockAccess) world, (BlockPosition) blockposition_mutableblockposition).set(BlockFire.AGE, j2), 3); // CraftBukkit
+                                        }
+                                        // CraftBukkit end
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+            }
+        }
+    }
+
+    protected boolean a(World world, BlockPosition blockposition) {
+        return world.isRainingAt(blockposition) || world.isRainingAt(blockposition.west()) || world.isRainingAt(blockposition.east()) || world.isRainingAt(blockposition.north()) || world.isRainingAt(blockposition.south());
+    }
+
+    private int f(Block block) {
+        return this.t.getInt(block);
+    }
+
+    private int g(Block block) {
+        return this.flameChances.getInt(block);
+    }
+
+    private void a(World world, BlockPosition blockposition, int i, Random random, int j, BlockPosition sourceposition) { // CraftBukkit add sourceposition
+        // Paper start
+        final IBlockData iblockdata = world.getTypeIfLoaded(blockposition);
+        if (iblockdata == null) return;
+        int k = this.f(iblockdata.getBlock());
+        // Paper end
+
+        if (random.nextInt(i) < k) {
+            //IBlockData iblockdata = world.getType(blockposition); // Paper
+
+            // CraftBukkit start
+            org.bukkit.block.Block theBlock = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
+            org.bukkit.block.Block sourceBlock = world.getWorld().getBlockAt(sourceposition.getX(), sourceposition.getY(), sourceposition.getZ());
+
+            BlockBurnEvent event = new BlockBurnEvent(theBlock, sourceBlock);
+            world.getServer().getPluginManager().callEvent(event);
+
+            if (event.isCancelled()) {
+                return;
+            }
+            // CraftBukkit end
+
+            if (random.nextInt(j + 10) < 5 && !world.isRainingAt(blockposition)) {
+                int l = Math.min(j + random.nextInt(5) / 4, 15);
+
+                world.setTypeAndData(blockposition, (IBlockData) this.a((IBlockAccess) world, blockposition).set(BlockFire.AGE, l), 3);
+            } else {
+                if(iblockdata.getBlock() != Blocks.TNT) world.setAir(blockposition); // Paper - TNTPrimeEvent - We might be cancelling it below, move the setAir down
+            }
+
+            Block block = iblockdata.getBlock();
+
+            if (block instanceof BlockTNT) {
+                // Paper start - TNTPrimeEvent
+                org.bukkit.block.Block tntBlock = MCUtil.toBukkitBlock(world, blockposition);
+                if (!new TNTPrimeEvent(tntBlock, TNTPrimeEvent.PrimeReason.FIRE, null).callEvent()) {
+                    return;
+                }
+                world.setAir(blockposition); // setair after non cancelled event, it would usually be air by now
+                // Paper end
+                ((BlockTNT) block).a(world, blockposition);
+            }
+        }
+
+    }
+
+    private boolean d(IBlockAccess iblockaccess, BlockPosition blockposition) {
+        EnumDirection[] aenumdirection = EnumDirection.values();
+        int i = aenumdirection.length;
+
+        for (int j = 0; j < i; ++j) {
+            EnumDirection enumdirection = aenumdirection[j];
+
+            if (this.k(iblockaccess.getType(blockposition.shift(enumdirection)))) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private int a(IWorldReader iworldreader, BlockPosition blockposition) {
+        if (!iworldreader.isEmpty(blockposition)) {
+            return 0;
+        } else {
+            int i = 0;
+            EnumDirection[] aenumdirection = EnumDirection.values();
+            int j = aenumdirection.length;
+
+            for (int k = 0; k < j; ++k) {
+                EnumDirection enumdirection = aenumdirection[k];
+
+                // Paper start
+                final IBlockData type = ((World)iworldreader).getTypeIfLoaded(blockposition.shift(enumdirection));
+                if (type == null) continue;
+                i = Math.max(this.g(type.getBlock()), i);
+                // Paper end
+            }
+
+            return i;
+        }
+    }
+
+    public boolean j() {
+        return false;
+    }
+
+    public boolean k(IBlockData iblockdata) {
+        return this.g(iblockdata.getBlock()) > 0;
+    }
+
+    public void onPlace(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1) {
+        if (iblockdata1.getBlock() != iblockdata.getBlock()) {
+            if (world.worldProvider.getDimensionManager() != DimensionManager.OVERWORLD && world.worldProvider.getDimensionManager() != DimensionManager.NETHER || !((BlockPortal) Blocks.NETHER_PORTAL).a((GeneratorAccess) world, blockposition)) {
+                if (!iblockdata.canPlace(world, blockposition)) {
+                    fireExtinguished(world, blockposition); // CraftBukkit - fuel block broke
+                } else {
+                    world.getBlockTickList().a(blockposition, this, this.a((IWorldReader) world) + world.random.nextInt(10));
+                }
+            }
+        }
+    }
+
+    public TextureType c() {
+        return TextureType.CUTOUT;
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockFire.AGE, BlockFire.NORTH, BlockFire.EAST, BlockFire.SOUTH, BlockFire.WEST, BlockFire.UPPER);
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return EnumBlockFaceShape.UNDEFINED;
+    }
+
+    public void a(Block block, int i, int j) {
+        this.flameChances.put(block, i);
+        this.t.put(block, j);
+    }
+
+    public static void d() {
+        BlockFire blockfire = (BlockFire) Blocks.FIRE;
+
+        blockfire.a(Blocks.OAK_PLANKS, 5, 20);
+        blockfire.a(Blocks.SPRUCE_PLANKS, 5, 20);
+        blockfire.a(Blocks.BIRCH_PLANKS, 5, 20);
+        blockfire.a(Blocks.JUNGLE_PLANKS, 5, 20);
+        blockfire.a(Blocks.ACACIA_PLANKS, 5, 20);
+        blockfire.a(Blocks.DARK_OAK_PLANKS, 5, 20);
+        blockfire.a(Blocks.OAK_SLAB, 5, 20);
+        blockfire.a(Blocks.SPRUCE_SLAB, 5, 20);
+        blockfire.a(Blocks.BIRCH_SLAB, 5, 20);
+        blockfire.a(Blocks.JUNGLE_SLAB, 5, 20);
+        blockfire.a(Blocks.ACACIA_SLAB, 5, 20);
+        blockfire.a(Blocks.DARK_OAK_SLAB, 5, 20);
+        blockfire.a(Blocks.OAK_FENCE_GATE, 5, 20);
+        blockfire.a(Blocks.SPRUCE_FENCE_GATE, 5, 20);
+        blockfire.a(Blocks.BIRCH_FENCE_GATE, 5, 20);
+        blockfire.a(Blocks.JUNGLE_FENCE_GATE, 5, 20);
+        blockfire.a(Blocks.DARK_OAK_FENCE_GATE, 5, 20);
+        blockfire.a(Blocks.ACACIA_FENCE_GATE, 5, 20);
+        blockfire.a(Blocks.OAK_FENCE, 5, 20);
+        blockfire.a(Blocks.SPRUCE_FENCE, 5, 20);
+        blockfire.a(Blocks.BIRCH_FENCE, 5, 20);
+        blockfire.a(Blocks.JUNGLE_FENCE, 5, 20);
+        blockfire.a(Blocks.DARK_OAK_FENCE, 5, 20);
+        blockfire.a(Blocks.ACACIA_FENCE, 5, 20);
+        blockfire.a(Blocks.OAK_STAIRS, 5, 20);
+        blockfire.a(Blocks.BIRCH_STAIRS, 5, 20);
+        blockfire.a(Blocks.SPRUCE_STAIRS, 5, 20);
+        blockfire.a(Blocks.JUNGLE_STAIRS, 5, 20);
+        blockfire.a(Blocks.ACACIA_STAIRS, 5, 20);
+        blockfire.a(Blocks.DARK_OAK_STAIRS, 5, 20);
+        blockfire.a(Blocks.OAK_LOG, 5, 5);
+        blockfire.a(Blocks.SPRUCE_LOG, 5, 5);
+        blockfire.a(Blocks.BIRCH_LOG, 5, 5);
+        blockfire.a(Blocks.JUNGLE_LOG, 5, 5);
+        blockfire.a(Blocks.ACACIA_LOG, 5, 5);
+        blockfire.a(Blocks.DARK_OAK_LOG, 5, 5);
+        blockfire.a(Blocks.STRIPPED_OAK_LOG, 5, 5);
+        blockfire.a(Blocks.STRIPPED_SPRUCE_LOG, 5, 5);
+        blockfire.a(Blocks.STRIPPED_BIRCH_LOG, 5, 5);
+        blockfire.a(Blocks.STRIPPED_JUNGLE_LOG, 5, 5);
+        blockfire.a(Blocks.STRIPPED_ACACIA_LOG, 5, 5);
+        blockfire.a(Blocks.STRIPPED_DARK_OAK_LOG, 5, 5);
+        blockfire.a(Blocks.STRIPPED_OAK_WOOD, 5, 5);
+        blockfire.a(Blocks.STRIPPED_SPRUCE_WOOD, 5, 5);
+        blockfire.a(Blocks.STRIPPED_BIRCH_WOOD, 5, 5);
+        blockfire.a(Blocks.STRIPPED_JUNGLE_WOOD, 5, 5);
+        blockfire.a(Blocks.STRIPPED_ACACIA_WOOD, 5, 5);
+        blockfire.a(Blocks.STRIPPED_DARK_OAK_WOOD, 5, 5);
+        blockfire.a(Blocks.OAK_WOOD, 5, 5);
+        blockfire.a(Blocks.SPRUCE_WOOD, 5, 5);
+        blockfire.a(Blocks.BIRCH_WOOD, 5, 5);
+        blockfire.a(Blocks.JUNGLE_WOOD, 5, 5);
+        blockfire.a(Blocks.ACACIA_WOOD, 5, 5);
+        blockfire.a(Blocks.DARK_OAK_WOOD, 5, 5);
+        blockfire.a(Blocks.OAK_LEAVES, 30, 60);
+        blockfire.a(Blocks.SPRUCE_LEAVES, 30, 60);
+        blockfire.a(Blocks.BIRCH_LEAVES, 30, 60);
+        blockfire.a(Blocks.JUNGLE_LEAVES, 30, 60);
+        blockfire.a(Blocks.ACACIA_LEAVES, 30, 60);
+        blockfire.a(Blocks.DARK_OAK_LEAVES, 30, 60);
+        blockfire.a(Blocks.BOOKSHELF, 30, 20);
+        blockfire.a(Blocks.TNT, 15, 100);
+        blockfire.a(Blocks.GRASS, 60, 100);
+        blockfire.a(Blocks.FERN, 60, 100);
+        blockfire.a(Blocks.DEAD_BUSH, 60, 100);
+        blockfire.a(Blocks.SUNFLOWER, 60, 100);
+        blockfire.a(Blocks.LILAC, 60, 100);
+        blockfire.a(Blocks.ROSE_BUSH, 60, 100);
+        blockfire.a(Blocks.PEONY, 60, 100);
+        blockfire.a(Blocks.TALL_GRASS, 60, 100);
+        blockfire.a(Blocks.LARGE_FERN, 60, 100);
+        blockfire.a(Blocks.DANDELION, 60, 100);
+        blockfire.a(Blocks.POPPY, 60, 100);
+        blockfire.a(Blocks.BLUE_ORCHID, 60, 100);
+        blockfire.a(Blocks.ALLIUM, 60, 100);
+        blockfire.a(Blocks.AZURE_BLUET, 60, 100);
+        blockfire.a(Blocks.RED_TULIP, 60, 100);
+        blockfire.a(Blocks.ORANGE_TULIP, 60, 100);
+        blockfire.a(Blocks.WHITE_TULIP, 60, 100);
+        blockfire.a(Blocks.PINK_TULIP, 60, 100);
+        blockfire.a(Blocks.OXEYE_DAISY, 60, 100);
+        blockfire.a(Blocks.WHITE_WOOL, 30, 60);
+        blockfire.a(Blocks.ORANGE_WOOL, 30, 60);
+        blockfire.a(Blocks.MAGENTA_WOOL, 30, 60);
+        blockfire.a(Blocks.LIGHT_BLUE_WOOL, 30, 60);
+        blockfire.a(Blocks.YELLOW_WOOL, 30, 60);
+        blockfire.a(Blocks.LIME_WOOL, 30, 60);
+        blockfire.a(Blocks.PINK_WOOL, 30, 60);
+        blockfire.a(Blocks.GRAY_WOOL, 30, 60);
+        blockfire.a(Blocks.LIGHT_GRAY_WOOL, 30, 60);
+        blockfire.a(Blocks.CYAN_WOOL, 30, 60);
+        blockfire.a(Blocks.PURPLE_WOOL, 30, 60);
+        blockfire.a(Blocks.BLUE_WOOL, 30, 60);
+        blockfire.a(Blocks.BROWN_WOOL, 30, 60);
+        blockfire.a(Blocks.GREEN_WOOL, 30, 60);
+        blockfire.a(Blocks.RED_WOOL, 30, 60);
+        blockfire.a(Blocks.BLACK_WOOL, 30, 60);
+        blockfire.a(Blocks.VINE, 15, 100);
+        blockfire.a(Blocks.COAL_BLOCK, 5, 5);
+        blockfire.a(Blocks.HAY_BLOCK, 60, 20);
+        blockfire.a(Blocks.WHITE_CARPET, 60, 20);
+        blockfire.a(Blocks.ORANGE_CARPET, 60, 20);
+        blockfire.a(Blocks.MAGENTA_CARPET, 60, 20);
+        blockfire.a(Blocks.LIGHT_BLUE_CARPET, 60, 20);
+        blockfire.a(Blocks.YELLOW_CARPET, 60, 20);
+        blockfire.a(Blocks.LIME_CARPET, 60, 20);
+        blockfire.a(Blocks.PINK_CARPET, 60, 20);
+        blockfire.a(Blocks.GRAY_CARPET, 60, 20);
+        blockfire.a(Blocks.LIGHT_GRAY_CARPET, 60, 20);
+        blockfire.a(Blocks.CYAN_CARPET, 60, 20);
+        blockfire.a(Blocks.PURPLE_CARPET, 60, 20);
+        blockfire.a(Blocks.BLUE_CARPET, 60, 20);
+        blockfire.a(Blocks.BROWN_CARPET, 60, 20);
+        blockfire.a(Blocks.GREEN_CARPET, 60, 20);
+        blockfire.a(Blocks.RED_CARPET, 60, 20);
+        blockfire.a(Blocks.BLACK_CARPET, 60, 20);
+        blockfire.a(Blocks.DRIED_KELP_BLOCK, 30, 60);
+    }
+
+    // CraftBukkit start
+    private void fireExtinguished(GeneratorAccess world, BlockPosition position) {
+        if (!CraftEventFactory.callBlockFadeEvent(world, position, Blocks.AIR.getBlockData()).isCancelled()) {
+            world.setAir(position);
+        }
+    }
+    // CraftBukkit end
+}

src/main/java/net/minecraft/server/BlockFluids.java

@@ -0,0 +1,186 @@
+package net.minecraft.server;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+
+public class BlockFluids extends Block implements IFluidSource {
+
+    public static final BlockStateInteger LEVEL = BlockProperties.ah;
+    protected final FluidTypeFlowing b;
+    private final List<Fluid> c;
+    private final Map<IBlockData, VoxelShape> o = Maps.newIdentityHashMap();
+
+    protected BlockFluids(FluidTypeFlowing fluidtypeflowing, Block.Info block_info) {
+        super(block_info);
+        this.b = fluidtypeflowing;
+        this.c = Lists.newArrayList();
+        this.c.add(fluidtypeflowing.a(false));
+
+        for (int i = 1; i < 8; ++i) {
+            this.c.add(fluidtypeflowing.a(8 - i, false));
+        }
+
+        this.c.add(fluidtypeflowing.a(8, true));
+        this.v((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockFluids.LEVEL, 0));
+    }
+
+    public void b(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        world.getFluid(blockposition).b(world, blockposition, random);
+    }
+
+    public boolean a_(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return false;
+    }
+
+    public boolean a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, PathMode pathmode) {
+        return !this.b.a(TagsFluid.LAVA);
+    }
+
+    public Fluid h(IBlockData iblockdata) {
+        int i = (Integer) iblockdata.get(BlockFluids.LEVEL);
+
+        return (Fluid) this.c.get(Math.min(i, 8));
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public boolean isCollidable(IBlockData iblockdata) {
+        return false;
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        Fluid fluid = iblockaccess.getFluid(blockposition.up());
+
+        return fluid.c().a((FluidType) this.b) ? VoxelShapes.b() : (VoxelShape) this.o.computeIfAbsent(iblockdata, (iblockdata1) -> {
+            Fluid fluid1 = iblockdata1.s();
+
+            return VoxelShapes.create(0.0D, 0.0D, 0.0D, 1.0D, (double) fluid1.getHeight(), 1.0D);
+        });
+    }
+
+    public EnumRenderType c(IBlockData iblockdata) {
+        return EnumRenderType.INVISIBLE;
+    }
+
+    public IMaterial getDropType(IBlockData iblockdata, World world, BlockPosition blockposition, int i) {
+        return Items.AIR;
+    }
+
+    public int a(IWorldReader iworldreader) {
+        return this.b.a(iworldreader);
+    }
+
+    public void onPlace(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1) {
+        if (this.a(world, blockposition, iblockdata)) {
+            world.getFluidTickList().a(blockposition, iblockdata.s().c(), this.getFlowSpeed(world, blockposition)); // Paper
+        }
+
+    }
+
+    // Paper start - Get flow speed. Throttle if its water and flowing adjacent to lava
+    public int getFlowSpeed(World world, BlockPosition blockposition) {
+        if (this.material == Material.WATER) {
+            if (
+                world.getMaterialIfLoaded(blockposition.north(1)) == Material.LAVA ||
+                world.getMaterialIfLoaded(blockposition.south(1)) == Material.LAVA ||
+                world.getMaterialIfLoaded(blockposition.west(1)) == Material.LAVA ||
+                world.getMaterialIfLoaded(blockposition.east(1)) == Material.LAVA
+            ) {
+                return world.paperConfig.waterOverLavaFlowSpeed;
+            }
+        }
+        return this.a(world);
+    }
+    // Paper end
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        if (iblockdata.s().d() || iblockdata1.s().d()) {
+            generatoraccess.getFluidTickList().a(blockposition, iblockdata.s().c(), this.a((IWorldReader) generatoraccess));
+        }
+
+        return super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
+    }
+
+    public void doPhysics(IBlockData iblockdata, World world, BlockPosition blockposition, Block block, BlockPosition blockposition1) {
+        if (this.a(world, blockposition, iblockdata)) {
+            world.getFluidTickList().a(blockposition, iblockdata.s().c(), this.getFlowSpeed(world, blockposition)); // Paper
+        }
+
+    }
+
+    public boolean a(World world, BlockPosition blockposition, IBlockData iblockdata) {
+        if (this.b.a(TagsFluid.LAVA)) {
+            boolean flag = false;
+            EnumDirection[] aenumdirection = EnumDirection.values();
+            int i = aenumdirection.length;
+
+            for (int j = 0; j < i; ++j) {
+                EnumDirection enumdirection = aenumdirection[j];
+
+                if (enumdirection != EnumDirection.DOWN && world.getFluid(blockposition.shift(enumdirection)).a(TagsFluid.WATER)) {
+                    flag = true;
+                    break;
+                }
+            }
+
+            if (flag) {
+                Fluid fluid = world.getFluid(blockposition);
+
+                if (fluid.d()) {
+                    // CraftBukkit start
+                    if (org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockFormEvent(world, blockposition, Blocks.OBSIDIAN.getBlockData())) {
+                        this.fizz(world, blockposition);
+                    }
+                    // CraftBukkit end
+                    return false;
+                }
+
+                if (fluid.getHeight() >= 0.44444445F) {
+                    // CraftBukkit start
+                    if (org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockFormEvent(world, blockposition, Blocks.COBBLESTONE.getBlockData())) {
+                        this.fizz(world, blockposition);
+                    }
+                    // CraftBukkit end
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    protected void fizz(GeneratorAccess generatoraccess, BlockPosition blockposition) {
+        double d0 = (double) blockposition.getX();
+        double d1 = (double) blockposition.getY();
+        double d2 = (double) blockposition.getZ();
+
+        generatoraccess.a((EntityHuman) null, blockposition, SoundEffects.BLOCK_LAVA_EXTINGUISH, SoundCategory.BLOCKS, 0.5F, 2.6F + (generatoraccess.m().nextFloat() - generatoraccess.m().nextFloat()) * 0.8F);
+
+        for (int i = 0; i < 8; ++i) {
+            generatoraccess.addParticle(Particles.F, d0 + Math.random(), d1 + 1.2D, d2 + Math.random(), 0.0D, 0.0D, 0.0D);
+        }
+
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockFluids.LEVEL);
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return EnumBlockFaceShape.UNDEFINED;
+    }
+
+    public FluidType removeFluid(GeneratorAccess generatoraccess, BlockPosition blockposition, IBlockData iblockdata) {
+        if ((Integer) iblockdata.get(BlockFluids.LEVEL) == 0) {
+            generatoraccess.setTypeAndData(blockposition, Blocks.AIR.getBlockData(), 11);
+            return this.b;
+        } else {
+            return FluidTypes.EMPTY;
+        }
+    }
+}

src/main/java/net/minecraft/server/BlockGrass.java

@@ -0,0 +1,81 @@
+package net.minecraft.server;
+
+import java.util.List;
+import java.util.Random;
+
+public class BlockGrass extends BlockDirtSnowSpreadable implements IBlockFragilePlantElement {
+
+    public BlockGrass(Block.Info block_info) {
+        super(block_info);
+    }
+
+    public boolean a(IBlockAccess iblockaccess, BlockPosition blockposition, IBlockData iblockdata, boolean flag) {
+        return iblockaccess.getType(blockposition.up()).isAir();
+    }
+
+    public boolean a(World world, Random random, BlockPosition blockposition, IBlockData iblockdata) {
+        return true;
+    }
+
+    public void b(World world, Random random, BlockPosition blockposition, IBlockData iblockdata) {
+        BlockPosition blockposition1 = blockposition.up();
+        IBlockData iblockdata1 = Blocks.GRASS.getBlockData();
+        int i = 0;
+
+        while (i < 128) {
+            BlockPosition blockposition2 = blockposition1;
+            int j = 0;
+
+            while (true) {
+                if (j < i / 16) {
+                    blockposition2 = blockposition2.a(random.nextInt(3) - 1, (random.nextInt(3) - 1) * random.nextInt(3) / 2, random.nextInt(3) - 1);
+                    if (world.getType(blockposition2.down()).getBlock() == this && !world.getType(blockposition2).k()) {
+                        ++j;
+                        continue;
+                    }
+                } else {
+                    IBlockData iblockdata2 = world.getType(blockposition2);
+
+                    if (iblockdata2.getBlock() == iblockdata1.getBlock() && random.nextInt(10) == 0) {
+                        ((IBlockFragilePlantElement) iblockdata1.getBlock()).b(world, random, blockposition2, iblockdata2);
+                    }
+
+                    if (iblockdata2.isAir()) {
+                        label38:
+                        {
+                            IBlockData iblockdata3;
+
+                            if (random.nextInt(8) == 0) {
+                                List<WorldGenFeatureCompositeFlower<?>> list = world.getBiome(blockposition2).f();
+
+                                if (list.isEmpty()) {
+                                    break label38;
+                                }
+
+                                iblockdata3 = ((WorldGenFeatureCompositeFlower) list.get(0)).a(random, blockposition2);
+                            } else {
+                                iblockdata3 = iblockdata1;
+                            }
+
+                            if (iblockdata3.canPlace(world, blockposition2)) {
+                                org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockGrowEvent(world, blockposition2, iblockdata3, 3); // CraftBukkit
+                            }
+                        }
+                    }
+                }
+
+                ++i;
+                break;
+            }
+        }
+
+    }
+
+    public boolean f(IBlockData iblockdata) {
+        return true;
+    }
+
+    public TextureType c() {
+        return TextureType.CUTOUT_MIPPED;
+    }
+}

src/main/java/net/minecraft/server/BlockIce.java

@@ -0,0 +1,72 @@
+package net.minecraft.server;
+
+import java.util.Random;
+import javax.annotation.Nullable;
+
+public class BlockIce extends BlockHalfTransparent {
+
+    public BlockIce(Block.Info block_info) {
+        super(block_info);
+    }
+
+    public int j(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return Blocks.WATER.getBlockData().b(iblockaccess, blockposition);
+    }
+
+    public TextureType c() {
+        return TextureType.TRANSLUCENT;
+    }
+
+    public void a(World world, EntityHuman entityhuman, BlockPosition blockposition, IBlockData iblockdata, @Nullable TileEntity tileentity, ItemStack itemstack) {
+        entityhuman.b(StatisticList.BLOCK_MINED.b(this));
+        entityhuman.applyExhaustion(0.005F);
+        if (this.X_() && EnchantmentManager.getEnchantmentLevel(Enchantments.SILK_TOUCH, itemstack) > 0) {
+            a(world, blockposition, this.t(iblockdata));
+        } else {
+            if (world.worldProvider.isNether()) {
+                world.setAir(blockposition);
+                return;
+            }
+
+            int i = EnchantmentManager.getEnchantmentLevel(Enchantments.LOOT_BONUS_BLOCKS, itemstack);
+
+            iblockdata.a(world, blockposition, i);
+            Material material = world.getType(blockposition.down()).getMaterial();
+
+            if (material.isSolid() || material.isLiquid()) {
+                world.setTypeUpdate(blockposition, Blocks.WATER.getBlockData());
+            }
+        }
+
+    }
+
+    public int a(IBlockData iblockdata, Random random) {
+        return 0;
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if (world.getBrightness(EnumSkyBlock.BLOCK, blockposition) > 11 - iblockdata.b(world, blockposition)) {
+            this.b(iblockdata, world, blockposition);
+        }
+
+    }
+
+    protected void b(IBlockData iblockdata, World world, BlockPosition blockposition) {
+        // CraftBukkit start
+        if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockFadeEvent(world, blockposition, world.worldProvider.isNether() ? Blocks.AIR.getBlockData() : Blocks.WATER.getBlockData()).isCancelled()) {
+            return;
+        }
+        // CraftBukkit end
+        if (world.worldProvider.isNether()) {
+            world.setAir(blockposition);
+        } else {
+            iblockdata.a(world, blockposition, 0);
+            world.setTypeUpdate(blockposition, Blocks.WATER.getBlockData());
+            world.a(blockposition, Blocks.WATER, blockposition);
+        }
+    }
+
+    public EnumPistonReaction getPushReaction(IBlockData iblockdata) {
+        return EnumPistonReaction.NORMAL;
+    }
+}

src/main/java/net/minecraft/server/BlockIceFrost.java

@@ -0,0 +1,128 @@
+package net.minecraft.server;
+
+import java.util.Random;
+
+public class BlockIceFrost extends BlockIce {
+
+    public static final BlockStateInteger a = BlockProperties.U;
+
+    public BlockIceFrost(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockIceFrost.a, 0));
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if (!world.paperConfig.frostedIceEnabled) return; // Paper - add ability to disable frosted ice
+        if ((random.nextInt(3) == 0 || this.a(world, blockposition, 4)) && world.getLightLevel(blockposition) > 11 - (Integer) iblockdata.get(BlockIceFrost.a) - iblockdata.b(world, blockposition) && this.c(iblockdata, world, blockposition)) {
+            BlockPosition.b blockposition_b = BlockPosition.b.r();
+            Throwable throwable = null;
+
+            try {
+                EnumDirection[] aenumdirection = EnumDirection.values();
+                int i = aenumdirection.length;
+
+                for (int j = 0; j < i; ++j) {
+                    EnumDirection enumdirection = aenumdirection[j];
+
+                    blockposition_b.g(blockposition).c(enumdirection);
+                    IBlockData iblockdata1 = world.getTypeIfLoaded(blockposition_b); // Paper - don't load chunks
+                    if (iblockdata1 == null) continue; // Paper
+
+                    if (iblockdata1.getBlock() == this && !this.c(iblockdata1, world, blockposition_b)) {
+                        world.getBlockTickList().a(blockposition_b, this, MathHelper.nextInt(random, world.paperConfig.frostedIceDelayMin, world.paperConfig.frostedIceDelayMax)); // Paper - use configurable min/max delay
+                    }
+                }
+            } catch (Throwable throwable1) {
+                throwable = throwable1;
+                throw throwable1;
+            } finally {
+                if (blockposition_b != null) {
+                    if (throwable != null) {
+                        try {
+                            blockposition_b.close();
+                        } catch (Throwable throwable2) {
+                            throwable.addSuppressed(throwable2);
+                        }
+                    } else {
+                        blockposition_b.close();
+                    }
+                }
+
+            }
+
+        } else {
+            world.getBlockTickList().a(blockposition, this, MathHelper.nextInt(random, world.paperConfig.frostedIceDelayMin, world.paperConfig.frostedIceDelayMax)); // Paper - use configurable min/max delay
+        }
+    }
+
+    private boolean c(IBlockData iblockdata, World world, BlockPosition blockposition) {
+        int i = (Integer) iblockdata.get(BlockIceFrost.a);
+
+        if (i < 3) {
+            world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockIceFrost.a, i + 1), 2);
+            return false;
+        } else {
+            this.b(iblockdata, world, blockposition);
+            return true;
+        }
+    }
+
+    public void doPhysics(IBlockData iblockdata, World world, BlockPosition blockposition, Block block, BlockPosition blockposition1) {
+        if (block == this && this.a(world, blockposition, 2)) {
+            this.b(iblockdata, world, blockposition);
+        }
+
+        super.doPhysics(iblockdata, world, blockposition, block, blockposition1);
+    }
+
+    private boolean a(IBlockAccess iblockaccess, BlockPosition blockposition, int i) {
+        int j = 0;
+        BlockPosition.b blockposition_b = BlockPosition.b.r();
+        Throwable throwable = null;
+
+        try {
+            EnumDirection[] aenumdirection = EnumDirection.values();
+            int k = aenumdirection.length;
+
+            for (int l = 0; l < k; ++l) {
+                EnumDirection enumdirection = aenumdirection[l];
+
+                blockposition_b.g(blockposition).c(enumdirection);
+                if (((World) iblockaccess).getBlockIfLoaded(blockposition_b) == this) { // Paper - don't load chunks
+                    ++j;
+                    if (j >= i) {
+                        boolean flag = false;
+
+                        return flag;
+                    }
+                }
+            }
+
+            return true;
+        } catch (Throwable throwable1) {
+            throwable = throwable1;
+            throw throwable1;
+        } finally {
+            if (blockposition_b != null) {
+                if (throwable != null) {
+                    try {
+                        blockposition_b.close();
+                    } catch (Throwable throwable2) {
+                        throwable.addSuppressed(throwable2);
+                    }
+                } else {
+                    blockposition_b.close();
+                }
+            }
+
+        }
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockIceFrost.a);
+    }
+
+    public ItemStack a(IBlockAccess iblockaccess, BlockPosition blockposition, IBlockData iblockdata) {
+        return ItemStack.a;
+    }
+}

src/main/java/net/minecraft/server/BlockJukeBox.java

@@ -0,0 +1,106 @@
+package net.minecraft.server;
+
+public class BlockJukeBox extends BlockTileEntity {
+
+    public static final BlockStateBoolean HAS_RECORD = BlockProperties.l;
+
+    protected BlockJukeBox(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockJukeBox.HAS_RECORD, false));
+    }
+
+    public boolean interact(IBlockData iblockdata, World world, BlockPosition blockposition, EntityHuman entityhuman, EnumHand enumhand, EnumDirection enumdirection, float f, float f1, float f2) {
+        if ((Boolean) iblockdata.get(BlockJukeBox.HAS_RECORD)) {
+            this.dropRecord(world, blockposition);
+            iblockdata = (IBlockData) iblockdata.set(BlockJukeBox.HAS_RECORD, false);
+            world.setTypeAndData(blockposition, iblockdata, 2);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public void a(GeneratorAccess generatoraccess, BlockPosition blockposition, IBlockData iblockdata, ItemStack itemstack) {
+        TileEntity tileentity = generatoraccess.getTileEntity(blockposition);
+
+        if (tileentity instanceof TileEntityJukeBox) {
+            // CraftBukkit start - There can only be one
+            itemstack = itemstack.cloneItemStack();
+            if (!itemstack.isEmpty()) {
+                itemstack.setCount(1);
+            }
+            ((TileEntityJukeBox) tileentity).setRecord(itemstack);
+            // CraftBukkit end
+            generatoraccess.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockJukeBox.HAS_RECORD, true), 2);
+        }
+    }
+
+    public void dropRecord(World world, BlockPosition blockposition) {
+        if (!world.isClientSide) {
+            TileEntity tileentity = world.getTileEntity(blockposition);
+
+            if (tileentity instanceof TileEntityJukeBox) {
+                TileEntityJukeBox tileentityjukebox = (TileEntityJukeBox) tileentity;
+                ItemStack itemstack = tileentityjukebox.getRecord();
+
+                if (!itemstack.isEmpty()) {
+                    world.triggerEffect(1010, blockposition, 0);
+                    world.a(blockposition, (SoundEffect) null);
+                    tileentityjukebox.setRecord(ItemStack.a);
+                    float f = 0.7F;
+                    double d0 = (double) (world.random.nextFloat() * 0.7F) + 0.15000000596046448D;
+                    double d1 = (double) (world.random.nextFloat() * 0.7F) + 0.06000000238418579D + 0.6D;
+                    double d2 = (double) (world.random.nextFloat() * 0.7F) + 0.15000000596046448D;
+                    ItemStack itemstack1 = itemstack.cloneItemStack();
+                    EntityItem entityitem = new EntityItem(world, (double) blockposition.getX() + d0, (double) blockposition.getY() + d1, (double) blockposition.getZ() + d2, itemstack1);
+
+                    entityitem.n();
+                    world.addEntity(entityitem);
+                }
+            }
+        }
+    }
+
+    public void remove(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1, boolean flag) {
+        if (iblockdata.getBlock() != iblockdata1.getBlock()) {
+            this.dropRecord(world, blockposition);
+            super.remove(iblockdata, world, blockposition, iblockdata1, flag);
+        }
+    }
+
+    public void dropNaturally(IBlockData iblockdata, World world, BlockPosition blockposition, float f, int i) {
+        if (!world.isClientSide) {
+            super.dropNaturally(iblockdata, world, blockposition, f, 0);
+        }
+    }
+
+    public TileEntity a(IBlockAccess iblockaccess) {
+        return new TileEntityJukeBox();
+    }
+
+    public boolean isComplexRedstone(IBlockData iblockdata) {
+        return true;
+    }
+
+    public int a(IBlockData iblockdata, World world, BlockPosition blockposition) {
+        TileEntity tileentity = world.getTileEntity(blockposition);
+
+        if (tileentity instanceof TileEntityJukeBox) {
+            Item item = ((TileEntityJukeBox) tileentity).getRecord().getItem();
+
+            if (item instanceof ItemRecord) {
+                return ((ItemRecord) item).d();
+            }
+        }
+
+        return 0;
+    }
+
+    public EnumRenderType c(IBlockData iblockdata) {
+        return EnumRenderType.MODEL;
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockJukeBox.HAS_RECORD);
+    }
+}

src/main/java/net/minecraft/server/BlockKelp.java

@@ -0,0 +1,97 @@
+package net.minecraft.server;
+
+import java.util.Random;
+import javax.annotation.Nullable;
+
+public class BlockKelp extends Block implements IFluidContainer {
+
+    public static final BlockStateInteger a = BlockProperties.Y;
+    protected static final VoxelShape b = Block.a(0.0D, 0.0D, 0.0D, 16.0D, 9.0D, 16.0D);
+
+    protected BlockKelp(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockKelp.a, 0));
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return BlockKelp.b;
+    }
+
+    @Nullable
+    public IBlockData getPlacedState(BlockActionContext blockactioncontext) {
+        Fluid fluid = blockactioncontext.getWorld().getFluid(blockactioncontext.getClickPosition());
+
+        return fluid.a(TagsFluid.WATER) && fluid.g() == 8 ? this.a((GeneratorAccess) blockactioncontext.getWorld()) : null;
+    }
+
+    public IBlockData a(GeneratorAccess generatoraccess) {
+        return (IBlockData) this.getBlockData().set(BlockKelp.a, generatoraccess.m().nextInt(25));
+    }
+
+    public TextureType c() {
+        return TextureType.CUTOUT;
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return EnumBlockFaceShape.UNDEFINED;
+    }
+
+    public Fluid h(IBlockData iblockdata) {
+        return FluidTypes.WATER.a(false);
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if (!iblockdata.canPlace(world, blockposition)) {
+            world.setAir(blockposition, true);
+        } else {
+            BlockPosition blockposition1 = blockposition.up();
+            IBlockData iblockdata1 = world.getType(blockposition1);
+
+            if (iblockdata1.getBlock() == Blocks.WATER && (Integer) iblockdata.get(BlockKelp.a) < 25 && random.nextDouble() < 0.14D) {
+                org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockSpreadEvent(world, blockposition, blockposition1, (IBlockData) iblockdata.a((IBlockState) BlockKelp.a)); // CraftBukkit
+            }
+
+        }
+    }
+
+    public boolean canPlace(IBlockData iblockdata, IWorldReader iworldreader, BlockPosition blockposition) {
+        BlockPosition blockposition1 = blockposition.down();
+        IBlockData iblockdata1 = iworldreader.getType(blockposition1);
+        Block block = iblockdata1.getBlock();
+
+        return block == Blocks.MAGMA_BLOCK ? false : block == this || block == Blocks.KELP_PLANT || Block.a(iblockdata1.getCollisionShape(iworldreader, blockposition1), EnumDirection.UP);
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        if (!iblockdata.canPlace(generatoraccess, blockposition)) {
+            if (enumdirection == EnumDirection.DOWN) {
+                return Blocks.AIR.getBlockData();
+            }
+
+            generatoraccess.getBlockTickList().a(blockposition, this, 1);
+        }
+
+        if (enumdirection == EnumDirection.UP && iblockdata1.getBlock() == this) {
+            return Blocks.KELP_PLANT.getBlockData();
+        } else {
+            generatoraccess.getFluidTickList().a(blockposition, FluidTypes.WATER, FluidTypes.WATER.a((IWorldReader) generatoraccess));
+            return super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
+        }
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockKelp.a);
+    }
+
+    public boolean canPlace(IBlockAccess iblockaccess, BlockPosition blockposition, IBlockData iblockdata, FluidType fluidtype) {
+        return false;
+    }
+
+    public boolean place(GeneratorAccess generatoraccess, BlockPosition blockposition, IBlockData iblockdata, Fluid fluid) {
+        return false;
+    }
+}

src/main/java/net/minecraft/server/BlockLeaves.java

@@ -0,0 +1,174 @@
+package net.minecraft.server;
+
+import java.util.Random;
+import javax.annotation.Nullable;
+
+import org.bukkit.event.block.LeavesDecayEvent; // CraftBukkit
+
+public class BlockLeaves extends Block {
+
+    public static final BlockStateInteger DISTANCE = BlockProperties.ab;
+    public static final BlockStateBoolean PERSISTENT = BlockProperties.s;
+    protected static boolean c;
+
+    public BlockLeaves(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockLeaves.DISTANCE, 7)).set(BlockLeaves.PERSISTENT, false));
+    }
+
+    public boolean isTicking(IBlockData iblockdata) {
+        return (Integer) iblockdata.get(BlockLeaves.DISTANCE) == 7 && !(Boolean) iblockdata.get(BlockLeaves.PERSISTENT);
+    }
+
+    public void b(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if (!(Boolean) iblockdata.get(BlockLeaves.PERSISTENT) && (Integer) iblockdata.get(BlockLeaves.DISTANCE) == 7) {
+            // CraftBukkit start
+            LeavesDecayEvent event = new LeavesDecayEvent(world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ()));
+            world.getServer().getPluginManager().callEvent(event);
+
+            if (event.isCancelled() || world.getType(blockposition).getBlock() != this) {
+                return;
+            }
+            // CraftBukkit end
+            iblockdata.a(world, blockposition, 0);
+            world.setAir(blockposition);
+        }
+
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        world.setTypeAndData(blockposition, a(iblockdata, (GeneratorAccess) world, blockposition), 3);
+    }
+
+    public int j(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return 1;
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        int i = w(iblockdata1) + 1;
+
+        if (i != 1 || (Integer) iblockdata.get(BlockLeaves.DISTANCE) != i) {
+            generatoraccess.getBlockTickList().a(blockposition, this, 1);
+        }
+
+        return iblockdata;
+    }
+
+    private static IBlockData a(IBlockData iblockdata, GeneratorAccess generatoraccess, BlockPosition blockposition) {
+        int i = 7;
+        BlockPosition.b blockposition_b = BlockPosition.b.r();
+        Throwable throwable = null;
+
+        try {
+            EnumDirection[] aenumdirection = EnumDirection.values();
+            int j = aenumdirection.length;
+
+            for (int k = 0; k < j; ++k) {
+                EnumDirection enumdirection = aenumdirection[k];
+
+                blockposition_b.g(blockposition).c(enumdirection);
+                i = Math.min(i, w(generatoraccess.getType(blockposition_b)) + 1);
+                if (i == 1) {
+                    break;
+                }
+            }
+        } catch (Throwable throwable1) {
+            throwable = throwable1;
+            throw throwable1;
+        } finally {
+            if (blockposition_b != null) {
+                if (throwable != null) {
+                    try {
+                        blockposition_b.close();
+                    } catch (Throwable throwable2) {
+                        throwable.addSuppressed(throwable2);
+                    }
+                } else {
+                    blockposition_b.close();
+                }
+            }
+
+        }
+
+        return (IBlockData) iblockdata.set(BlockLeaves.DISTANCE, i);
+    }
+
+    private static int w(IBlockData iblockdata) {
+        return TagsBlock.LOGS.isTagged(iblockdata.getBlock()) ? 0 : (iblockdata.getBlock() instanceof BlockLeaves ? (Integer) iblockdata.get(BlockLeaves.DISTANCE) : 7);
+    }
+
+    public int a(IBlockData iblockdata, Random random) {
+        return random.nextInt(20) == 0 ? 1 : 0;
+    }
+
+    public IMaterial getDropType(IBlockData iblockdata, World world, BlockPosition blockposition, int i) {
+        Block block = iblockdata.getBlock();
+
+        return block == Blocks.OAK_LEAVES ? Blocks.OAK_SAPLING : (block == Blocks.SPRUCE_LEAVES ? Blocks.SPRUCE_SAPLING : (block == Blocks.BIRCH_LEAVES ? Blocks.BIRCH_SAPLING : (block == Blocks.JUNGLE_LEAVES ? Blocks.JUNGLE_SAPLING : (block == Blocks.ACACIA_LEAVES ? Blocks.ACACIA_SAPLING : (block == Blocks.DARK_OAK_LEAVES ? Blocks.DARK_OAK_SAPLING : Blocks.OAK_SAPLING)))));
+    }
+
+    public void dropNaturally(IBlockData iblockdata, World world, BlockPosition blockposition, float f, int i) {
+        if (!world.isClientSide) {
+            int j = this.k(iblockdata);
+
+            if (i > 0) {
+                j -= 2 << i;
+                if (j < 10) {
+                    j = 10;
+                }
+            }
+
+            if (world.random.nextInt(j) == 0) {
+                a(world, blockposition, new ItemStack(this.getDropType(iblockdata, world, blockposition, i)));
+            }
+
+            j = 200;
+            if (i > 0) {
+                j -= 10 << i;
+                if (j < 40) {
+                    j = 40;
+                }
+            }
+
+            this.a(world, blockposition, iblockdata, j);
+        }
+
+    }
+
+    protected void a(World world, BlockPosition blockposition, IBlockData iblockdata, int i) {
+        if ((iblockdata.getBlock() == Blocks.OAK_LEAVES || iblockdata.getBlock() == Blocks.DARK_OAK_LEAVES) && world.random.nextInt(i) == 0) {
+            a(world, blockposition, new ItemStack(Items.APPLE));
+        }
+
+    }
+
+    protected int k(IBlockData iblockdata) {
+        return iblockdata.getBlock() == Blocks.JUNGLE_LEAVES ? 40 : 20;
+    }
+
+    public TextureType c() {
+        return BlockLeaves.c ? TextureType.CUTOUT_MIPPED : TextureType.SOLID;
+    }
+
+    public boolean q(IBlockData iblockdata) {
+        return false;
+    }
+
+    public void a(World world, EntityHuman entityhuman, BlockPosition blockposition, IBlockData iblockdata, @Nullable TileEntity tileentity, ItemStack itemstack) {
+        if (!world.isClientSide && itemstack.getItem() == Items.SHEARS) {
+            entityhuman.b(StatisticList.BLOCK_MINED.b(this));
+            entityhuman.applyExhaustion(0.005F);
+            a(world, blockposition, new ItemStack(this));
+        } else {
+            super.a(world, entityhuman, blockposition, iblockdata, tileentity, itemstack);
+        }
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockLeaves.DISTANCE, BlockLeaves.PERSISTENT);
+    }
+
+    public IBlockData getPlacedState(BlockActionContext blockactioncontext) {
+        return a((IBlockData) this.getBlockData().set(BlockLeaves.PERSISTENT, true), (GeneratorAccess) blockactioncontext.getWorld(), blockactioncontext.getClickPosition());
+    }
+}

src/main/java/net/minecraft/server/BlockLever.java

@@ -0,0 +1,138 @@
+package net.minecraft.server;
+
+import org.bukkit.event.block.BlockRedstoneEvent; // CraftBukkit
+
+public class BlockLever extends BlockAttachable {
+
+    public static final BlockStateBoolean POWERED = BlockProperties.t;
+    protected static final VoxelShape b = Block.a(5.0D, 4.0D, 10.0D, 11.0D, 12.0D, 16.0D);
+    protected static final VoxelShape c = Block.a(5.0D, 4.0D, 0.0D, 11.0D, 12.0D, 6.0D);
+    protected static final VoxelShape o = Block.a(10.0D, 4.0D, 5.0D, 16.0D, 12.0D, 11.0D);
+    protected static final VoxelShape p = Block.a(0.0D, 4.0D, 5.0D, 6.0D, 12.0D, 11.0D);
+    protected static final VoxelShape q = Block.a(5.0D, 0.0D, 4.0D, 11.0D, 6.0D, 12.0D);
+    protected static final VoxelShape r = Block.a(4.0D, 0.0D, 5.0D, 12.0D, 6.0D, 11.0D);
+    protected static final VoxelShape s = Block.a(5.0D, 10.0D, 4.0D, 11.0D, 16.0D, 12.0D);
+    protected static final VoxelShape t = Block.a(4.0D, 10.0D, 5.0D, 12.0D, 16.0D, 11.0D);
+
+    protected BlockLever(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockLever.FACING, EnumDirection.NORTH)).set(BlockLever.POWERED, false)).set(BlockLever.FACE, BlockPropertyAttachPosition.WALL));
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        switch ((BlockPropertyAttachPosition) iblockdata.get(BlockLever.FACE)) {
+        case FLOOR:
+            switch (((EnumDirection) iblockdata.get(BlockLever.FACING)).k()) {
+            case X:
+                return BlockLever.r;
+            case Z:
+            default:
+                return BlockLever.q;
+            }
+        case WALL:
+            switch ((EnumDirection) iblockdata.get(BlockLever.FACING)) {
+            case EAST:
+                return BlockLever.p;
+            case WEST:
+                return BlockLever.o;
+            case SOUTH:
+                return BlockLever.c;
+            case NORTH:
+            default:
+                return BlockLever.b;
+            }
+        case CEILING:
+        default:
+            switch (((EnumDirection) iblockdata.get(BlockLever.FACING)).k()) {
+            case X:
+                return BlockLever.t;
+            case Z:
+            default:
+                return BlockLever.s;
+            }
+        }
+    }
+
+    public boolean interact(IBlockData iblockdata, World world, BlockPosition blockposition, EntityHuman entityhuman, EnumHand enumhand, EnumDirection enumdirection, float f, float f1, float f2) {
+        iblockdata = (IBlockData) iblockdata.a((IBlockState) BlockLever.POWERED);
+        boolean flag = (Boolean) iblockdata.get(BlockLever.POWERED);
+
+        if (world.isClientSide) {
+            if (flag) {
+                a(iblockdata, world, blockposition, 1.0F);
+            }
+
+            return true;
+        } else {
+            // CraftBukkit start - Interact Lever
+            boolean powered = !flag; // Old powered state
+            org.bukkit.block.Block block = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
+            int old = (powered) ? 15 : 0;
+            int current = (!powered) ? 15 : 0;
+
+            BlockRedstoneEvent eventRedstone = new BlockRedstoneEvent(block, old, current);
+            world.getServer().getPluginManager().callEvent(eventRedstone);
+
+            if ((eventRedstone.getNewCurrent() > 0) != (!powered)) {
+                return true;
+            }
+            // CraftBukkit end
+
+            world.setTypeAndData(blockposition, iblockdata, 3);
+            float f3 = flag ? 0.6F : 0.5F;
+
+            world.a((EntityHuman) null, blockposition, SoundEffects.BLOCK_LEVER_CLICK, SoundCategory.BLOCKS, 0.3F, f3);
+            this.b(iblockdata, world, blockposition);
+            return true;
+        }
+    }
+
+    private static void a(IBlockData iblockdata, GeneratorAccess generatoraccess, BlockPosition blockposition, float f) {
+        EnumDirection enumdirection = ((EnumDirection) iblockdata.get(BlockLever.FACING)).opposite();
+        EnumDirection enumdirection1 = k(iblockdata).opposite();
+        double d0 = (double) blockposition.getX() + 0.5D + 0.1D * (double) enumdirection.getAdjacentX() + 0.2D * (double) enumdirection1.getAdjacentX();
+        double d1 = (double) blockposition.getY() + 0.5D + 0.1D * (double) enumdirection.getAdjacentY() + 0.2D * (double) enumdirection1.getAdjacentY();
+        double d2 = (double) blockposition.getZ() + 0.5D + 0.1D * (double) enumdirection.getAdjacentZ() + 0.2D * (double) enumdirection1.getAdjacentZ();
+
+        generatoraccess.addParticle(new ParticleParamRedstone(1.0F, 0.0F, 0.0F, f), d0, d1, d2, 0.0D, 0.0D, 0.0D);
+    }
+
+    public void remove(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1, boolean flag) {
+        if (!flag && iblockdata.getBlock() != iblockdata1.getBlock()) {
+            if ((Boolean) iblockdata.get(BlockLever.POWERED)) {
+                this.b(iblockdata, world, blockposition);
+            }
+
+            super.remove(iblockdata, world, blockposition, iblockdata1, flag);
+        }
+    }
+
+    public int a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, EnumDirection enumdirection) {
+        return (Boolean) iblockdata.get(BlockLever.POWERED) ? 15 : 0;
+    }
+
+    public int b(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, EnumDirection enumdirection) {
+        return (Boolean) iblockdata.get(BlockLever.POWERED) && k(iblockdata) == enumdirection ? 15 : 0;
+    }
+
+    public boolean isPowerSource(IBlockData iblockdata) {
+        return true;
+    }
+
+    private void b(IBlockData iblockdata, World world, BlockPosition blockposition) {
+        world.applyPhysics(blockposition, this);
+        world.applyPhysics(blockposition.shift(k(iblockdata).opposite()), this);
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockLever.FACE, BlockLever.FACING, BlockLever.POWERED);
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return EnumBlockFaceShape.UNDEFINED;
+    }
+}

src/main/java/net/minecraft/server/BlockMagma.java

@@ -0,0 +1,60 @@
+package net.minecraft.server;
+
+import java.util.Random;
+
+public class BlockMagma extends Block {
+
+    public BlockMagma(Block.Info block_info) {
+        super(block_info);
+    }
+
+    public void stepOn(World world, BlockPosition blockposition, Entity entity) {
+        if (!entity.isFireProof() && entity instanceof EntityLiving && !EnchantmentManager.i((EntityLiving) entity)) {
+            org.bukkit.craftbukkit.event.CraftEventFactory.blockDamage = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ()); // CraftBukkit
+            entity.damageEntity(DamageSource.HOT_FLOOR, 1.0F);
+            org.bukkit.craftbukkit.event.CraftEventFactory.blockDamage = null; // CraftBukkit
+        }
+
+        super.stepOn(world, blockposition, entity);
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        BlockBubbleColumn.a(world, blockposition.up(), true);
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        if (enumdirection == EnumDirection.UP && iblockdata1.getBlock() == Blocks.WATER) {
+            generatoraccess.getBlockTickList().a(blockposition, this, this.a((IWorldReader) generatoraccess));
+        }
+
+        return super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
+    }
+
+    public void b(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        BlockPosition blockposition1 = blockposition.up();
+
+        if (world.getFluid(blockposition).a(TagsFluid.WATER)) {
+            world.a((EntityHuman) null, blockposition, SoundEffects.BLOCK_FIRE_EXTINGUISH, SoundCategory.BLOCKS, 0.5F, 2.6F + (world.random.nextFloat() - world.random.nextFloat()) * 0.8F);
+            if (world instanceof WorldServer) {
+                ((WorldServer) world).a(Particles.F, (double) blockposition1.getX() + 0.5D, (double) blockposition1.getY() + 0.25D, (double) blockposition1.getZ() + 0.5D, 8, 0.5D, 0.25D, 0.5D, 0.0D);
+            }
+        }
+
+    }
+
+    public int a(IWorldReader iworldreader) {
+        return 20;
+    }
+
+    public void onPlace(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1) {
+        world.getBlockTickList().a(blockposition, this, this.a((IWorldReader) world));
+    }
+
+    public boolean a(IBlockData iblockdata, Entity entity) {
+        return entity.isFireProof();
+    }
+
+    public boolean e(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return true;
+    }
+}

src/main/java/net/minecraft/server/BlockMinecartDetector.java

@@ -0,0 +1,271 @@
+package net.minecraft.server;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+import java.util.function.Predicate;
+import javax.annotation.Nullable;
+
+import org.bukkit.event.block.BlockRedstoneEvent; // CraftBukkit
+
+public class BlockMinecartDetector extends BlockMinecartTrackAbstract {
+
+    public static final BlockStateEnum<BlockPropertyTrackPosition> SHAPE = BlockProperties.S;
+    public static final BlockStateBoolean POWERED = BlockProperties.t;
+
+    public BlockMinecartDetector(Block.Info block_info) {
+        super(true, block_info);
+        this.v((IBlockData) ((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockMinecartDetector.POWERED, false)).set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.NORTH_SOUTH));
+    }
+
+    public int a(IWorldReader iworldreader) {
+        return 20;
+    }
+
+    public boolean isPowerSource(IBlockData iblockdata) {
+        return true;
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
+        if (!world.isClientSide) {
+            if (!(Boolean) iblockdata.get(BlockMinecartDetector.POWERED)) {
+                this.a(world, blockposition, iblockdata);
+            }
+        }
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if (!world.isClientSide && (Boolean) iblockdata.get(BlockMinecartDetector.POWERED)) {
+            this.a(world, blockposition, iblockdata);
+        }
+    }
+
+    public int a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, EnumDirection enumdirection) {
+        return (Boolean) iblockdata.get(BlockMinecartDetector.POWERED) ? 15 : 0;
+    }
+
+    public int b(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, EnumDirection enumdirection) {
+        return !(Boolean) iblockdata.get(BlockMinecartDetector.POWERED) ? 0 : (enumdirection == EnumDirection.UP ? 15 : 0);
+    }
+
+    private void a(World world, BlockPosition blockposition, IBlockData iblockdata) {
+        boolean flag = (Boolean) iblockdata.get(BlockMinecartDetector.POWERED);
+        boolean flag1 = false;
+        List<EntityMinecartAbstract> list = this.a(world, blockposition, EntityMinecartAbstract.class, (Predicate) null);
+
+        if (!list.isEmpty()) {
+            flag1 = true;
+        }
+
+        // CraftBukkit start
+        if (flag != flag1) {
+            org.bukkit.block.Block block = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
+
+            BlockRedstoneEvent eventRedstone = new BlockRedstoneEvent(block, flag ? 15 : 0, flag1 ? 15 : 0);
+            world.getServer().getPluginManager().callEvent(eventRedstone);
+
+            flag1 = eventRedstone.getNewCurrent() > 0;
+        }
+        // CraftBukkit end
+
+        if (flag1 && !flag) {
+            world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockMinecartDetector.POWERED, true), 3);
+            this.b(world, blockposition, iblockdata, true);
+            world.applyPhysics(blockposition, this);
+            world.applyPhysics(blockposition.down(), this);
+            world.a(blockposition, blockposition);
+        }
+
+        if (!flag1 && flag) {
+            world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockMinecartDetector.POWERED, false), 3);
+            this.b(world, blockposition, iblockdata, false);
+            world.applyPhysics(blockposition, this);
+            world.applyPhysics(blockposition.down(), this);
+            world.a(blockposition, blockposition);
+        }
+
+        if (flag1) {
+            world.getBlockTickList().a(blockposition, this, this.a((IWorldReader) world));
+        }
+
+        world.updateAdjacentComparators(blockposition, this);
+    }
+
+    protected void b(World world, BlockPosition blockposition, IBlockData iblockdata, boolean flag) {
+        MinecartTrackLogic minecarttracklogic = new MinecartTrackLogic(world, blockposition, iblockdata);
+        List<BlockPosition> list = minecarttracklogic.a();
+        Iterator iterator = list.iterator();
+
+        while (iterator.hasNext()) {
+            BlockPosition blockposition1 = (BlockPosition) iterator.next();
+            IBlockData iblockdata1 = world.getType(blockposition1);
+
+            iblockdata1.doPhysics(world, blockposition1, iblockdata1.getBlock(), blockposition);
+        }
+
+    }
+
+    public void onPlace(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1) {
+        if (iblockdata1.getBlock() != iblockdata.getBlock()) {
+            super.onPlace(iblockdata, world, blockposition, iblockdata1);
+            this.a(world, blockposition, iblockdata);
+        }
+    }
+
+    public IBlockState<BlockPropertyTrackPosition> e() {
+        return BlockMinecartDetector.SHAPE;
+    }
+
+    public boolean isComplexRedstone(IBlockData iblockdata) {
+        return true;
+    }
+
+    public int a(IBlockData iblockdata, World world, BlockPosition blockposition) {
+        if ((Boolean) iblockdata.get(BlockMinecartDetector.POWERED)) {
+            List<EntityMinecartCommandBlock> list = this.a(world, blockposition, EntityMinecartCommandBlock.class, (Predicate) null);
+
+            if (!list.isEmpty()) {
+                return ((EntityMinecartCommandBlock) list.get(0)).getCommandBlock().i();
+            }
+
+            List<EntityMinecartAbstract> list1 = this.a(world, blockposition, EntityMinecartAbstract.class, IEntitySelector.d);
+
+            if (!list1.isEmpty()) {
+                return Container.b((IInventory) list1.get(0));
+            }
+        }
+
+        return 0;
+    }
+
+    protected <T extends EntityMinecartAbstract> List<T> a(World world, BlockPosition blockposition, Class<T> oclass, @Nullable Predicate<Entity> predicate) {
+        return world.a(oclass, this.a(blockposition), predicate);
+    }
+
+    private AxisAlignedBB a(BlockPosition blockposition) {
+        float f = 0.2F;
+
+        return new AxisAlignedBB((double) ((float) blockposition.getX() + 0.2F), (double) blockposition.getY(), (double) ((float) blockposition.getZ() + 0.2F), (double) ((float) (blockposition.getX() + 1) - 0.2F), (double) ((float) (blockposition.getY() + 1) - 0.2F), (double) ((float) (blockposition.getZ() + 1) - 0.2F));
+    }
+
+    public IBlockData a(IBlockData iblockdata, EnumBlockRotation enumblockrotation) {
+        switch (enumblockrotation) {
+        case CLOCKWISE_180:
+            switch ((BlockPropertyTrackPosition) iblockdata.get(BlockMinecartDetector.SHAPE)) {
+            case ASCENDING_EAST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.ASCENDING_WEST);
+            case ASCENDING_WEST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.ASCENDING_EAST);
+            case ASCENDING_NORTH:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.ASCENDING_SOUTH);
+            case ASCENDING_SOUTH:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.ASCENDING_NORTH);
+            case SOUTH_EAST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.NORTH_WEST);
+            case SOUTH_WEST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.NORTH_EAST);
+            case NORTH_WEST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.SOUTH_EAST);
+            case NORTH_EAST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.SOUTH_WEST);
+            }
+        case COUNTERCLOCKWISE_90:
+            switch ((BlockPropertyTrackPosition) iblockdata.get(BlockMinecartDetector.SHAPE)) {
+            case ASCENDING_EAST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.ASCENDING_NORTH);
+            case ASCENDING_WEST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.ASCENDING_SOUTH);
+            case ASCENDING_NORTH:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.ASCENDING_WEST);
+            case ASCENDING_SOUTH:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.ASCENDING_EAST);
+            case SOUTH_EAST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.NORTH_EAST);
+            case SOUTH_WEST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.SOUTH_EAST);
+            case NORTH_WEST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.SOUTH_WEST);
+            case NORTH_EAST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.NORTH_WEST);
+            case NORTH_SOUTH:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.EAST_WEST);
+            case EAST_WEST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.NORTH_SOUTH);
+            }
+        case CLOCKWISE_90:
+            switch ((BlockPropertyTrackPosition) iblockdata.get(BlockMinecartDetector.SHAPE)) {
+            case ASCENDING_EAST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.ASCENDING_SOUTH);
+            case ASCENDING_WEST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.ASCENDING_NORTH);
+            case ASCENDING_NORTH:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.ASCENDING_EAST);
+            case ASCENDING_SOUTH:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.ASCENDING_WEST);
+            case SOUTH_EAST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.SOUTH_WEST);
+            case SOUTH_WEST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.NORTH_WEST);
+            case NORTH_WEST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.NORTH_EAST);
+            case NORTH_EAST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.SOUTH_EAST);
+            case NORTH_SOUTH:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.EAST_WEST);
+            case EAST_WEST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.NORTH_SOUTH);
+            }
+        default:
+            return iblockdata;
+        }
+    }
+
+    public IBlockData a(IBlockData iblockdata, EnumBlockMirror enumblockmirror) {
+        BlockPropertyTrackPosition blockpropertytrackposition = (BlockPropertyTrackPosition) iblockdata.get(BlockMinecartDetector.SHAPE);
+
+        switch (enumblockmirror) {
+        case LEFT_RIGHT:
+            switch (blockpropertytrackposition) {
+            case ASCENDING_NORTH:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.ASCENDING_SOUTH);
+            case ASCENDING_SOUTH:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.ASCENDING_NORTH);
+            case SOUTH_EAST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.NORTH_EAST);
+            case SOUTH_WEST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.NORTH_WEST);
+            case NORTH_WEST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.SOUTH_WEST);
+            case NORTH_EAST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.SOUTH_EAST);
+            default:
+                return super.a(iblockdata, enumblockmirror);
+            }
+        case FRONT_BACK:
+            switch (blockpropertytrackposition) {
+            case ASCENDING_EAST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.ASCENDING_WEST);
+            case ASCENDING_WEST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.ASCENDING_EAST);
+            case ASCENDING_NORTH:
+            case ASCENDING_SOUTH:
+            default:
+                break;
+            case SOUTH_EAST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.SOUTH_WEST);
+            case SOUTH_WEST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.SOUTH_EAST);
+            case NORTH_WEST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.NORTH_EAST);
+            case NORTH_EAST:
+                return (IBlockData) iblockdata.set(BlockMinecartDetector.SHAPE, BlockPropertyTrackPosition.NORTH_WEST);
+            }
+        }
+
+        return super.a(iblockdata, enumblockmirror);
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockMinecartDetector.SHAPE, BlockMinecartDetector.POWERED);
+    }
+}

src/main/java/net/minecraft/server/BlockMobSpawner.java

@@ -0,0 +1,45 @@
+package net.minecraft.server;
+
+public class BlockMobSpawner extends BlockTileEntity {
+
+    protected BlockMobSpawner(Block.Info block_info) {
+        super(block_info);
+    }
+
+    public TileEntity a(IBlockAccess iblockaccess) {
+        return new TileEntityMobSpawner();
+    }
+
+    public IMaterial getDropType(IBlockData iblockdata, World world, BlockPosition blockposition, int i) {
+        return Items.AIR;
+    }
+
+    public void dropNaturally(IBlockData iblockdata, World world, BlockPosition blockposition, float f, int i) {
+        super.dropNaturally(iblockdata, world, blockposition, f, i);
+        /* CraftBukkit start - Delegate to getExpDrop
+        int j = 15 + world.random.nextInt(15) + world.random.nextInt(15);
+
+        this.dropExperience(world, blockposition, j);
+        */
+    }
+
+    @Override
+    public int getExpDrop(IBlockData iblockdata, World world, BlockPosition blockposition, int enchantmentLevel) {
+        int j = 15 + world.random.nextInt(15) + world.random.nextInt(15);
+
+        return j;
+        // CraftBukkit end
+    }
+
+    public EnumRenderType c(IBlockData iblockdata) {
+        return EnumRenderType.MODEL;
+    }
+
+    public TextureType c() {
+        return TextureType.CUTOUT;
+    }
+
+    public ItemStack a(IBlockAccess iblockaccess, BlockPosition blockposition, IBlockData iblockdata) {
+        return ItemStack.a;
+    }
+}

src/main/java/net/minecraft/server/BlockMonsterEggs.java

@@ -0,0 +1,50 @@
+package net.minecraft.server;
+
+import com.google.common.collect.Maps;
+import java.util.Map;
+import java.util.Random;
+
+import org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason; // CraftBukkit
+
+public class BlockMonsterEggs extends Block {
+
+    private final Block a;
+    private static final Map<Block, Block> b = Maps.newIdentityHashMap();
+
+    public BlockMonsterEggs(Block block, Block.Info block_info) {
+        super(block_info);
+        this.a = block;
+        BlockMonsterEggs.b.put(block, this);
+    }
+
+    public int a(IBlockData iblockdata, Random random) {
+        return 0;
+    }
+
+    public Block d() {
+        return this.a;
+    }
+
+    public static boolean k(IBlockData iblockdata) {
+        return BlockMonsterEggs.b.containsKey(iblockdata.getBlock());
+    }
+
+    protected ItemStack t(IBlockData iblockdata) {
+        return new ItemStack(this.a);
+    }
+
+    public void dropNaturally(IBlockData iblockdata, World world, BlockPosition blockposition, float f, int i) {
+        if (!world.isClientSide && world.getGameRules().getBoolean("doTileDrops")) {
+            EntitySilverfish entitysilverfish = EntityTypes.SILVERFISH.create(world); // Paper
+
+            entitysilverfish.setPositionRotation((double) blockposition.getX() + 0.5D, (double) blockposition.getY(), (double) blockposition.getZ() + 0.5D, 0.0F, 0.0F);
+            world.addEntity(entitysilverfish, SpawnReason.SILVERFISH_BLOCK); // CraftBukkit - add SpawnReason
+            entitysilverfish.doSpawnEffect();
+        }
+
+    }
+
+    public static IBlockData f(Block block) {
+        return ((Block) BlockMonsterEggs.b.get(block)).getBlockData();
+    }
+}

src/main/java/net/minecraft/server/BlockMushroom.java

@@ -0,0 +1,103 @@
+package net.minecraft.server;
+
+import java.util.Iterator;
+import java.util.Random;
+
+// CraftBukkit start
+import org.bukkit.TreeType;
+// CraftBukkit end
+
+public class BlockMushroom extends BlockPlant implements IBlockFragilePlantElement {
+
+    protected static final VoxelShape a = Block.a(5.0D, 0.0D, 5.0D, 11.0D, 6.0D, 11.0D);
+
+    public BlockMushroom(Block.Info block_info) {
+        super(block_info);
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return BlockMushroom.a;
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if (random.nextInt(Math.max(1, (int) (100.0F / world.spigotConfig.mushroomModifier) * 25)) == 0) { // Spigot
+            int i = 5;
+            boolean flag = true;
+            Iterator iterator = BlockPosition.b(blockposition.a(-4, -1, -4), blockposition.a(4, 1, 4)).iterator();
+
+            while (iterator.hasNext()) {
+                BlockPosition blockposition1 = (BlockPosition) iterator.next();
+
+                if (world.getType(blockposition1).getBlock() == this) {
+                    --i;
+                    if (i <= 0) {
+                        return;
+                    }
+                }
+            }
+
+            BlockPosition blockposition2 = blockposition.a(random.nextInt(3) - 1, random.nextInt(2) - random.nextInt(2), random.nextInt(3) - 1);
+
+            for (int j = 0; j < 4; ++j) {
+                if (world.isEmpty(blockposition2) && iblockdata.canPlace(world, blockposition2)) {
+                    blockposition = blockposition2;
+                }
+
+                blockposition2 = blockposition.a(random.nextInt(3) - 1, random.nextInt(2) - random.nextInt(2), random.nextInt(3) - 1);
+            }
+
+            if (world.isEmpty(blockposition2) && iblockdata.canPlace(world, blockposition2)) {
+                org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockSpreadEvent(world, blockposition, blockposition2, iblockdata, 2); // CraftBukkit
+            }
+        }
+
+    }
+
+    protected boolean b(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return iblockdata.f(iblockaccess, blockposition);
+    }
+
+    public boolean canPlace(IBlockData iblockdata, IWorldReader iworldreader, BlockPosition blockposition) {
+        BlockPosition blockposition1 = blockposition.down();
+        IBlockData iblockdata1 = iworldreader.getType(blockposition1);
+        Block block = iblockdata1.getBlock();
+
+        return block != Blocks.MYCELIUM && block != Blocks.PODZOL ? iworldreader.getLightLevel(blockposition, 0) < 13 && this.b(iblockdata1, (IBlockAccess) iworldreader, blockposition1) : true;
+    }
+
+    public boolean a(GeneratorAccess generatoraccess, BlockPosition blockposition, IBlockData iblockdata, Random random) {
+        generatoraccess.setAir(blockposition);
+        WorldGenerator<WorldGenFeatureEmptyConfiguration> worldgenerator = null;
+
+        if (this == Blocks.BROWN_MUSHROOM) {
+            BlockSapling.treeType = TreeType.BROWN_MUSHROOM; // CraftBukkit
+            worldgenerator = WorldGenerator.U;
+        } else if (this == Blocks.RED_MUSHROOM) {
+            BlockSapling.treeType = TreeType.RED_MUSHROOM; // CraftBukkit
+            worldgenerator = WorldGenerator.T;
+        }
+
+        if (worldgenerator != null && worldgenerator.generate(generatoraccess, generatoraccess.getChunkProvider().getChunkGenerator(), random, blockposition, WorldGenFeatureConfiguration.e)) {
+            return true;
+        } else {
+            generatoraccess.setTypeAndData(blockposition, iblockdata, 3);
+            return false;
+        }
+    }
+
+    public boolean a(IBlockAccess iblockaccess, BlockPosition blockposition, IBlockData iblockdata, boolean flag) {
+        return true;
+    }
+
+    public boolean a(World world, Random random, BlockPosition blockposition, IBlockData iblockdata) {
+        return (double) random.nextFloat() < 0.4D;
+    }
+
+    public void b(World world, Random random, BlockPosition blockposition, IBlockData iblockdata) {
+        this.a((GeneratorAccess) world, blockposition, iblockdata, random);
+    }
+
+    public boolean e(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return true;
+    }
+}

src/main/java/net/minecraft/server/BlockNetherWart.java

@@ -0,0 +1,63 @@
+package net.minecraft.server;
+
+import java.util.Random;
+
+public class BlockNetherWart extends BlockPlant {
+
+    public static final BlockStateInteger AGE = BlockProperties.U;
+    private static final VoxelShape[] b = new VoxelShape[] { Block.a(0.0D, 0.0D, 0.0D, 16.0D, 5.0D, 16.0D), Block.a(0.0D, 0.0D, 0.0D, 16.0D, 8.0D, 16.0D), Block.a(0.0D, 0.0D, 0.0D, 16.0D, 11.0D, 16.0D), Block.a(0.0D, 0.0D, 0.0D, 16.0D, 14.0D, 16.0D)};
+
+    protected BlockNetherWart(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockNetherWart.AGE, 0));
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return BlockNetherWart.b[(Integer) iblockdata.get(BlockNetherWart.AGE)];
+    }
+
+    protected boolean b(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return iblockdata.getBlock() == Blocks.SOUL_SAND;
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        int i = (Integer) iblockdata.get(BlockNetherWart.AGE);
+
+        if (i < 3 && random.nextInt(Math.max(1, (int) (100.0F / world.spigotConfig.wartModifier) * 10)) == 0) { // Spigot
+            iblockdata = (IBlockData) iblockdata.set(BlockNetherWart.AGE, i + 1);
+            org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockGrowEvent(world, blockposition, iblockdata, 2); // CraftBukkit
+        }
+
+        super.a(iblockdata, world, blockposition, random);
+    }
+
+    public void dropNaturally(IBlockData iblockdata, World world, BlockPosition blockposition, float f, int i) {
+        if (!world.isClientSide) {
+            int j = 1;
+
+            if ((Integer) iblockdata.get(BlockNetherWart.AGE) >= 3) {
+                j = 2 + world.random.nextInt(3);
+                if (i > 0) {
+                    j += world.random.nextInt(i + 1);
+                }
+            }
+
+            for (int k = 0; k < j; ++k) {
+                a(world, blockposition, new ItemStack(Items.NETHER_WART));
+            }
+
+        }
+    }
+
+    public IMaterial getDropType(IBlockData iblockdata, World world, BlockPosition blockposition, int i) {
+        return Items.AIR;
+    }
+
+    public ItemStack a(IBlockAccess iblockaccess, BlockPosition blockposition, IBlockData iblockdata) {
+        return new ItemStack(Items.NETHER_WART);
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockNetherWart.AGE);
+    }
+}

src/main/java/net/minecraft/server/BlockNote.java

@@ -0,0 +1,78 @@
+package net.minecraft.server;
+
+public class BlockNote extends Block {
+
+    public static final BlockStateEnum<BlockPropertyInstrument> INSTRUMENT = BlockProperties.as;
+    public static final BlockStateBoolean POWERED = BlockProperties.t;
+    public static final BlockStateInteger NOTE = BlockProperties.aj;
+
+    public BlockNote(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockNote.INSTRUMENT, BlockPropertyInstrument.HARP)).set(BlockNote.NOTE, 0)).set(BlockNote.POWERED, false));
+    }
+
+    public IBlockData getPlacedState(BlockActionContext blockactioncontext) {
+        return (IBlockData) this.getBlockData().set(BlockNote.INSTRUMENT, BlockPropertyInstrument.a(blockactioncontext.getWorld().getType(blockactioncontext.getClickPosition().down())));
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        return enumdirection == EnumDirection.DOWN ? (IBlockData) iblockdata.set(BlockNote.INSTRUMENT, BlockPropertyInstrument.a(iblockdata1)) : super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
+    }
+
+    public void doPhysics(IBlockData iblockdata, World world, BlockPosition blockposition, Block block, BlockPosition blockposition1) {
+        boolean flag = world.isBlockIndirectlyPowered(blockposition);
+
+        if (flag != (Boolean) iblockdata.get(BlockNote.POWERED)) {
+            if (flag) {
+                this.play(world, blockposition, iblockdata); // CraftBukkit
+            }
+
+            world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockNote.POWERED, flag), 3);
+        }
+
+    }
+
+    private void play(World world, BlockPosition blockposition, IBlockData data) { // CraftBukkit
+        if (world.getType(blockposition.up()).isAir()) {
+            // CraftBukkit start
+            org.bukkit.event.block.NotePlayEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callNotePlayEvent(world, blockposition, data.get(BlockNote.INSTRUMENT), data.get(BlockNote.NOTE));
+            if (!event.isCancelled()) {
+                world.playBlockAction(blockposition, this, 0, 0);
+            }
+            // CraftBukkit end
+        }
+
+    }
+
+    public boolean interact(IBlockData iblockdata, World world, BlockPosition blockposition, EntityHuman entityhuman, EnumHand enumhand, EnumDirection enumdirection, float f, float f1, float f2) {
+        if (world.isClientSide) {
+            return true;
+        } else {
+            iblockdata = (IBlockData) iblockdata.a((IBlockState) BlockNote.NOTE);
+            world.setTypeAndData(blockposition, iblockdata, 3);
+            this.play(world, blockposition, iblockdata); // CraftBukkit
+            entityhuman.a(StatisticList.TUNE_NOTEBLOCK);
+            return true;
+        }
+    }
+
+    public void attack(IBlockData iblockdata, World world, BlockPosition blockposition, EntityHuman entityhuman) {
+        if (!world.isClientSide) {
+            this.play(world, blockposition, iblockdata); // CraftBukkit
+            entityhuman.a(StatisticList.PLAY_NOTEBLOCK);
+        }
+    }
+
+    public boolean a(IBlockData iblockdata, World world, BlockPosition blockposition, int i, int j) {
+        int k = (Integer) iblockdata.get(BlockNote.NOTE);
+        float f = (float) Math.pow(2.0D, (double) (k - 12) / 12.0D);
+
+        world.a((EntityHuman) null, blockposition, ((BlockPropertyInstrument) iblockdata.get(BlockNote.INSTRUMENT)).a(), SoundCategory.RECORDS, 3.0F, f);
+        world.addParticle(Particles.I, (double) blockposition.getX() + 0.5D, (double) blockposition.getY() + 1.2D, (double) blockposition.getZ() + 0.5D, (double) k / 24.0D, 0.0D, 0.0D);
+        return true;
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockNote.INSTRUMENT, BlockNote.POWERED, BlockNote.NOTE);
+    }
+}

src/main/java/net/minecraft/server/BlockObserver.java

@@ -0,0 +1,108 @@
+package net.minecraft.server;
+
+import java.util.Random;
+
+import org.bukkit.craftbukkit.event.CraftEventFactory; // CraftBukkit
+
+public class BlockObserver extends BlockDirectional {
+
+    public static final BlockStateBoolean b = BlockProperties.t;
+
+    public BlockObserver(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockObserver.FACING, EnumDirection.SOUTH)).set(BlockObserver.b, false));
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockObserver.FACING, BlockObserver.b);
+    }
+
+    public IBlockData a(IBlockData iblockdata, EnumBlockRotation enumblockrotation) {
+        return (IBlockData) iblockdata.set(BlockObserver.FACING, enumblockrotation.a((EnumDirection) iblockdata.get(BlockObserver.FACING)));
+    }
+
+    public IBlockData a(IBlockData iblockdata, EnumBlockMirror enumblockmirror) {
+        return iblockdata.a(enumblockmirror.a((EnumDirection) iblockdata.get(BlockObserver.FACING)));
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if ((Boolean) iblockdata.get(BlockObserver.b)) {
+            // CraftBukkit start
+            if (CraftEventFactory.callRedstoneChange(world, blockposition, 15, 0).getNewCurrent() != 0) {
+                return;
+            }
+            // CraftBukkit end
+            world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockObserver.b, false), 2);
+        } else {
+            // CraftBukkit start
+            if (CraftEventFactory.callRedstoneChange(world, blockposition, 0, 15).getNewCurrent() != 15) {
+                return;
+            }
+            // CraftBukkit end
+            world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockObserver.b, true), 2);
+            world.getBlockTickList().a(blockposition, this, 2);
+        }
+
+        this.a(world, blockposition, iblockdata);
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        if (iblockdata.get(BlockObserver.FACING) == enumdirection && !(Boolean) iblockdata.get(BlockObserver.b)) {
+            this.a(generatoraccess, blockposition);
+        }
+
+        return super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
+    }
+
+    private void a(GeneratorAccess generatoraccess, BlockPosition blockposition) {
+        if (!generatoraccess.e() && !generatoraccess.getBlockTickList().a(blockposition, this)) {
+            generatoraccess.getBlockTickList().a(blockposition, this, 2);
+        }
+
+    }
+
+    protected void a(World world, BlockPosition blockposition, IBlockData iblockdata) {
+        EnumDirection enumdirection = (EnumDirection) iblockdata.get(BlockObserver.FACING);
+        BlockPosition blockposition1 = blockposition.shift(enumdirection.opposite());
+
+        world.a(blockposition1, (Block) this, blockposition);
+        world.a(blockposition1, (Block) this, enumdirection);
+    }
+
+    public boolean isPowerSource(IBlockData iblockdata) {
+        return true;
+    }
+
+    public int b(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, EnumDirection enumdirection) {
+        return iblockdata.a(iblockaccess, blockposition, enumdirection);
+    }
+
+    public int a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, EnumDirection enumdirection) {
+        return (Boolean) iblockdata.get(BlockObserver.b) && iblockdata.get(BlockObserver.FACING) == enumdirection ? 15 : 0;
+    }
+
+    public void onPlace(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1) {
+        if (iblockdata.getBlock() != iblockdata1.getBlock()) {
+            if (!world.e() && (Boolean) iblockdata.get(BlockObserver.b) && !world.getBlockTickList().a(blockposition, this)) {
+                IBlockData iblockdata2 = (IBlockData) iblockdata.set(BlockObserver.b, false);
+
+                world.setTypeAndData(blockposition, iblockdata2, 18);
+                this.a(world, blockposition, iblockdata2);
+            }
+
+        }
+    }
+
+    public void remove(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1, boolean flag) {
+        if (iblockdata.getBlock() != iblockdata1.getBlock()) {
+            if (!world.isClientSide && (Boolean) iblockdata.get(BlockObserver.b) && world.getBlockTickList().a(blockposition, this)) {
+                this.a(world, blockposition, (IBlockData) iblockdata.set(BlockObserver.b, false));
+            }
+
+        }
+    }
+
+    public IBlockData getPlacedState(BlockActionContext blockactioncontext) {
+        return (IBlockData) this.getBlockData().set(BlockObserver.FACING, blockactioncontext.d().opposite().opposite());
+    }
+}

src/main/java/net/minecraft/server/BlockOre.java

@@ -0,0 +1,84 @@
+package net.minecraft.server;
+
+import java.util.Random;
+
+public class BlockOre extends Block {
+
+    public BlockOre(Block.Info block_info) {
+        super(block_info);
+    }
+
+    public IMaterial getDropType(IBlockData iblockdata, World world, BlockPosition blockposition, int i) {
+        return (IMaterial) (this == Blocks.COAL_ORE ? Items.COAL : (this == Blocks.DIAMOND_ORE ? Items.DIAMOND : (this == Blocks.LAPIS_ORE ? Items.LAPIS_LAZULI : (this == Blocks.EMERALD_ORE ? Items.EMERALD : (this == Blocks.NETHER_QUARTZ_ORE ? Items.QUARTZ : this)))));
+    }
+
+    public int a(IBlockData iblockdata, Random random) {
+        return this == Blocks.LAPIS_ORE ? 4 + random.nextInt(5) : 1;
+    }
+
+    public int getDropCount(IBlockData iblockdata, int i, World world, BlockPosition blockposition, Random random) {
+        if (i > 0 && this != this.getDropType((IBlockData) this.getStates().a().iterator().next(), world, blockposition, i)) {
+            int j = random.nextInt(i + 2) - 1;
+
+            if (j < 0) {
+                j = 0;
+            }
+
+            return this.a(iblockdata, random) * (j + 1);
+        } else {
+            return this.a(iblockdata, random);
+        }
+    }
+
+    public void dropNaturally(IBlockData iblockdata, World world, BlockPosition blockposition, float f, int i) {
+        super.dropNaturally(iblockdata, world, blockposition, f, i);
+        /* CraftBukkit start - Delegated to getExpDrop
+        if (this.getDropType(iblockdata, world, blockposition, i) != this) {
+            int j = 0;
+
+            if (this == Blocks.COAL_ORE) {
+                j = MathHelper.nextInt(world.random, 0, 2);
+            } else if (this == Blocks.DIAMOND_ORE) {
+                j = MathHelper.nextInt(world.random, 3, 7);
+            } else if (this == Blocks.EMERALD_ORE) {
+                j = MathHelper.nextInt(world.random, 3, 7);
+            } else if (this == Blocks.LAPIS_ORE) {
+                j = MathHelper.nextInt(world.random, 2, 5);
+            } else if (this == Blocks.NETHER_QUARTZ_ORE) {
+                j = MathHelper.nextInt(world.random, 2, 5);
+            }
+
+            this.dropExperience(world, blockposition, j);
+        }
+        // */
+
+    }
+
+    @Override
+    public int getExpDrop(IBlockData iblockdata, World world, BlockPosition blockposition, int enchantmentLevel) {
+        if (this.getDropType(iblockdata, world, blockposition, enchantmentLevel) != this) {
+            int j = 0;
+
+            if (this == Blocks.COAL_ORE) {
+                j = MathHelper.nextInt(world.random, 0, 2);
+            } else if (this == Blocks.DIAMOND_ORE) {
+                j = MathHelper.nextInt(world.random, 3, 7);
+            } else if (this == Blocks.EMERALD_ORE) {
+                j = MathHelper.nextInt(world.random, 3, 7);
+            } else if (this == Blocks.LAPIS_ORE) {
+                j = MathHelper.nextInt(world.random, 2, 5);
+            } else if (this == Blocks.NETHER_QUARTZ_ORE) {
+                j = MathHelper.nextInt(world.random, 2, 5);
+            }
+
+            return j;
+        }
+
+        return 0;
+        // CraftBukkit end
+    }
+
+    public ItemStack a(IBlockAccess iblockaccess, BlockPosition blockposition, IBlockData iblockdata) {
+        return new ItemStack(this);
+    }
+}

src/main/java/net/minecraft/server/BlockPiston.java

@@ -0,0 +1,433 @@
+package net.minecraft.server;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+// CraftBukkit start
+import java.util.AbstractList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.ListIterator;
+
+import com.google.common.collect.ImmutableList;
+import org.bukkit.craftbukkit.block.CraftBlock;
+import org.bukkit.event.block.BlockPistonRetractEvent;
+import org.bukkit.event.block.BlockPistonExtendEvent;
+// CraftBukkit end
+
+public class BlockPiston extends BlockDirectional {
+
+    public static final BlockStateBoolean EXTENDED = BlockProperties.f;
+    protected static final VoxelShape c = Block.a(0.0D, 0.0D, 0.0D, 12.0D, 16.0D, 16.0D);
+    protected static final VoxelShape o = Block.a(4.0D, 0.0D, 0.0D, 16.0D, 16.0D, 16.0D);
+    protected static final VoxelShape p = Block.a(0.0D, 0.0D, 0.0D, 16.0D, 16.0D, 12.0D);
+    protected static final VoxelShape q = Block.a(0.0D, 0.0D, 4.0D, 16.0D, 16.0D, 16.0D);
+    protected static final VoxelShape r = Block.a(0.0D, 0.0D, 0.0D, 16.0D, 12.0D, 16.0D);
+    protected static final VoxelShape s = Block.a(0.0D, 4.0D, 0.0D, 16.0D, 16.0D, 16.0D);
+    private final boolean sticky;
+
+    public BlockPiston(boolean flag, Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockPiston.FACING, EnumDirection.NORTH)).set(BlockPiston.EXTENDED, false));
+        this.sticky = flag;
+    }
+
+    public boolean q(IBlockData iblockdata) {
+        return !(Boolean) iblockdata.get(BlockPiston.EXTENDED);
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        if ((Boolean) iblockdata.get(BlockPiston.EXTENDED)) {
+            switch ((EnumDirection) iblockdata.get(BlockPiston.FACING)) {
+            case DOWN:
+                return BlockPiston.s;
+            case UP:
+            default:
+                return BlockPiston.r;
+            case NORTH:
+                return BlockPiston.q;
+            case SOUTH:
+                return BlockPiston.p;
+            case WEST:
+                return BlockPiston.o;
+            case EAST:
+                return BlockPiston.c;
+            }
+        } else {
+            return VoxelShapes.b();
+        }
+    }
+
+    public boolean r(IBlockData iblockdata) {
+        return !(Boolean) iblockdata.get(BlockPiston.EXTENDED) || iblockdata.get(BlockPiston.FACING) == EnumDirection.DOWN;
+    }
+
+    public void postPlace(World world, BlockPosition blockposition, IBlockData iblockdata, EntityLiving entityliving, ItemStack itemstack) {
+        if (!world.isClientSide) {
+            this.a(world, blockposition, iblockdata);
+        }
+
+    }
+
+    public void doPhysics(IBlockData iblockdata, World world, BlockPosition blockposition, Block block, BlockPosition blockposition1) {
+        if (!world.isClientSide) {
+            this.a(world, blockposition, iblockdata);
+        }
+
+    }
+
+    public void onPlace(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1) {
+        if (iblockdata1.getBlock() != iblockdata.getBlock()) {
+            if (!world.isClientSide && world.getTileEntity(blockposition) == null) {
+                this.a(world, blockposition, iblockdata);
+            }
+
+        }
+    }
+
+    public IBlockData getPlacedState(BlockActionContext blockactioncontext) {
+        return (IBlockData) ((IBlockData) this.getBlockData().set(BlockPiston.FACING, blockactioncontext.d().opposite())).set(BlockPiston.EXTENDED, false);
+    }
+
+    private void a(World world, BlockPosition blockposition, IBlockData iblockdata) {
+        EnumDirection enumdirection = (EnumDirection) iblockdata.get(BlockPiston.FACING);
+        boolean flag = this.a(world, blockposition, enumdirection);
+
+        if (flag && !(Boolean) iblockdata.get(BlockPiston.EXTENDED)) {
+            if ((new PistonExtendsChecker(world, blockposition, enumdirection, true)).a()) {
+                world.playBlockAction(blockposition, this, 0, enumdirection.a());
+            }
+        } else if (!flag && (Boolean) iblockdata.get(BlockPiston.EXTENDED)) {
+            BlockPosition blockposition1 = blockposition.shift(enumdirection, 2);
+            IBlockData iblockdata1 = world.getType(blockposition1);
+            byte b0 = 1;
+
+            if (iblockdata1.getBlock() == Blocks.MOVING_PISTON && iblockdata1.get(BlockPiston.FACING) == enumdirection) {
+                TileEntity tileentity = world.getTileEntity(blockposition1);
+
+                if (tileentity instanceof TileEntityPiston) {
+                    TileEntityPiston tileentitypiston = (TileEntityPiston) tileentity;
+
+                    if (tileentitypiston.c() && (tileentitypiston.a(0.0F) < 0.5F || world.getTime() == tileentitypiston.k() || ((WorldServer) world).j_())) {
+                        b0 = 2;
+                    }
+                }
+            }
+
+            // CraftBukkit start
+            //if (!this.sticky) { // Paper - Prevents empty sticky pistons from firing retract - history behind is odd
+                org.bukkit.block.Block block = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
+                BlockPistonRetractEvent event = new BlockPistonRetractEvent(block, ImmutableList.<org.bukkit.block.Block>of(), CraftBlock.notchToBlockFace(enumdirection));
+                world.getServer().getPluginManager().callEvent(event);
+
+                if (event.isCancelled()) {
+                    return;
+                }
+            //} // Paper
+            // PAIL: checkME - what happened to setTypeAndData?
+            // CraftBukkit end
+            world.playBlockAction(blockposition, this, b0, enumdirection.a());
+        }
+
+    }
+
+    private boolean a(World world, BlockPosition blockposition, EnumDirection enumdirection) {
+        EnumDirection[] aenumdirection = EnumDirection.values();
+        int i = aenumdirection.length;
+
+        int j;
+
+        for (j = 0; j < i; ++j) {
+            EnumDirection enumdirection1 = aenumdirection[j];
+
+            if (enumdirection1 != enumdirection && world.isBlockFacePowered(blockposition.shift(enumdirection1), enumdirection1)) {
+                return true;
+            }
+        }
+
+        if (world.isBlockFacePowered(blockposition, EnumDirection.DOWN)) {
+            return true;
+        } else {
+            BlockPosition blockposition1 = blockposition.up();
+            EnumDirection[] aenumdirection1 = EnumDirection.values();
+
+            j = aenumdirection1.length;
+
+            for (int k = 0; k < j; ++k) {
+                EnumDirection enumdirection2 = aenumdirection1[k];
+
+                if (enumdirection2 != EnumDirection.DOWN && world.isBlockFacePowered(blockposition1.shift(enumdirection2), enumdirection2)) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    }
+
+    public boolean a(IBlockData iblockdata, World world, BlockPosition blockposition, int i, int j) {
+        EnumDirection enumdirection = (EnumDirection) iblockdata.get(BlockPiston.FACING);
+
+        if (!world.isClientSide) {
+            boolean flag = this.a(world, blockposition, enumdirection);
+
+            if (flag && (i == 1 || i == 2)) {
+                world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockPiston.EXTENDED, true), 2);
+                return false;
+            }
+
+            if (!flag && i == 0) {
+                return false;
+            }
+        }
+
+        if (i == 0) {
+            if (!this.a(world, blockposition, enumdirection, true)) {
+                return false;
+            }
+
+            world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockPiston.EXTENDED, true), 67);
+            world.a((EntityHuman) null, blockposition, SoundEffects.BLOCK_PISTON_EXTEND, SoundCategory.BLOCKS, 0.5F, world.random.nextFloat() * 0.25F + 0.6F);
+        } else if (i == 1 || i == 2) {
+            TileEntity tileentity = world.getTileEntity(blockposition.shift(enumdirection));
+
+            if (tileentity instanceof TileEntityPiston) {
+                ((TileEntityPiston) tileentity).j();
+            }
+
+            world.setTypeAndData(blockposition, (IBlockData) ((IBlockData) Blocks.MOVING_PISTON.getBlockData().set(BlockPistonMoving.a, enumdirection)).set(BlockPistonMoving.b, this.sticky ? BlockPropertyPistonType.STICKY : BlockPropertyPistonType.DEFAULT), 3);
+            world.setTileEntity(blockposition, BlockPistonMoving.a((IBlockData) this.getBlockData().set(BlockPiston.FACING, EnumDirection.fromType1(j & 7)), enumdirection, false, true));
+            if (this.sticky) {
+                BlockPosition blockposition1 = blockposition.a(enumdirection.getAdjacentX() * 2, enumdirection.getAdjacentY() * 2, enumdirection.getAdjacentZ() * 2);
+                IBlockData iblockdata1 = world.getType(blockposition1);
+                Block block = iblockdata1.getBlock();
+                boolean flag1 = false;
+
+                if (block == Blocks.MOVING_PISTON) {
+                    TileEntity tileentity1 = world.getTileEntity(blockposition1);
+
+                    if (tileentity1 instanceof TileEntityPiston) {
+                        TileEntityPiston tileentitypiston = (TileEntityPiston) tileentity1;
+
+                        if (tileentitypiston.d() == enumdirection && tileentitypiston.c()) {
+                            tileentitypiston.j();
+                            flag1 = true;
+                        }
+                    }
+                }
+
+                if (!flag1) {
+                    if (i == 1 && !iblockdata1.isAir() && a(iblockdata1, world, blockposition1, enumdirection.opposite(), false, enumdirection) && (iblockdata1.getPushReaction() == EnumPistonReaction.NORMAL || block == Blocks.PISTON || block == Blocks.STICKY_PISTON)) {
+                        this.a(world, blockposition, enumdirection, false);
+                    } else {
+                        world.setAir(blockposition.shift(enumdirection));
+                    }
+                }
+            } else {
+                world.setAir(blockposition.shift(enumdirection));
+            }
+
+            world.a((EntityHuman) null, blockposition, SoundEffects.BLOCK_PISTON_CONTRACT, SoundCategory.BLOCKS, 0.5F, world.random.nextFloat() * 0.15F + 0.6F);
+        }
+
+        return true;
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public static boolean a(IBlockData iblockdata, World world, BlockPosition blockposition, EnumDirection enumdirection, boolean flag, EnumDirection enumdirection1) {
+        Block block = iblockdata.getBlock();
+
+        if (block == Blocks.OBSIDIAN) {
+            return false;
+        } else if (!world.getWorldBorder().a(blockposition)) {
+            return false;
+        } else if (blockposition.getY() >= 0 && (enumdirection != EnumDirection.DOWN || blockposition.getY() != 0)) {
+            if (blockposition.getY() <= world.getHeight() - 1 && (enumdirection != EnumDirection.UP || blockposition.getY() != world.getHeight() - 1)) {
+                if (block != Blocks.PISTON && block != Blocks.STICKY_PISTON) {
+                    if (iblockdata.e(world, blockposition) == -1.0F) {
+                        return false;
+                    }
+
+                    switch (iblockdata.getPushReaction()) {
+                    case BLOCK:
+                        return false;
+                    case DESTROY:
+                        return flag;
+                    case PUSH_ONLY:
+                        return enumdirection == enumdirection1;
+                    }
+                } else if ((Boolean) iblockdata.get(BlockPiston.EXTENDED)) {
+                    return false;
+                }
+
+                return !block.isTileEntity();
+            } else {
+                return false;
+            }
+        } else {
+            return false;
+        }
+    }
+
+    private boolean a(World world, BlockPosition blockposition, EnumDirection enumdirection, boolean flag) {
+        BlockPosition blockposition1 = blockposition.shift(enumdirection);
+
+        if (!flag && world.getType(blockposition1).getBlock() == Blocks.PISTON_HEAD) {
+            world.setTypeAndData(blockposition1, Blocks.AIR.getBlockData(), 20);
+        }
+
+        PistonExtendsChecker pistonextendschecker = new PistonExtendsChecker(world, blockposition, enumdirection, flag);
+
+        if (!pistonextendschecker.a()) {
+            return false;
+        } else {
+            List<BlockPosition> list = pistonextendschecker.getMovedBlocks();
+            List<IBlockData> list1 = Lists.newArrayList();
+
+            for (int i = 0; i < list.size(); ++i) {
+                BlockPosition blockposition2 = (BlockPosition) list.get(i);
+
+                list1.add(world.getType(blockposition2));
+            }
+
+            List<BlockPosition> list2 = pistonextendschecker.getBrokenBlocks();
+            int j = list.size() + list2.size();
+            IBlockData[] aiblockdata = new IBlockData[j];
+            EnumDirection enumdirection1 = flag ? enumdirection : enumdirection.opposite();
+            Set<BlockPosition> set = Sets.newHashSet(list);
+            // CraftBukkit start
+            final org.bukkit.block.Block bblock = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
+
+            final List<BlockPosition> moved = pistonextendschecker.getMovedBlocks();
+            final List<BlockPosition> broken = pistonextendschecker.getBrokenBlocks();
+
+            List<org.bukkit.block.Block> blocks = new AbstractList<org.bukkit.block.Block>() {
+
+                @Override
+                public int size() {
+                    return moved.size() + broken.size();
+                }
+
+                @Override
+                public org.bukkit.block.Block get(int index) {
+                    if (index >= size() || index < 0) {
+                        throw new ArrayIndexOutOfBoundsException(index);
+                    }
+                    BlockPosition pos = (BlockPosition) (index < moved.size() ? moved.get(index) : broken.get(index - moved.size()));
+                    return bblock.getWorld().getBlockAt(pos.getX(), pos.getY(), pos.getZ());
+                }
+            };
+            org.bukkit.event.block.BlockPistonEvent event;
+            if (flag) {
+                event = new BlockPistonExtendEvent(bblock, blocks, CraftBlock.notchToBlockFace(enumdirection1));
+            } else {
+                event = new BlockPistonRetractEvent(bblock, blocks, CraftBlock.notchToBlockFace(enumdirection1));
+            }
+            world.getServer().getPluginManager().callEvent(event);
+
+            if (event.isCancelled()) {
+                for (BlockPosition b : broken) {
+                    world.notify(b, Blocks.AIR.getBlockData(), world.getType(b), 3);
+                }
+                for (BlockPosition b : moved) {
+                    world.notify(b, Blocks.AIR.getBlockData(), world.getType(b), 3);
+                    b = b.shift(enumdirection1);
+                    world.notify(b, Blocks.AIR.getBlockData(), world.getType(b), 3);
+                }
+                return false;
+            }
+            // CraftBukkit end
+
+            BlockPosition blockposition3;
+            int k;
+            IBlockData iblockdata;
+
+            for (k = list2.size() - 1; k >= 0; --k) {
+                blockposition3 = (BlockPosition) list2.get(k);
+                iblockdata = world.getType(blockposition3);
+                iblockdata.a(world, blockposition3, 0);
+                world.setTypeAndData(blockposition3, Blocks.AIR.getBlockData(), 18);
+                --j;
+                aiblockdata[j] = iblockdata;
+            }
+
+            for (k = list.size() - 1; k >= 0; --k) {
+                blockposition3 = (BlockPosition) list.get(k);
+                iblockdata = world.getType(blockposition3);
+                blockposition3 = blockposition3.shift(enumdirection1);
+                set.remove(blockposition3);
+                world.setTypeAndData(blockposition3, (IBlockData) Blocks.MOVING_PISTON.getBlockData().set(BlockPiston.FACING, enumdirection), 68);
+                world.setTileEntity(blockposition3, BlockPistonMoving.a((IBlockData) list1.get(k), enumdirection, flag, false));
+                --j;
+                aiblockdata[j] = iblockdata;
+            }
+
+            IBlockData iblockdata1;
+
+            if (flag) {
+                BlockPropertyPistonType blockpropertypistontype = this.sticky ? BlockPropertyPistonType.STICKY : BlockPropertyPistonType.DEFAULT;
+
+                iblockdata1 = (IBlockData) ((IBlockData) Blocks.PISTON_HEAD.getBlockData().set(BlockPistonExtension.FACING, enumdirection)).set(BlockPistonExtension.TYPE, blockpropertypistontype);
+                iblockdata = (IBlockData) ((IBlockData) Blocks.MOVING_PISTON.getBlockData().set(BlockPistonMoving.a, enumdirection)).set(BlockPistonMoving.b, this.sticky ? BlockPropertyPistonType.STICKY : BlockPropertyPistonType.DEFAULT);
+                set.remove(blockposition1);
+                world.setTypeAndData(blockposition1, iblockdata, 68);
+                world.setTileEntity(blockposition1, BlockPistonMoving.a(iblockdata1, enumdirection, true, true));
+            }
+
+            Iterator iterator = set.iterator();
+
+            while (iterator.hasNext()) {
+                blockposition3 = (BlockPosition) iterator.next();
+                world.setTypeAndData(blockposition3, Blocks.AIR.getBlockData(), 66);
+            }
+
+            for (k = list2.size() - 1; k >= 0; --k) {
+                iblockdata1 = aiblockdata[j++];
+                BlockPosition blockposition4 = (BlockPosition) list2.get(k);
+
+                iblockdata1.b(world, blockposition4, 2);
+                world.applyPhysics(blockposition4, iblockdata1.getBlock());
+            }
+
+            for (k = list.size() - 1; k >= 0; --k) {
+                world.applyPhysics((BlockPosition) list.get(k), aiblockdata[j++].getBlock());
+            }
+
+            if (flag) {
+                world.applyPhysics(blockposition1, Blocks.PISTON_HEAD);
+            }
+
+            return true;
+        }
+    }
+
+    public IBlockData a(IBlockData iblockdata, EnumBlockRotation enumblockrotation) {
+        return (IBlockData) iblockdata.set(BlockPiston.FACING, enumblockrotation.a((EnumDirection) iblockdata.get(BlockPiston.FACING)));
+    }
+
+    public IBlockData a(IBlockData iblockdata, EnumBlockMirror enumblockmirror) {
+        return iblockdata.a(enumblockmirror.a((EnumDirection) iblockdata.get(BlockPiston.FACING)));
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockPiston.FACING, BlockPiston.EXTENDED);
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return iblockdata.get(BlockPiston.FACING) != enumdirection.opposite() && (Boolean) iblockdata.get(BlockPiston.EXTENDED) ? EnumBlockFaceShape.UNDEFINED : EnumBlockFaceShape.SOLID;
+    }
+
+    public int j(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return 0;
+    }
+
+    public boolean a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, PathMode pathmode) {
+        return false;
+    }
+}

src/main/java/net/minecraft/server/BlockPlant.java

@@ -0,0 +1,47 @@
+package net.minecraft.server;
+
+public class BlockPlant extends Block {
+
+    protected BlockPlant(Block.Info block_info) {
+        super(block_info);
+    }
+
+    protected boolean b(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        Block block = iblockdata.getBlock();
+
+        return block == Blocks.GRASS_BLOCK || block == Blocks.DIRT || block == Blocks.COARSE_DIRT || block == Blocks.PODZOL || block == Blocks.FARMLAND;
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        // CraftBukkit start
+        if (!iblockdata.canPlace(generatoraccess, blockposition)) {
+            if (!(generatoraccess instanceof WorldServer && ((WorldServer) generatoraccess).hasPhysicsEvent) || !org.bukkit.craftbukkit.event.CraftEventFactory.callBlockPhysicsEvent(generatoraccess, blockposition).isCancelled()) { // Paper
+                return Blocks.AIR.getBlockData();
+            }
+        }
+        return super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
+        // CraftBukkit end
+    }
+
+    public boolean canPlace(IBlockData iblockdata, IWorldReader iworldreader, BlockPosition blockposition) {
+        BlockPosition blockposition1 = blockposition.down();
+
+        return this.b(iworldreader.getType(blockposition1), (IBlockAccess) iworldreader, blockposition1);
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public TextureType c() {
+        return TextureType.CUTOUT;
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return EnumBlockFaceShape.UNDEFINED;
+    }
+
+    public int j(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return 0;
+    }
+}

src/main/java/net/minecraft/server/BlockPortal.java

@@ -0,0 +1,381 @@
+package net.minecraft.server;
+
+import com.google.common.cache.LoadingCache;
+import java.util.Random;
+import javax.annotation.Nullable;
+
+// CraftBukkit start
+import org.bukkit.craftbukkit.block.CraftBlock;
+import org.bukkit.event.entity.EntityPortalEnterEvent;
+import org.bukkit.event.world.PortalCreateEvent;
+// CraftBukkit end
+
+public class BlockPortal extends Block {
+
+    public static final BlockStateEnum<EnumDirection.EnumAxis> AXIS = BlockProperties.z;
+    protected static final VoxelShape b = Block.a(0.0D, 0.0D, 6.0D, 16.0D, 16.0D, 10.0D);
+    protected static final VoxelShape c = Block.a(6.0D, 0.0D, 0.0D, 10.0D, 16.0D, 16.0D);
+
+    public BlockPortal(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockPortal.AXIS, EnumDirection.EnumAxis.X));
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        switch ((EnumDirection.EnumAxis) iblockdata.get(BlockPortal.AXIS)) {
+        case Z:
+            return BlockPortal.c;
+        case X:
+        default:
+            return BlockPortal.b;
+        }
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if (world.spigotConfig.enableZombiePigmenPortalSpawns && world.worldProvider.isOverworld() && world.getGameRules().getBoolean("doMobSpawning") && random.nextInt(2000) < world.getDifficulty().a()) { // Spigot
+            int i = blockposition.getY();
+
+            BlockPosition blockposition1;
+
+            for (blockposition1 = blockposition; !world.getType(blockposition1).q() && blockposition1.getY() > 0; blockposition1 = blockposition1.down()) {
+                ;
+            }
+
+            if (i > 0 && !world.getType(blockposition1.up()).isOccluding()) {
+                // CraftBukkit - set spawn reason to NETHER_PORTAL
+                Entity entity = EntityTypes.ZOMBIE_PIGMAN.spawnCreature(world, (NBTTagCompound) null, (IChatBaseComponent) null, (EntityHuman) null, blockposition1.up(), false, false, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.NETHER_PORTAL);
+
+                if (entity != null) {
+                    entity.portalCooldown = entity.aQ();
+                }
+            }
+        }
+
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public boolean a(GeneratorAccess generatoraccess, BlockPosition blockposition) {
+        BlockPortal.Shape blockportal_shape = this.b(generatoraccess, blockposition);
+
+        if (blockportal_shape != null) {
+            // CraftBukkit start - return portalcreator
+            return blockportal_shape.createPortal();
+            // return true;
+            // CraftBukkit end
+        } else {
+            return false;
+        }
+    }
+
+    @Nullable
+    public BlockPortal.Shape b(GeneratorAccess generatoraccess, BlockPosition blockposition) {
+        BlockPortal.Shape blockportal_shape = new BlockPortal.Shape(generatoraccess, blockposition, EnumDirection.EnumAxis.X);
+
+        if (blockportal_shape.d() && blockportal_shape.e == 0) {
+            return blockportal_shape;
+        } else {
+            BlockPortal.Shape blockportal_shape1 = new BlockPortal.Shape(generatoraccess, blockposition, EnumDirection.EnumAxis.Z);
+
+            return blockportal_shape1.d() && blockportal_shape1.e == 0 ? blockportal_shape1 : null;
+        }
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        EnumDirection.EnumAxis enumdirection_enumaxis = enumdirection.k();
+        EnumDirection.EnumAxis enumdirection_enumaxis1 = (EnumDirection.EnumAxis) iblockdata.get(BlockPortal.AXIS);
+        boolean flag = enumdirection_enumaxis1 != enumdirection_enumaxis && enumdirection_enumaxis.c();
+
+        return !flag && iblockdata1.getBlock() != this && !(new BlockPortal.Shape(generatoraccess, blockposition, enumdirection_enumaxis1)).f() ? Blocks.AIR.getBlockData() : super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
+    }
+
+    public int a(IBlockData iblockdata, Random random) {
+        return 0;
+    }
+
+    public TextureType c() {
+        return TextureType.TRANSLUCENT;
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
+        if (!entity.isPassenger() && !entity.isVehicle() && entity.bm()) {
+            // CraftBukkit start - Entity in portal
+            EntityPortalEnterEvent event = new EntityPortalEnterEvent(entity.getBukkitEntity(), new org.bukkit.Location(world.getWorld(), blockposition.getX(), blockposition.getY(), blockposition.getZ()));
+            world.getServer().getPluginManager().callEvent(event);
+            // CraftBukkit end
+            entity.e(blockposition);
+        }
+
+    }
+
+    public ItemStack a(IBlockAccess iblockaccess, BlockPosition blockposition, IBlockData iblockdata) {
+        return ItemStack.a;
+    }
+
+    public IBlockData a(IBlockData iblockdata, EnumBlockRotation enumblockrotation) {
+        switch (enumblockrotation) {
+        case COUNTERCLOCKWISE_90:
+        case CLOCKWISE_90:
+            switch ((EnumDirection.EnumAxis) iblockdata.get(BlockPortal.AXIS)) {
+            case Z:
+                return (IBlockData) iblockdata.set(BlockPortal.AXIS, EnumDirection.EnumAxis.X);
+            case X:
+                return (IBlockData) iblockdata.set(BlockPortal.AXIS, EnumDirection.EnumAxis.Z);
+            default:
+                return iblockdata;
+            }
+        default:
+            return iblockdata;
+        }
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockPortal.AXIS);
+    }
+
+    public ShapeDetector.ShapeDetectorCollection c(GeneratorAccess generatoraccess, BlockPosition blockposition) {
+        EnumDirection.EnumAxis enumdirection_enumaxis = EnumDirection.EnumAxis.Z;
+        BlockPortal.Shape blockportal_shape = new BlockPortal.Shape(generatoraccess, blockposition, EnumDirection.EnumAxis.X);
+        LoadingCache<BlockPosition, ShapeDetectorBlock> loadingcache = ShapeDetector.a(generatoraccess, true);
+
+        if (!blockportal_shape.d()) {
+            enumdirection_enumaxis = EnumDirection.EnumAxis.X;
+            blockportal_shape = new BlockPortal.Shape(generatoraccess, blockposition, EnumDirection.EnumAxis.Z);
+        }
+
+        if (!blockportal_shape.d()) {
+            return new ShapeDetector.ShapeDetectorCollection(blockposition, EnumDirection.NORTH, EnumDirection.UP, loadingcache, 1, 1, 1);
+        } else {
+            int[] aint = new int[EnumDirection.EnumAxisDirection.values().length];
+            EnumDirection enumdirection = blockportal_shape.c.f();
+            BlockPosition blockposition1 = blockportal_shape.position.up(blockportal_shape.a() - 1);
+            EnumDirection.EnumAxisDirection[] aenumdirection_enumaxisdirection = EnumDirection.EnumAxisDirection.values();
+            int i = aenumdirection_enumaxisdirection.length;
+
+            int j;
+
+            for (j = 0; j < i; ++j) {
+                EnumDirection.EnumAxisDirection enumdirection_enumaxisdirection = aenumdirection_enumaxisdirection[j];
+                ShapeDetector.ShapeDetectorCollection shapedetector_shapedetectorcollection = new ShapeDetector.ShapeDetectorCollection(enumdirection.c() == enumdirection_enumaxisdirection ? blockposition1 : blockposition1.shift(blockportal_shape.c, blockportal_shape.b() - 1), EnumDirection.a(enumdirection_enumaxisdirection, enumdirection_enumaxis), EnumDirection.UP, loadingcache, blockportal_shape.b(), blockportal_shape.a(), 1);
+
+                for (int k = 0; k < blockportal_shape.b(); ++k) {
+                    for (int l = 0; l < blockportal_shape.a(); ++l) {
+                        ShapeDetectorBlock shapedetectorblock = shapedetector_shapedetectorcollection.a(k, l, 1);
+
+                        if (!shapedetectorblock.a().isAir()) {
+                            ++aint[enumdirection_enumaxisdirection.ordinal()];
+                        }
+                    }
+                }
+            }
+
+            EnumDirection.EnumAxisDirection enumdirection_enumaxisdirection1 = EnumDirection.EnumAxisDirection.POSITIVE;
+            EnumDirection.EnumAxisDirection[] aenumdirection_enumaxisdirection1 = EnumDirection.EnumAxisDirection.values();
+
+            j = aenumdirection_enumaxisdirection1.length;
+
+            for (int i1 = 0; i1 < j; ++i1) {
+                EnumDirection.EnumAxisDirection enumdirection_enumaxisdirection2 = aenumdirection_enumaxisdirection1[i1];
+
+                if (aint[enumdirection_enumaxisdirection2.ordinal()] < aint[enumdirection_enumaxisdirection1.ordinal()]) {
+                    enumdirection_enumaxisdirection1 = enumdirection_enumaxisdirection2;
+                }
+            }
+
+            return new ShapeDetector.ShapeDetectorCollection(enumdirection.c() == enumdirection_enumaxisdirection1 ? blockposition1 : blockposition1.shift(blockportal_shape.c, blockportal_shape.b() - 1), EnumDirection.a(enumdirection_enumaxisdirection1, enumdirection_enumaxis), EnumDirection.UP, loadingcache, blockportal_shape.b(), blockportal_shape.a(), 1);
+        }
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return EnumBlockFaceShape.UNDEFINED;
+    }
+
+    public static class Shape {
+
+        private final GeneratorAccess a;
+        private final EnumDirection.EnumAxis b;
+        private final EnumDirection c;
+        private final EnumDirection d;
+        private int e;
+        private BlockPosition position;
+        private int height;
+        private int width;
+        java.util.Collection<org.bukkit.block.Block> blocks = new java.util.HashSet<org.bukkit.block.Block>(); // CraftBukkit - add field
+
+        public Shape(GeneratorAccess generatoraccess, BlockPosition blockposition, EnumDirection.EnumAxis enumdirection_enumaxis) {
+            this.a = generatoraccess;
+            this.b = enumdirection_enumaxis;
+            if (enumdirection_enumaxis == EnumDirection.EnumAxis.X) {
+                this.d = EnumDirection.EAST;
+                this.c = EnumDirection.WEST;
+            } else {
+                this.d = EnumDirection.NORTH;
+                this.c = EnumDirection.SOUTH;
+            }
+
+            for (BlockPosition blockposition1 = blockposition; blockposition.getY() > blockposition1.getY() - 21 && blockposition.getY() > 0 && this.a(generatoraccess.getType(blockposition.down())); blockposition = blockposition.down()) {
+                ;
+            }
+
+            int i = this.a(blockposition, this.d) - 1;
+
+            if (i >= 0) {
+                this.position = blockposition.shift(this.d, i);
+                this.width = this.a(this.position, this.c);
+                if (this.width < 2 || this.width > 21) {
+                    this.position = null;
+                    this.width = 0;
+                }
+            }
+
+            if (this.position != null) {
+                this.height = this.c();
+            }
+
+        }
+
+        protected int a(BlockPosition blockposition, EnumDirection enumdirection) {
+            int i;
+
+            for (i = 0; i < 22; ++i) {
+                BlockPosition blockposition1 = blockposition.shift(enumdirection, i);
+
+                if (!this.a(this.a.getType(blockposition1)) || this.a.getType(blockposition1.down()).getBlock() != Blocks.OBSIDIAN) {
+                    break;
+                }
+            }
+
+            Block block = this.a.getType(blockposition.shift(enumdirection, i)).getBlock();
+
+            return block == Blocks.OBSIDIAN ? i : 0;
+        }
+
+        public int a() {
+            return this.height;
+        }
+
+        public int b() {
+            return this.width;
+        }
+
+        protected int c() {
+            // CraftBukkit start
+            this.blocks.clear();
+            // CraftBukkit end
+            int i;
+
+            label56:
+            for (this.height = 0; this.height < 21; ++this.height) {
+                for (i = 0; i < this.width; ++i) {
+                    BlockPosition blockposition = this.position.shift(this.c, i).up(this.height);
+                    IBlockData iblockdata = this.a.getType(blockposition);
+
+                    if (!this.a(iblockdata)) {
+                        break label56;
+                    }
+
+                    Block block = iblockdata.getBlock();
+
+                    if (block == Blocks.NETHER_PORTAL) {
+                        ++this.e;
+                    }
+
+                    if (i == 0) {
+                        block = this.a.getType(blockposition.shift(this.d)).getBlock();
+                        if (block != Blocks.OBSIDIAN) {
+                            break label56;
+                            // CraftBukkit start - add the block to our list
+                        } else {
+                            BlockPosition pos = blockposition.shift(this.d);
+                            blocks.add(CraftBlock.at(this.a, pos));
+                            // CraftBukkit end
+                        }
+                    } else if (i == this.width - 1) {
+                        block = this.a.getType(blockposition.shift(this.c)).getBlock();
+                        if (block != Blocks.OBSIDIAN) {
+                            break label56;
+                            // CraftBukkit start - add the block to our list
+                        } else {
+                            BlockPosition pos = blockposition.shift(this.c);
+                            blocks.add(CraftBlock.at(this.a, pos));
+                            // CraftBukkit end
+                        }
+                    }
+                }
+            }
+
+            for (i = 0; i < this.width; ++i) {
+                if (this.a.getType(this.position.shift(this.c, i).up(this.height)).getBlock() != Blocks.OBSIDIAN) {
+                    this.height = 0;
+                    break;
+                    // CraftBukkit start - add the block to our list
+                } else {
+                    BlockPosition pos = this.position.shift(this.c, i).up(this.height);
+                    blocks.add(CraftBlock.at(this.a, pos));
+                    // CraftBukkit end
+                }
+            }
+
+            if (this.height <= 21 && this.height >= 3) {
+                return this.height;
+            } else {
+                this.position = null;
+                this.width = 0;
+                this.height = 0;
+                return 0;
+            }
+        }
+
+        protected boolean a(IBlockData iblockdata) {
+            Block block = iblockdata.getBlock();
+
+            return iblockdata.isAir() || block == Blocks.FIRE || block == Blocks.NETHER_PORTAL;
+        }
+
+        public boolean d() {
+            return this.position != null && this.width >= 2 && this.width <= 21 && this.height >= 3 && this.height <= 21;
+        }
+
+        // CraftBukkit start - return boolean
+        public boolean createPortal() {
+            org.bukkit.World bworld = this.a.getMinecraftWorld().getWorld();
+
+            // Copy below for loop
+            for (int i = 0; i < this.width; ++i) {
+                BlockPosition blockposition = this.position.shift(this.c, i);
+
+                for (int j = 0; j < this.height; ++j) {
+                    BlockPosition pos = blockposition.up(j);
+                    blocks.add(bworld.getBlockAt(pos.getX(), pos.getY(), pos.getZ()));
+                }
+            }
+
+            PortalCreateEvent event = new PortalCreateEvent(blocks, bworld, PortalCreateEvent.CreateReason.FIRE);
+            this.a.getMinecraftWorld().getMinecraftServer().server.getPluginManager().callEvent(event);
+
+            if (event.isCancelled()) {
+                return false;
+            }
+            // CraftBukkit end
+            for (int i = 0; i < this.width; ++i) {
+                BlockPosition blockposition = this.position.shift(this.c, i);
+
+                for (int j = 0; j < this.height; ++j) {
+                    this.a.setTypeAndData(blockposition.up(j), (IBlockData) Blocks.NETHER_PORTAL.getBlockData().set(BlockPortal.AXIS, this.b), 18);
+                }
+            }
+
+            return true; // CraftBukkit
+        }
+
+        private boolean g() {
+            return this.e >= this.width * this.height;
+        }
+
+        public boolean f() {
+            return this.d() && this.g();
+        }
+    }
+}

src/main/java/net/minecraft/server/BlockPosition.java

@@ -0,0 +1,422 @@
+package net.minecraft.server;
+
+import com.google.common.collect.AbstractIterator;
+import com.google.common.collect.Lists;
+import java.util.List;
+import javax.annotation.concurrent.Immutable;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Immutable
+public class BlockPosition extends BaseBlockPosition {
+
+    //private static final Logger b = LogManager.getLogger(); // Paper - variable name conflict, logger isn't used
+    public static final BlockPosition ZERO = new BlockPosition(0, 0, 0);
+    private static final int c = 1 + MathHelper.e(MathHelper.c(30000000));
+    private static final int d = BlockPosition.c;
+    private static final int f = 64 - BlockPosition.c - BlockPosition.d;
+    private static final int g = 0 + BlockPosition.d;
+    private static final int h = BlockPosition.g + BlockPosition.f;
+    private static final long i = (1L << BlockPosition.c) - 1L;
+    private static final long j = (1L << BlockPosition.f) - 1L;
+    private static final long k = (1L << BlockPosition.d) - 1L;
+
+    public BlockPosition(int i, int j, int k) {
+        super(i, j, k);
+    }
+
+    public BlockPosition(double d0, double d1, double d2) {
+        super(d0, d1, d2);
+    }
+
+    public BlockPosition(Entity entity) {
+        this(entity.locX, entity.locY, entity.locZ);
+    }
+
+    public BlockPosition(Vec3D vec3d) {
+        this(vec3d.x, vec3d.y, vec3d.z);
+    }
+
+    public BlockPosition(BaseBlockPosition baseblockposition) {
+        this(baseblockposition.getX(), baseblockposition.getY(), baseblockposition.getZ());
+    }
+
+    public BlockPosition a(double d0, double d1, double d2) {
+        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);
+    }
+
+    public BlockPosition add(int i, int j, int k) {return a(i, j, k);} // Paper - OBFHELPER
+    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);
+    }
+
+    public BlockPosition a(BaseBlockPosition baseblockposition) {
+        return this.a(baseblockposition.getX(), baseblockposition.getY(), baseblockposition.getZ());
+    }
+
+    public BlockPosition b(BaseBlockPosition baseblockposition) {
+        return this.a(-baseblockposition.getX(), -baseblockposition.getY(), -baseblockposition.getZ());
+    }
+
+    public BlockPosition up() {
+        return new BlockPosition(this.getX(), this.getY() + 1, this.getZ()); // Paper - Optimize BlockPosition
+    }
+
+    public BlockPosition up(int i) {
+        return i == 0 ? this : new BlockPosition(this.getX(), this.getY() + i, this.getZ()); // Paper - Optimize BlockPosition
+    }
+
+    public BlockPosition down() {
+        return new BlockPosition(this.getX(), this.getY() - 1, this.getZ()); // Paper - Optimize BlockPosition
+    }
+
+    public BlockPosition down(int i) {
+        return i == 0 ? this : new BlockPosition(this.getX(), this.getY() - i, this.getZ()); // Paper - Optimize BlockPosition
+    }
+
+    public BlockPosition north() {
+        return new BlockPosition(this.getX(), this.getY(), this.getZ() - 1); // Paper - Optimize BlockPosition
+    }
+
+    public BlockPosition north(int i) {
+        return i == 0 ? this : new BlockPosition(this.getX(), this.getY(), this.getZ() - i); // Paper - Optimize BlockPosition
+    }
+
+    public BlockPosition south() {
+        return new BlockPosition(this.getX(), this.getY(), this.getZ() + 1); // Paper - Optimize BlockPosition
+    }
+
+    public BlockPosition south(int i) {
+        return i == 0 ? this : new BlockPosition(this.getX(), this.getY(), this.getZ() + i); // Paper - Optimize BlockPosition
+    }
+
+    public BlockPosition west() {
+        return new BlockPosition(this.getX() - 1, this.getY(), this.getZ()); // Paper - Optimize BlockPosition
+    }
+
+    public BlockPosition west(int i) {
+        return i == 0 ? this : new BlockPosition(this.getX() - i, this.getY(), this.getZ()); // Paper - Optimize BlockPosition
+    }
+
+    public BlockPosition east() {
+        return new BlockPosition(this.getX() + 1, this.getY(), this.getZ()); // Paper - Optimize BlockPosition
+    }
+
+    public BlockPosition east(int i) {
+        return i == 0 ? this : new BlockPosition(this.getX() + i, this.getY(), this.getZ()); // Paper - Optimize BlockPosition
+    }
+
+    public BlockPosition shift(EnumDirection enumdirection) {
+        // Paper Start - Optimize BlockPosition
+        switch(enumdirection) {
+            case UP:
+                return new BlockPosition(this.getX(), this.getY() + 1, this.getZ());
+            case DOWN:
+                return new BlockPosition(this.getX(), this.getY() - 1, this.getZ());
+            case NORTH:
+                return new BlockPosition(this.getX(), this.getY(), this.getZ() - 1);
+            case SOUTH:
+                return new BlockPosition(this.getX(), this.getY(), this.getZ() + 1);
+            case WEST:
+                return new BlockPosition(this.getX() - 1, this.getY(), this.getZ());
+            case EAST:
+                return new BlockPosition(this.getX() + 1, this.getY(), this.getZ());
+            default:
+                return new BlockPosition(this.getX() + enumdirection.getAdjacentX(), this.getY() + enumdirection.getAdjacentY(), this.getZ() + enumdirection.getAdjacentZ());
+        }
+        // Paper End
+    }
+
+    public BlockPosition shift(EnumDirection enumdirection, int i) {
+        return i == 0 ? this : new BlockPosition(this.getX() + enumdirection.getAdjacentX() * i, this.getY() + enumdirection.getAdjacentY() * i, this.getZ() + enumdirection.getAdjacentZ() * i);
+    }
+
+    public BlockPosition a(EnumBlockRotation enumblockrotation) {
+        switch (enumblockrotation) {
+        case NONE:
+        default:
+            return this;
+        case CLOCKWISE_90:
+            return new BlockPosition(-this.getZ(), this.getY(), this.getX());
+        case CLOCKWISE_180:
+            return new BlockPosition(-this.getX(), this.getY(), -this.getZ());
+        case COUNTERCLOCKWISE_90:
+            return new BlockPosition(this.getZ(), this.getY(), -this.getX());
+        }
+    }
+
+    public BlockPosition d(BaseBlockPosition baseblockposition) {
+        return new BlockPosition(this.getY() * baseblockposition.getZ() - this.getZ() * baseblockposition.getY(), this.getZ() * baseblockposition.getX() - this.getX() * baseblockposition.getZ(), this.getX() * baseblockposition.getY() - this.getY() * baseblockposition.getX());
+    }
+
+    public long asLong() {
+        return ((long) this.getX() & BlockPosition.i) << BlockPosition.h | ((long) this.getY() & BlockPosition.j) << BlockPosition.g | ((long) this.getZ() & BlockPosition.k) << 0;
+    }
+
+    public static BlockPosition fromLong(long i) {
+        int j = (int) (i << 64 - BlockPosition.h - BlockPosition.c >> 64 - BlockPosition.c);
+        int k = (int) (i << 64 - BlockPosition.g - BlockPosition.f >> 64 - BlockPosition.f);
+        int l = (int) (i << 64 - BlockPosition.d >> 64 - BlockPosition.d);
+
+        return new BlockPosition(j, k, l);
+    }
+
+    public static Iterable<BlockPosition> a(BlockPosition blockposition, BlockPosition blockposition1) {
+        return a(Math.min(blockposition.getX(), blockposition1.getX()), Math.min(blockposition.getY(), blockposition1.getY()), Math.min(blockposition.getZ(), blockposition1.getZ()), Math.max(blockposition.getX(), blockposition1.getX()), Math.max(blockposition.getY(), blockposition1.getY()), Math.max(blockposition.getZ(), blockposition1.getZ()));
+    }
+
+    public static Iterable<BlockPosition> a(int ix, int jx, int kx, int l, int i1, int j1) { // Paper - decompile fix
+        return () -> {
+            return new AbstractIterator<BlockPosition>() {
+                private boolean g = true;
+                private int h;
+                private int i;
+                private int j;
+
+                protected BlockPosition computeNext() {
+                    if (this.g) {
+                        this.g = false;
+                        this.h = ix; // Paper - decompile fix
+                        this.i = jx; // Paper - decompile fix
+                        this.j = kx; // Paper - decompile fix
+                        return new BlockPosition(ix, jx, kx);
+                    } else if (this.h == l && this.i == i1 && this.j == j1) {
+                        return (BlockPosition) this.endOfData();
+                    } else {
+                        if (this.h < l) {
+                            ++this.h;
+                        } else if (this.i < i1) {
+                            this.h = ix; // Paper - decompile fix
+                            ++this.i;
+                        } else if (this.j < j1) {
+                            this.h = ix; // Paper - decompile fix
+                            this.i = jx; // Paper - decompile fix
+                            ++this.j;
+                        }
+
+                        return new BlockPosition(this.h, this.i, this.j);
+                    }
+                }
+            };
+        };
+    }
+
+    public BlockPosition asImmutable() { return h(); } // Paper - OBFHELPER
+    public BlockPosition h() {
+        return this;
+    }
+
+    public static Iterable<BlockPosition.MutableBlockPosition> b(BlockPosition blockposition, BlockPosition blockposition1) {
+        return b(Math.min(blockposition.getX(), blockposition1.getX()), Math.min(blockposition.getY(), blockposition1.getY()), Math.min(blockposition.getZ(), blockposition1.getZ()), Math.max(blockposition.getX(), blockposition1.getX()), Math.max(blockposition.getY(), blockposition1.getY()), Math.max(blockposition.getZ(), blockposition1.getZ()));
+    }
+
+    public static Iterable<BlockPosition.MutableBlockPosition> b(int i, int j, int k, int l, int i1, int j1) {
+        return () -> {
+            return new AbstractIterator<BlockPosition.MutableBlockPosition>() {
+                private BlockPosition.MutableBlockPosition g;
+
+                protected BlockPosition.MutableBlockPosition computeNext() {
+                    if (this.g == null) {
+                        this.g = new BlockPosition.MutableBlockPosition(i, j, k);
+                        return this.g;
+                    } else if (this.g.x == l && this.g.y == i1 && this.g.z == j1) {
+                        return (BlockPosition.MutableBlockPosition) this.endOfData();
+                    } else {
+                        if (this.g.x < l) {
+                            ++this.g.x;
+                        } else if (this.g.y < i1) {
+                            this.g.x = i; // Paper - decompile fix Readd line removed by the decompiler
+                            ++this.g.y;
+                        } else if (this.g.z < j1) {
+                            this.g.x = i; // Paper - decompile fix Readd line removed by the decompiler
+                            this.g.y = j; // Paper - decompile fix Readd line removed by the decompiler
+                            ++this.g.z;
+                        }
+
+                        return this.g;
+                    }
+                }
+            };
+        };
+    }
+
+    public static final class b extends BlockPosition.MutableBlockPosition implements AutoCloseable {
+
+        private boolean f;
+        private static final List<BlockPosition.b> g = Lists.newArrayList();
+
+        private b(int i, int j, int k) {
+            super(i, j, k);
+        }
+
+        public static BlockPosition.b r() {
+            return e(0, 0, 0);
+        }
+
+        public static BlockPosition.b b(Entity entity) {
+            return d(entity.locX, entity.locY, entity.locZ);
+        }
+
+        public static BlockPosition.b d(double d0, double d1, double d2) {
+            return e(MathHelper.floor(d0), MathHelper.floor(d1), MathHelper.floor(d2));
+        }
+
+        public static BlockPosition.b e(int i, int j, int k) {
+            synchronized (BlockPosition.b.g) {
+                if (!BlockPosition.b.g.isEmpty()) {
+                    BlockPosition.b blockposition_b = (BlockPosition.b) BlockPosition.b.g.remove(BlockPosition.b.g.size() - 1);
+
+                    if (blockposition_b != null && blockposition_b.f) {
+                        blockposition_b.f = false;
+                        blockposition_b.c(i, j, k);
+                        return blockposition_b;
+                    }
+                }
+            }
+
+            return new BlockPosition.b(i, j, k);
+        }
+
+        public BlockPosition.b c(int i, int j, int k) {
+            return (BlockPosition.b) super.c(i, j, k);
+        }
+
+        public BlockPosition.b c(double d0, double d1, double d2) {
+            return (BlockPosition.b) super.c(d0, d1, d2);
+        }
+
+        public BlockPosition.b g(BaseBlockPosition baseblockposition) {
+            return (BlockPosition.b) super.g(baseblockposition);
+        }
+
+        public BlockPosition.b c(EnumDirection enumdirection) {
+            return (BlockPosition.b) super.c(enumdirection);
+        }
+
+        public BlockPosition.b c(EnumDirection enumdirection, int i) {
+            return (BlockPosition.b) super.c(enumdirection, i);
+        }
+
+        public BlockPosition.b d(int i, int j, int k) {
+            return (BlockPosition.b) super.d(i, j, k);
+        }
+
+        public void close() {
+            synchronized (BlockPosition.b.g) {
+                if (BlockPosition.b.g.size() < 100) {
+                    BlockPosition.b.g.add(this);
+                }
+
+                this.f = true;
+            }
+        }
+    }
+
+    public static class MutableBlockPosition extends BlockPosition {
+        // Paper start - comment out
+        /*
+        protected int b;
+        protected int c;
+        protected int d;
+
+        @Override
+        public boolean isValidLocation() {
+            return b >= -30000000 && d >= -30000000 && b < 30000000 && d < 30000000 && c >= 0 && c < 256;
+        }
+        @Override
+        public boolean isInvalidYLocation() {
+            return c < 0 || c >= 256;
+        }
+        */
+        // Paper end
+
+        public MutableBlockPosition() {
+            this(0, 0, 0);
+        }
+
+        public MutableBlockPosition(BlockPosition blockposition) {
+            this(blockposition.getX(), blockposition.getY(), blockposition.getZ());
+        }
+
+        public MutableBlockPosition(int i, int j, int k) {
+            // Paper start
+            super(i, j, k);
+            /*
+            this.b = i;
+            this.c = j;
+            this.d = k;*/
+            // Paper end
+        }
+
+        public BlockPosition a(double d0, double d1, double d2) {
+            return super.a(d0, d1, d2).h();
+        }
+
+        public BlockPosition a(int i, int j, int k) {
+            return super.a(i, j, k).h();
+        }
+
+        public BlockPosition shift(EnumDirection enumdirection, int i) {
+            return super.shift(enumdirection, i).h();
+        }
+
+        public BlockPosition a(EnumBlockRotation enumblockrotation) {
+            return super.a(enumblockrotation).h();
+        }
+
+        /*
+        // Paper start - use parent getters
+        public int getX() {
+            return this.b;
+        }
+
+        public int getY() {
+            return this.c;
+        }
+
+        public int getZ() {
+            return this.d;
+        }*/
+        // Paper end
+
+        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) {
+            // Paper start - use xyz
+            this.x = i;
+            this.y = j;
+            this.z = k;
+            // Paper end
+            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));
+        }
+
+        public BlockPosition.MutableBlockPosition g(BaseBlockPosition baseblockposition) {
+            return this.c(baseblockposition.getX(), baseblockposition.getY(), baseblockposition.getZ());
+        }
+
+        public BlockPosition.MutableBlockPosition c(EnumDirection enumdirection) {
+            return this.c(enumdirection, 1);
+        }
+
+        public BlockPosition.MutableBlockPosition c(EnumDirection enumdirection, int i) {
+            return this.c(x + enumdirection.getAdjacentX() * i, y + enumdirection.getAdjacentY() * i, z + enumdirection.getAdjacentZ() * i); // Paper - use xyz
+        }
+
+        public BlockPosition.MutableBlockPosition d(int i, int j, int k) {
+            return this.c(x + i, y + j, z + k); // Paper - use xyz
+        }
+
+        public void p(int i) {
+            this.y = i; // Paper change to y
+        }
+
+        public BlockPosition toBlockPosition() { return h(); } // Paper - OBFHELPER
+        public BlockPosition h() {
+            return new BlockPosition(this);
+        }
+    }
+}

src/main/java/net/minecraft/server/BlockPoweredRail.java

@@ -0,0 +1,246 @@
+package net.minecraft.server;
+
+import org.bukkit.craftbukkit.event.CraftEventFactory; // CraftBukkit
+
+public class BlockPoweredRail extends BlockMinecartTrackAbstract {
+
+    public static final BlockStateEnum<BlockPropertyTrackPosition> SHAPE = BlockProperties.S;
+    public static final BlockStateBoolean POWERED = BlockProperties.t;
+
+    protected BlockPoweredRail(Block.Info block_info) {
+        super(true, block_info);
+        this.v((IBlockData) ((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.NORTH_SOUTH)).set(BlockPoweredRail.POWERED, false));
+    }
+
+    protected boolean a(World world, BlockPosition blockposition, IBlockData iblockdata, boolean flag, int i) {
+        if (i >= 8) {
+            return false;
+        } else {
+            int j = blockposition.getX();
+            int k = blockposition.getY();
+            int l = blockposition.getZ();
+            boolean flag1 = true;
+            BlockPropertyTrackPosition blockpropertytrackposition = (BlockPropertyTrackPosition) iblockdata.get(BlockPoweredRail.SHAPE);
+
+            switch (blockpropertytrackposition) {
+            case NORTH_SOUTH:
+                if (flag) {
+                    ++l;
+                } else {
+                    --l;
+                }
+                break;
+            case EAST_WEST:
+                if (flag) {
+                    --j;
+                } else {
+                    ++j;
+                }
+                break;
+            case ASCENDING_EAST:
+                if (flag) {
+                    --j;
+                } else {
+                    ++j;
+                    ++k;
+                    flag1 = false;
+                }
+
+                blockpropertytrackposition = BlockPropertyTrackPosition.EAST_WEST;
+                break;
+            case ASCENDING_WEST:
+                if (flag) {
+                    --j;
+                    ++k;
+                    flag1 = false;
+                } else {
+                    ++j;
+                }
+
+                blockpropertytrackposition = BlockPropertyTrackPosition.EAST_WEST;
+                break;
+            case ASCENDING_NORTH:
+                if (flag) {
+                    ++l;
+                } else {
+                    --l;
+                    ++k;
+                    flag1 = false;
+                }
+
+                blockpropertytrackposition = BlockPropertyTrackPosition.NORTH_SOUTH;
+                break;
+            case ASCENDING_SOUTH:
+                if (flag) {
+                    ++l;
+                    ++k;
+                    flag1 = false;
+                } else {
+                    --l;
+                }
+
+                blockpropertytrackposition = BlockPropertyTrackPosition.NORTH_SOUTH;
+            }
+
+            return this.a(world, new BlockPosition(j, k, l), flag, i, blockpropertytrackposition) ? true : flag1 && this.a(world, new BlockPosition(j, k - 1, l), flag, i, blockpropertytrackposition);
+        }
+    }
+
+    protected boolean a(World world, BlockPosition blockposition, boolean flag, int i, BlockPropertyTrackPosition blockpropertytrackposition) {
+        IBlockData iblockdata = world.getType(blockposition);
+
+        if (iblockdata.getBlock() != this) {
+            return false;
+        } else {
+            BlockPropertyTrackPosition blockpropertytrackposition1 = (BlockPropertyTrackPosition) iblockdata.get(BlockPoweredRail.SHAPE);
+
+            return blockpropertytrackposition == BlockPropertyTrackPosition.EAST_WEST && (blockpropertytrackposition1 == BlockPropertyTrackPosition.NORTH_SOUTH || blockpropertytrackposition1 == BlockPropertyTrackPosition.ASCENDING_NORTH || blockpropertytrackposition1 == BlockPropertyTrackPosition.ASCENDING_SOUTH) ? false : (blockpropertytrackposition == BlockPropertyTrackPosition.NORTH_SOUTH && (blockpropertytrackposition1 == BlockPropertyTrackPosition.EAST_WEST || blockpropertytrackposition1 == BlockPropertyTrackPosition.ASCENDING_EAST || blockpropertytrackposition1 == BlockPropertyTrackPosition.ASCENDING_WEST) ? false : ((Boolean) iblockdata.get(BlockPoweredRail.POWERED) ? (world.isBlockIndirectlyPowered(blockposition) ? true : this.a(world, blockposition, iblockdata, flag, i + 1)) : false));
+        }
+    }
+
+    protected void a(IBlockData iblockdata, World world, BlockPosition blockposition, Block block) {
+        boolean flag = (Boolean) iblockdata.get(BlockPoweredRail.POWERED);
+        boolean flag1 = world.isBlockIndirectlyPowered(blockposition) || this.a(world, blockposition, iblockdata, true, 0) || this.a(world, blockposition, iblockdata, false, 0);
+
+        if (flag1 != flag) {
+            // CraftBukkit start
+            int power = flag ? 15 : 0;
+            int newPower = CraftEventFactory.callRedstoneChange(world, blockposition, power, 15 - power).getNewCurrent();
+            if (newPower == power) {
+                return;
+            }
+            // CraftBukkit end
+            world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockPoweredRail.POWERED, flag1), 3);
+            world.applyPhysics(blockposition.down(), this);
+            if (((BlockPropertyTrackPosition) iblockdata.get(BlockPoweredRail.SHAPE)).c()) {
+                world.applyPhysics(blockposition.up(), this);
+            }
+        }
+
+    }
+
+    public IBlockState<BlockPropertyTrackPosition> e() {
+        return BlockPoweredRail.SHAPE;
+    }
+
+    public IBlockData a(IBlockData iblockdata, EnumBlockRotation enumblockrotation) {
+        switch (enumblockrotation) {
+        case CLOCKWISE_180:
+            switch ((BlockPropertyTrackPosition) iblockdata.get(BlockPoweredRail.SHAPE)) {
+            case ASCENDING_EAST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.ASCENDING_WEST);
+            case ASCENDING_WEST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.ASCENDING_EAST);
+            case ASCENDING_NORTH:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.ASCENDING_SOUTH);
+            case ASCENDING_SOUTH:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.ASCENDING_NORTH);
+            case SOUTH_EAST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.NORTH_WEST);
+            case SOUTH_WEST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.NORTH_EAST);
+            case NORTH_WEST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.SOUTH_EAST);
+            case NORTH_EAST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.SOUTH_WEST);
+            }
+        case COUNTERCLOCKWISE_90:
+            switch ((BlockPropertyTrackPosition) iblockdata.get(BlockPoweredRail.SHAPE)) {
+            case NORTH_SOUTH:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.EAST_WEST);
+            case EAST_WEST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.NORTH_SOUTH);
+            case ASCENDING_EAST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.ASCENDING_NORTH);
+            case ASCENDING_WEST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.ASCENDING_SOUTH);
+            case ASCENDING_NORTH:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.ASCENDING_WEST);
+            case ASCENDING_SOUTH:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.ASCENDING_EAST);
+            case SOUTH_EAST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.NORTH_EAST);
+            case SOUTH_WEST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.SOUTH_EAST);
+            case NORTH_WEST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.SOUTH_WEST);
+            case NORTH_EAST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.NORTH_WEST);
+            }
+        case CLOCKWISE_90:
+            switch ((BlockPropertyTrackPosition) iblockdata.get(BlockPoweredRail.SHAPE)) {
+            case NORTH_SOUTH:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.EAST_WEST);
+            case EAST_WEST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.NORTH_SOUTH);
+            case ASCENDING_EAST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.ASCENDING_SOUTH);
+            case ASCENDING_WEST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.ASCENDING_NORTH);
+            case ASCENDING_NORTH:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.ASCENDING_EAST);
+            case ASCENDING_SOUTH:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.ASCENDING_WEST);
+            case SOUTH_EAST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.SOUTH_WEST);
+            case SOUTH_WEST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.NORTH_WEST);
+            case NORTH_WEST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.NORTH_EAST);
+            case NORTH_EAST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.SOUTH_EAST);
+            }
+        default:
+            return iblockdata;
+        }
+    }
+
+    public IBlockData a(IBlockData iblockdata, EnumBlockMirror enumblockmirror) {
+        BlockPropertyTrackPosition blockpropertytrackposition = (BlockPropertyTrackPosition) iblockdata.get(BlockPoweredRail.SHAPE);
+
+        switch (enumblockmirror) {
+        case LEFT_RIGHT:
+            switch (blockpropertytrackposition) {
+            case ASCENDING_NORTH:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.ASCENDING_SOUTH);
+            case ASCENDING_SOUTH:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.ASCENDING_NORTH);
+            case SOUTH_EAST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.NORTH_EAST);
+            case SOUTH_WEST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.NORTH_WEST);
+            case NORTH_WEST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.SOUTH_WEST);
+            case NORTH_EAST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.SOUTH_EAST);
+            default:
+                return super.a(iblockdata, enumblockmirror);
+            }
+        case FRONT_BACK:
+            switch (blockpropertytrackposition) {
+            case ASCENDING_EAST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.ASCENDING_WEST);
+            case ASCENDING_WEST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.ASCENDING_EAST);
+            case ASCENDING_NORTH:
+            case ASCENDING_SOUTH:
+            default:
+                break;
+            case SOUTH_EAST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.SOUTH_WEST);
+            case SOUTH_WEST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.SOUTH_EAST);
+            case NORTH_WEST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.NORTH_EAST);
+            case NORTH_EAST:
+                return (IBlockData) iblockdata.set(BlockPoweredRail.SHAPE, BlockPropertyTrackPosition.NORTH_WEST);
+            }
+        }
+
+        return super.a(iblockdata, enumblockmirror);
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockPoweredRail.SHAPE, BlockPoweredRail.POWERED);
+    }
+}

src/main/java/net/minecraft/server/BlockPressurePlateAbstract.java

@@ -0,0 +1,146 @@
+package net.minecraft.server;
+
+import java.util.Random;
+
+import org.bukkit.event.block.BlockRedstoneEvent; // CraftBukkit
+
+public abstract class BlockPressurePlateAbstract extends Block {
+
+    protected static final VoxelShape a = Block.a(1.0D, 0.0D, 1.0D, 15.0D, 0.5D, 15.0D);
+    protected static final VoxelShape b = Block.a(1.0D, 0.0D, 1.0D, 15.0D, 1.0D, 15.0D);
+    protected static final AxisAlignedBB c = new AxisAlignedBB(0.125D, 0.0D, 0.125D, 0.875D, 0.25D, 0.875D);
+
+    protected BlockPressurePlateAbstract(Block.Info block_info) {
+        super(block_info);
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return this.getPower(iblockdata) > 0 ? BlockPressurePlateAbstract.a : BlockPressurePlateAbstract.b;
+    }
+
+    public int a(IWorldReader iworldreader) {
+        return 20;
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public boolean a() {
+        return true;
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        return enumdirection == EnumDirection.DOWN && !iblockdata.canPlace(generatoraccess, blockposition) ? Blocks.AIR.getBlockData() : super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
+    }
+
+    public boolean canPlace(IBlockData iblockdata, IWorldReader iworldreader, BlockPosition blockposition) {
+        IBlockData iblockdata1 = iworldreader.getType(blockposition.down());
+
+        return iblockdata1.q() || iblockdata1.getBlock() instanceof BlockFence;
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if (!world.isClientSide) {
+            int i = this.getPower(iblockdata);
+
+            if (i > 0) {
+                this.a(world, blockposition, iblockdata, i);
+            }
+
+        }
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
+        if (!world.isClientSide) {
+            int i = this.getPower(iblockdata);
+
+            if (i == 0) {
+                this.a(world, blockposition, iblockdata, i);
+            }
+
+        }
+    }
+
+    protected void a(World world, BlockPosition blockposition, IBlockData iblockdata, int i) {
+        int j = this.b(world, blockposition);
+        boolean flag = i > 0;
+        boolean flag1 = j > 0;
+
+        // CraftBukkit start - Interact Pressure Plate
+        org.bukkit.World bworld = world.getWorld();
+        org.bukkit.plugin.PluginManager manager = world.getServer().getPluginManager();
+
+        if (flag != flag1) {
+            BlockRedstoneEvent eventRedstone = new BlockRedstoneEvent(bworld.getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ()), i, j);
+            manager.callEvent(eventRedstone);
+
+            flag1 = eventRedstone.getNewCurrent() > 0;
+            j = eventRedstone.getNewCurrent();
+        }
+        // CraftBukkit end
+
+        if (i != j) {
+            iblockdata = this.a(iblockdata, j);
+            world.setTypeAndData(blockposition, iblockdata, 2);
+            this.a(world, blockposition);
+            world.a(blockposition, blockposition);
+        }
+
+        if (!flag1 && flag) {
+            this.b((GeneratorAccess) world, blockposition);
+        } else if (flag1 && !flag) {
+            this.a((GeneratorAccess) world, blockposition);
+        }
+
+        if (flag1) {
+            world.getBlockTickList().a(new BlockPosition(blockposition), this, this.a((IWorldReader) world));
+        }
+
+    }
+
+    protected abstract void a(GeneratorAccess generatoraccess, BlockPosition blockposition);
+
+    protected abstract void b(GeneratorAccess generatoraccess, BlockPosition blockposition);
+
+    public void remove(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1, boolean flag) {
+        if (!flag && iblockdata.getBlock() != iblockdata1.getBlock()) {
+            if (this.getPower(iblockdata) > 0) {
+                this.a(world, blockposition);
+            }
+
+            super.remove(iblockdata, world, blockposition, iblockdata1, flag);
+        }
+    }
+
+    protected void a(World world, BlockPosition blockposition) {
+        world.applyPhysics(blockposition, this);
+        world.applyPhysics(blockposition.down(), this);
+    }
+
+    public int a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, EnumDirection enumdirection) {
+        return this.getPower(iblockdata);
+    }
+
+    public int b(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, EnumDirection enumdirection) {
+        return enumdirection == EnumDirection.UP ? this.getPower(iblockdata) : 0;
+    }
+
+    public boolean isPowerSource(IBlockData iblockdata) {
+        return true;
+    }
+
+    public EnumPistonReaction getPushReaction(IBlockData iblockdata) {
+        return EnumPistonReaction.DESTROY;
+    }
+
+    protected abstract int b(World world, BlockPosition blockposition);
+
+    protected abstract int getPower(IBlockData iblockdata);
+
+    protected abstract IBlockData a(IBlockData iblockdata, int i);
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return EnumBlockFaceShape.UNDEFINED;
+    }
+}

src/main/java/net/minecraft/server/BlockPressurePlateBinary.java

@@ -0,0 +1,105 @@
+package net.minecraft.server;
+
+import java.util.Iterator;
+import java.util.List;
+
+import org.bukkit.event.entity.EntityInteractEvent; // CraftBukkit
+
+public class BlockPressurePlateBinary extends BlockPressurePlateAbstract {
+
+    public static final BlockStateBoolean POWERED = BlockProperties.t;
+    private final BlockPressurePlateBinary.EnumMobType p;
+
+    protected BlockPressurePlateBinary(BlockPressurePlateBinary.EnumMobType blockpressureplatebinary_enummobtype, Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockPressurePlateBinary.POWERED, false));
+        this.p = blockpressureplatebinary_enummobtype;
+    }
+
+    protected int getPower(IBlockData iblockdata) {
+        return (Boolean) iblockdata.get(BlockPressurePlateBinary.POWERED) ? 15 : 0;
+    }
+
+    protected IBlockData a(IBlockData iblockdata, int i) {
+        return (IBlockData) iblockdata.set(BlockPressurePlateBinary.POWERED, i > 0);
+    }
+
+    protected void a(GeneratorAccess generatoraccess, BlockPosition blockposition) {
+        if (this.material == Material.WOOD) {
+            generatoraccess.a((EntityHuman) null, blockposition, SoundEffects.BLOCK_WOODEN_PRESSURE_PLATE_CLICK_ON, SoundCategory.BLOCKS, 0.3F, 0.8F);
+        } else {
+            generatoraccess.a((EntityHuman) null, blockposition, SoundEffects.BLOCK_STONE_PRESSURE_PLATE_CLICK_ON, SoundCategory.BLOCKS, 0.3F, 0.6F);
+        }
+
+    }
+
+    protected void b(GeneratorAccess generatoraccess, BlockPosition blockposition) {
+        if (this.material == Material.WOOD) {
+            generatoraccess.a((EntityHuman) null, blockposition, SoundEffects.BLOCK_WOODEN_PRESSURE_PLATE_CLICK_OFF, SoundCategory.BLOCKS, 0.3F, 0.7F);
+        } else {
+            generatoraccess.a((EntityHuman) null, blockposition, SoundEffects.BLOCK_STONE_PRESSURE_PLATE_CLICK_OFF, SoundCategory.BLOCKS, 0.3F, 0.5F);
+        }
+
+    }
+
+    protected int b(World world, BlockPosition blockposition) {
+        AxisAlignedBB axisalignedbb = BlockPressurePlateBinary.c.a(blockposition);
+        List list;
+
+        switch (this.p) {
+        case EVERYTHING:
+            list = world.getEntities((Entity) null, axisalignedbb);
+            break;
+        case MOBS:
+            list = world.a(EntityLiving.class, axisalignedbb);
+            break;
+        default:
+            return 0;
+        }
+
+        if (!list.isEmpty()) {
+            Iterator iterator = list.iterator();
+
+            while (iterator.hasNext()) {
+                Entity entity = (Entity) iterator.next();
+
+                // CraftBukkit start - Call interact event when turning on a pressure plate
+                if (this.getPower(world.getType(blockposition)) == 0) {
+                    org.bukkit.World bworld = world.getWorld();
+                    org.bukkit.plugin.PluginManager manager = world.getServer().getPluginManager();
+                    org.bukkit.event.Cancellable cancellable;
+
+                    if (entity instanceof EntityHuman) {
+                        cancellable = org.bukkit.craftbukkit.event.CraftEventFactory.callPlayerInteractEvent((EntityHuman) entity, org.bukkit.event.block.Action.PHYSICAL, blockposition, null, null, null);
+                    } else {
+                        cancellable = new EntityInteractEvent(entity.getBukkitEntity(), bworld.getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ()));
+                        manager.callEvent((EntityInteractEvent) cancellable);
+                    }
+
+                    // We only want to block turning the plate on if all events are cancelled
+                    if (cancellable.isCancelled()) {
+                        continue;
+                    }
+                }
+                // CraftBukkit end
+
+                if (!entity.isIgnoreBlockTrigger()) {
+                    return 15;
+                }
+            }
+        }
+
+        return 0;
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockPressurePlateBinary.POWERED);
+    }
+
+    public static enum EnumMobType {
+
+        EVERYTHING, MOBS;
+
+        private EnumMobType() {}
+    }
+}

src/main/java/net/minecraft/server/BlockPressurePlateWeighted.java

@@ -0,0 +1,75 @@
+package net.minecraft.server;
+
+import org.bukkit.event.entity.EntityInteractEvent; // CraftBukkit
+
+public class BlockPressurePlateWeighted extends BlockPressurePlateAbstract {
+
+    public static final BlockStateInteger POWER = BlockProperties.al;
+    private final int weight;
+
+    protected BlockPressurePlateWeighted(int i, Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockPressurePlateWeighted.POWER, 0));
+        this.weight = i;
+    }
+
+    protected int b(World world, BlockPosition blockposition) {
+        // CraftBukkit start
+        // int i = Math.min(world.a(Entity.class, BlockPressurePlateWeighted.c.a(blockposition)).size(), this.weight);
+        int i = 0;
+        java.util.Iterator iterator = world.a(Entity.class, BlockPressurePlateWeighted.c.a(blockposition)).iterator();
+
+        while (iterator.hasNext()) {
+            Entity entity = (Entity) iterator.next();
+
+            org.bukkit.event.Cancellable cancellable;
+
+            if (entity instanceof EntityHuman) {
+                cancellable = org.bukkit.craftbukkit.event.CraftEventFactory.callPlayerInteractEvent((EntityHuman) entity, org.bukkit.event.block.Action.PHYSICAL, blockposition, null, null, null);
+            } else {
+                cancellable = new EntityInteractEvent(entity.getBukkitEntity(), world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ()));
+                world.getServer().getPluginManager().callEvent((EntityInteractEvent) cancellable);
+            }
+
+            // We only want to block turning the plate on if all events are cancelled
+            if (!cancellable.isCancelled()) {
+                i++;
+            }
+        }
+
+        i = Math.min(i, this.weight);
+        // CraftBukkit end
+
+        if (i > 0) {
+            float f = (float) Math.min(this.weight, i) / (float) this.weight;
+
+            return MathHelper.f(f * 15.0F);
+        } else {
+            return 0;
+        }
+    }
+
+    protected void a(GeneratorAccess generatoraccess, BlockPosition blockposition) {
+        generatoraccess.a((EntityHuman) null, blockposition, SoundEffects.BLOCK_METAL_PRESSURE_PLATE_CLICK_ON, SoundCategory.BLOCKS, 0.3F, 0.90000004F);
+    }
+
+    protected void b(GeneratorAccess generatoraccess, BlockPosition blockposition) {
+        generatoraccess.a((EntityHuman) null, blockposition, SoundEffects.BLOCK_METAL_PRESSURE_PLATE_CLICK_OFF, SoundCategory.BLOCKS, 0.3F, 0.75F);
+    }
+
+    protected int getPower(IBlockData iblockdata) {
+        return (Integer) iblockdata.get(BlockPressurePlateWeighted.POWER);
+    }
+
+    protected IBlockData a(IBlockData iblockdata, int i) {
+        return (IBlockData) iblockdata.set(BlockPressurePlateWeighted.POWER, i);
+    }
+
+    public int a(IWorldReader iworldreader) {
+        return 10;
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockPressurePlateWeighted.POWER);
+    }
+}

src/main/java/net/minecraft/server/BlockPumpkinCarved.java

@@ -0,0 +1,161 @@
+package net.minecraft.server;
+
+import java.util.Iterator;
+import java.util.function.Predicate;
+
+// CraftBukkit start
+import org.bukkit.craftbukkit.util.BlockStateListPopulator;
+import org.bukkit.event.block.BlockRedstoneEvent;
+import org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason;
+// CraftBukkit end
+
+public class BlockPumpkinCarved extends BlockFacingHorizontal {
+
+    public static final BlockStateDirection a = BlockFacingHorizontal.FACING;
+    private ShapeDetector b;
+    private ShapeDetector c;
+    private ShapeDetector o;
+    private ShapeDetector p;
+    private static final Predicate<IBlockData> q = (iblockdata) -> {
+        return iblockdata != null && (iblockdata.getBlock() == Blocks.CARVED_PUMPKIN || iblockdata.getBlock() == Blocks.JACK_O_LANTERN);
+    };
+
+    protected BlockPumpkinCarved(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockPumpkinCarved.a, EnumDirection.NORTH));
+    }
+
+    public void onPlace(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1) {
+        if (iblockdata1.getBlock() != iblockdata.getBlock()) {
+            this.a(world, blockposition);
+        }
+    }
+
+    public boolean a(IWorldReader iworldreader, BlockPosition blockposition) {
+        return this.d().a(iworldreader, blockposition) != null || this.f().a(iworldreader, blockposition) != null;
+    }
+
+    private void a(World world, BlockPosition blockposition) {
+        ShapeDetector.ShapeDetectorCollection shapedetector_shapedetectorcollection = this.e().a(world, blockposition);
+        int i;
+        Iterator iterator;
+        EntityPlayer entityplayer;
+        int j;
+        ShapeDetectorBlock shapedetectorblock;
+        int k;
+
+        BlockStateListPopulator blockList = new BlockStateListPopulator(world); // CraftBukkit - Use BlockStateListPopulator
+        if (shapedetector_shapedetectorcollection != null) {
+            for (i = 0; i < this.e().b(); ++i) {
+                ShapeDetectorBlock shapedetectorblock1 = shapedetector_shapedetectorcollection.a(0, i, 0);
+
+                blockList.setTypeAndData(shapedetectorblock1.getPosition(), Blocks.AIR.getBlockData(), 2); // CraftBukkit
+            }
+
+            EntitySnowman entitysnowman = EntityTypes.SNOW_GOLEM.create(world); // Paper
+            BlockPosition blockposition1 = shapedetector_shapedetectorcollection.a(0, 2, 0).getPosition();
+
+            entitysnowman.setPositionRotation((double) blockposition1.getX() + 0.5D, (double) blockposition1.getY() + 0.05D, (double) blockposition1.getZ() + 0.5D, 0.0F, 0.0F);
+            // CraftBukkit start
+            if (!world.addEntity(entitysnowman, SpawnReason.BUILD_SNOWMAN)) {
+                return;
+            }
+            blockList.updateList();
+            // CraftBukkit end
+            iterator = world.a(EntityPlayer.class, entitysnowman.getBoundingBox().g(5.0D)).iterator();
+
+            while (iterator.hasNext()) {
+                entityplayer = (EntityPlayer) iterator.next();
+                CriterionTriggers.n.a(entityplayer, (Entity) entitysnowman);
+            }
+
+            j = Block.getCombinedId(Blocks.SNOW_BLOCK.getBlockData());
+            world.triggerEffect(2001, blockposition1, j);
+            world.triggerEffect(2001, blockposition1.up(), j);
+
+            for (k = 0; k < this.e().b(); ++k) {
+                shapedetectorblock = shapedetector_shapedetectorcollection.a(0, k, 0);
+                world.update(shapedetectorblock.getPosition(), Blocks.AIR);
+            }
+        } else {
+            shapedetector_shapedetectorcollection = this.g().a(world, blockposition);
+            if (shapedetector_shapedetectorcollection != null) {
+                for (i = 0; i < this.g().c(); ++i) {
+                    for (int l = 0; l < this.g().b(); ++l) {
+                        blockList.setTypeAndData(shapedetector_shapedetectorcollection.a(i, l, 0).getPosition(), Blocks.AIR.getBlockData(), 2); // CraftBukkit
+                    }
+                }
+
+                BlockPosition blockposition2 = shapedetector_shapedetectorcollection.a(1, 2, 0).getPosition();
+                EntityIronGolem entityirongolem = EntityTypes.IRON_GOLEM.create(world); // Paper
+
+                entityirongolem.setPlayerCreated(true);
+                entityirongolem.setPositionRotation((double) blockposition2.getX() + 0.5D, (double) blockposition2.getY() + 0.05D, (double) blockposition2.getZ() + 0.5D, 0.0F, 0.0F);
+                // CraftBukkit start
+                if (!world.addEntity(entityirongolem, SpawnReason.BUILD_IRONGOLEM)) {
+                    return;
+                }
+                blockList.updateList();
+                // CraftBukkit end
+                iterator = world.a(EntityPlayer.class, entityirongolem.getBoundingBox().g(5.0D)).iterator();
+
+                while (iterator.hasNext()) {
+                    entityplayer = (EntityPlayer) iterator.next();
+                    CriterionTriggers.n.a(entityplayer, (Entity) entityirongolem);
+                }
+
+                for (j = 0; j < 120; ++j) {
+                    world.addParticle(Particles.E, (double) blockposition2.getX() + world.random.nextDouble(), (double) blockposition2.getY() + world.random.nextDouble() * 3.9D, (double) blockposition2.getZ() + world.random.nextDouble(), 0.0D, 0.0D, 0.0D);
+                }
+
+                for (j = 0; j < this.g().c(); ++j) {
+                    for (k = 0; k < this.g().b(); ++k) {
+                        shapedetectorblock = shapedetector_shapedetectorcollection.a(j, k, 0);
+                        world.update(shapedetectorblock.getPosition(), Blocks.AIR);
+                    }
+                }
+            }
+        }
+
+    }
+
+    public IBlockData getPlacedState(BlockActionContext blockactioncontext) {
+        return (IBlockData) this.getBlockData().set(BlockPumpkinCarved.a, blockactioncontext.f().opposite());
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockPumpkinCarved.a);
+    }
+
+    protected ShapeDetector d() {
+        if (this.b == null) {
+            this.b = ShapeDetectorBuilder.a().a(" ", "#", "#").a('#', ShapeDetectorBlock.a(BlockStatePredicate.a(Blocks.SNOW_BLOCK))).b();
+        }
+
+        return this.b;
+    }
+
+    protected ShapeDetector e() {
+        if (this.c == null) {
+            this.c = ShapeDetectorBuilder.a().a("^", "#", "#").a('^', ShapeDetectorBlock.a(BlockPumpkinCarved.q)).a('#', ShapeDetectorBlock.a(BlockStatePredicate.a(Blocks.SNOW_BLOCK))).b();
+        }
+
+        return this.c;
+    }
+
+    protected ShapeDetector f() {
+        if (this.o == null) {
+            this.o = ShapeDetectorBuilder.a().a("~ ~", "###", "~#~").a('#', ShapeDetectorBlock.a(BlockStatePredicate.a(Blocks.IRON_BLOCK))).a('~', ShapeDetectorBlock.a(MaterialPredicate.a(Material.AIR))).b();
+        }
+
+        return this.o;
+    }
+
+    protected ShapeDetector g() {
+        if (this.p == null) {
+            this.p = ShapeDetectorBuilder.a().a("~^~", "###", "~#~").a('^', ShapeDetectorBlock.a(BlockPumpkinCarved.q)).a('#', ShapeDetectorBlock.a(BlockStatePredicate.a(Blocks.IRON_BLOCK))).a('~', ShapeDetectorBlock.a(MaterialPredicate.a(Material.AIR))).b();
+        }
+
+        return this.p;
+    }
+}

src/main/java/net/minecraft/server/BlockRedstoneComparator.java

@@ -0,0 +1,161 @@
+package net.minecraft.server;
+
+import java.util.List;
+import java.util.Random;
+import javax.annotation.Nullable;
+
+import org.bukkit.craftbukkit.event.CraftEventFactory; // CraftBukkit
+
+public class BlockRedstoneComparator extends BlockDiodeAbstract implements ITileEntity {
+
+    public static final BlockStateEnum<BlockPropertyComparatorMode> MODE = BlockProperties.aq;
+
+    public BlockRedstoneComparator(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockRedstoneComparator.FACING, EnumDirection.NORTH)).set(BlockRedstoneComparator.c, false)).set(BlockRedstoneComparator.MODE, BlockPropertyComparatorMode.COMPARE));
+    }
+
+    protected int k(IBlockData iblockdata) {
+        return 2;
+    }
+
+    protected int b(IBlockAccess iblockaccess, BlockPosition blockposition, IBlockData iblockdata) {
+        TileEntity tileentity = iblockaccess.getTileEntity(blockposition);
+
+        return tileentity instanceof TileEntityComparator ? ((TileEntityComparator) tileentity).c() : 0;
+    }
+
+    private int e(World world, BlockPosition blockposition, IBlockData iblockdata) {
+        return iblockdata.get(BlockRedstoneComparator.MODE) == BlockPropertyComparatorMode.SUBTRACT ? Math.max(this.b(world, blockposition, iblockdata) - this.b((IWorldReader) world, blockposition, iblockdata), 0) : this.b(world, blockposition, iblockdata);
+    }
+
+    protected boolean a(World world, BlockPosition blockposition, IBlockData iblockdata) {
+        int i = this.b(world, blockposition, iblockdata);
+
+        return i >= 15 ? true : (i == 0 ? false : i >= this.b((IWorldReader) world, blockposition, iblockdata));
+    }
+
+    protected void a(World world, BlockPosition blockposition) {
+        world.n(blockposition);
+    }
+
+    protected int b(World world, BlockPosition blockposition, IBlockData iblockdata) {
+        int i = super.b(world, blockposition, iblockdata);
+        EnumDirection enumdirection = (EnumDirection) iblockdata.get(BlockRedstoneComparator.FACING);
+        BlockPosition blockposition1 = blockposition.shift(enumdirection);
+        IBlockData iblockdata1 = world.getType(blockposition1);
+
+        if (iblockdata1.isComplexRedstone()) {
+            i = iblockdata1.a(world, blockposition1);
+        } else if (i < 15 && iblockdata1.isOccluding()) {
+            blockposition1 = blockposition1.shift(enumdirection);
+            iblockdata1 = world.getType(blockposition1);
+            if (iblockdata1.isComplexRedstone()) {
+                i = iblockdata1.a(world, blockposition1);
+            } else if (iblockdata1.isAir()) {
+                EntityItemFrame entityitemframe = this.a(world, enumdirection, blockposition1);
+
+                if (entityitemframe != null) {
+                    i = entityitemframe.q();
+                }
+            }
+        }
+
+        return i;
+    }
+
+    @Nullable
+    private EntityItemFrame a(World world, EnumDirection enumdirection, BlockPosition blockposition) {
+        // CraftBukkit - decompile error
+        List<EntityItemFrame> list = world.a(EntityItemFrame.class, new AxisAlignedBB((double) blockposition.getX(), (double) blockposition.getY(), (double) blockposition.getZ(), (double) (blockposition.getX() + 1), (double) (blockposition.getY() + 1), (double) (blockposition.getZ() + 1)), (java.util.function.Predicate<EntityItemFrame>) (entityitemframe) -> {
+            return entityitemframe != null && entityitemframe.getDirection() == enumdirection;
+        });
+
+        return list.size() == 1 ? (EntityItemFrame) list.get(0) : null;
+    }
+
+    public boolean interact(IBlockData iblockdata, World world, BlockPosition blockposition, EntityHuman entityhuman, EnumHand enumhand, EnumDirection enumdirection, float f, float f1, float f2) {
+        if (!entityhuman.abilities.mayBuild) {
+            return false;
+        } else {
+            iblockdata = (IBlockData) iblockdata.a((IBlockState) BlockRedstoneComparator.MODE);
+            float f3 = iblockdata.get(BlockRedstoneComparator.MODE) == BlockPropertyComparatorMode.SUBTRACT ? 0.55F : 0.5F;
+
+            world.a(entityhuman, blockposition, SoundEffects.BLOCK_COMPARATOR_CLICK, SoundCategory.BLOCKS, 0.3F, f3);
+            world.setTypeAndData(blockposition, iblockdata, 2);
+            this.f(world, blockposition, iblockdata);
+            return true;
+        }
+    }
+
+    protected void c(World world, BlockPosition blockposition, IBlockData iblockdata) {
+        if (!world.getBlockTickList().b(blockposition, this)) {
+            int i = this.e(world, blockposition, iblockdata);
+            TileEntity tileentity = world.getTileEntity(blockposition);
+            int j = tileentity instanceof TileEntityComparator ? ((TileEntityComparator) tileentity).c() : 0;
+
+            if (i != j || (Boolean) iblockdata.get(BlockRedstoneComparator.c) != this.a(world, blockposition, iblockdata)) {
+                TickListPriority ticklistpriority = this.c((IBlockAccess) world, blockposition, iblockdata) ? TickListPriority.HIGH : TickListPriority.NORMAL;
+
+                world.getBlockTickList().a(blockposition, this, 2, ticklistpriority);
+            }
+
+        }
+    }
+
+    private void f(World world, BlockPosition blockposition, IBlockData iblockdata) {
+        int i = this.e(world, blockposition, iblockdata);
+        TileEntity tileentity = world.getTileEntity(blockposition);
+        int j = 0;
+
+        if (tileentity instanceof TileEntityComparator) {
+            TileEntityComparator tileentitycomparator = (TileEntityComparator) tileentity;
+
+            j = tileentitycomparator.c();
+            tileentitycomparator.a(i);
+        }
+
+        if (j != i || iblockdata.get(BlockRedstoneComparator.MODE) == BlockPropertyComparatorMode.COMPARE) {
+            boolean flag = this.a(world, blockposition, iblockdata);
+            boolean flag1 = (Boolean) iblockdata.get(BlockRedstoneComparator.c);
+
+            if (flag1 && !flag) {
+                // CraftBukkit start
+                if (CraftEventFactory.callRedstoneChange(world, blockposition, 15, 0).getNewCurrent() != 0) {
+                    return;
+                }
+                // CraftBukkit end
+                world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockRedstoneComparator.c, false), 2);
+            } else if (!flag1 && flag) {
+                // CraftBukkit start
+                if (CraftEventFactory.callRedstoneChange(world, blockposition, 0, 15).getNewCurrent() != 15) {
+                    return;
+                }
+                // CraftBukkit end
+                world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockRedstoneComparator.c, true), 2);
+            }
+
+            this.d(world, blockposition, iblockdata);
+        }
+
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        this.f(world, blockposition, iblockdata);
+    }
+
+    public boolean a(IBlockData iblockdata, World world, BlockPosition blockposition, int i, int j) {
+        super.a(iblockdata, world, blockposition, i, j);
+        TileEntity tileentity = world.getTileEntity(blockposition);
+
+        return tileentity != null && tileentity.c(i, j);
+    }
+
+    public TileEntity a(IBlockAccess iblockaccess) {
+        return new TileEntityComparator();
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockRedstoneComparator.FACING, BlockRedstoneComparator.MODE, BlockRedstoneComparator.c);
+    }
+}

src/main/java/net/minecraft/server/BlockRedstoneLamp.java

@@ -0,0 +1,67 @@
+package net.minecraft.server;
+
+import java.util.Random;
+import javax.annotation.Nullable;
+
+import org.bukkit.craftbukkit.event.CraftEventFactory; // CraftBukkit
+
+public class BlockRedstoneLamp extends Block {
+
+    public static final BlockStateBoolean a = BlockRedstoneTorch.LIT;
+
+    public BlockRedstoneLamp(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) this.getBlockData().set(BlockRedstoneLamp.a, false));
+    }
+
+    public int m(IBlockData iblockdata) {
+        return (Boolean) iblockdata.get(BlockRedstoneLamp.a) ? super.m(iblockdata) : 0;
+    }
+
+    public void onPlace(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1) {
+        super.onPlace(iblockdata, world, blockposition, iblockdata1);
+    }
+
+    @Nullable
+    public IBlockData getPlacedState(BlockActionContext blockactioncontext) {
+        return (IBlockData) this.getBlockData().set(BlockRedstoneLamp.a, blockactioncontext.getWorld().isBlockIndirectlyPowered(blockactioncontext.getClickPosition()));
+    }
+
+    public void doPhysics(IBlockData iblockdata, World world, BlockPosition blockposition, Block block, BlockPosition blockposition1) {
+        if (!world.isClientSide) {
+            boolean flag = (Boolean) iblockdata.get(BlockRedstoneLamp.a);
+
+            if (flag != world.isBlockIndirectlyPowered(blockposition)) {
+                if (flag) {
+                    world.getBlockTickList().a(blockposition, this, 4);
+                } else {
+                    // CraftBukkit start
+                    if (CraftEventFactory.callRedstoneChange(world, blockposition, 0, 15).getNewCurrent() != 15) {
+                        return;
+                    }
+                    // CraftBukkit end
+                    world.setTypeAndData(blockposition, (IBlockData) iblockdata.a((IBlockState) BlockRedstoneLamp.a), 2);
+                }
+            }
+
+        }
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if (!world.isClientSide) {
+            if ((Boolean) iblockdata.get(BlockRedstoneLamp.a) && !world.isBlockIndirectlyPowered(blockposition)) {
+                // CraftBukkit start
+                if (CraftEventFactory.callRedstoneChange(world, blockposition, 15, 0).getNewCurrent() != 0) {
+                    return;
+                }
+                // CraftBukkit end
+                world.setTypeAndData(blockposition, (IBlockData) iblockdata.a((IBlockState) BlockRedstoneLamp.a), 2);
+            }
+
+        }
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockRedstoneLamp.a);
+    }
+}

src/main/java/net/minecraft/server/BlockRedstoneOre.java

@@ -0,0 +1,139 @@
+package net.minecraft.server;
+
+import java.util.Random;
+
+// CraftBukkit start
+import org.bukkit.craftbukkit.event.CraftEventFactory;
+import org.bukkit.event.entity.EntityInteractEvent;
+// CraftBukkit end
+
+public class BlockRedstoneOre extends Block {
+
+    public static final BlockStateBoolean a = BlockRedstoneTorch.LIT;
+
+    public BlockRedstoneOre(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) this.getBlockData().set(BlockRedstoneOre.a, false));
+    }
+
+    public int m(IBlockData iblockdata) {
+        return (Boolean) iblockdata.get(BlockRedstoneOre.a) ? super.m(iblockdata) : 0;
+    }
+
+    public void attack(IBlockData iblockdata, World world, BlockPosition blockposition, EntityHuman entityhuman) {
+        interact(iblockdata, world, blockposition, entityhuman); // CraftBukkit - add entityhuman
+        super.attack(iblockdata, world, blockposition, entityhuman);
+    }
+
+    public void stepOn(World world, BlockPosition blockposition, Entity entity) {
+        // CraftBukkit start
+        // interact(world.getType(blockposition), world, blockposition);
+        // super.stepOn(world, blockposition, entity);
+        if (entity instanceof EntityHuman) {
+            org.bukkit.event.player.PlayerInteractEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callPlayerInteractEvent((EntityHuman) entity, org.bukkit.event.block.Action.PHYSICAL, blockposition, null, null, null);
+            if (!event.isCancelled()) {
+                interact(world.getType(blockposition), world, blockposition, entity); // add entity
+                super.stepOn(world, blockposition, entity);
+            }
+        } else {
+            EntityInteractEvent event = new EntityInteractEvent(entity.getBukkitEntity(), world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ()));
+            world.getServer().getPluginManager().callEvent(event);
+            if (!event.isCancelled()) {
+                interact(world.getType(blockposition), world, blockposition, entity); // add entity
+                super.stepOn(world, blockposition, entity);
+            }
+        }
+        // CraftBukkit end
+    }
+
+    public boolean interact(IBlockData iblockdata, World world, BlockPosition blockposition, EntityHuman entityhuman, EnumHand enumhand, EnumDirection enumdirection, float f, float f1, float f2) {
+        interact(iblockdata, world, blockposition, entityhuman); // CraftBukkit - add entityhuman
+        return super.interact(iblockdata, world, blockposition, entityhuman, enumhand, enumdirection, f, f1, f2);
+    }
+
+    private static void interact(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) { // CraftBukkit - add Entity
+        playEffect(world, blockposition);
+        if (!(Boolean) iblockdata.get(BlockRedstoneOre.a)) {
+            // CraftBukkit start
+            if (CraftEventFactory.callEntityChangeBlockEvent(entity, blockposition, iblockdata.set(BlockRedstoneOre.a, true)).isCancelled()) {
+                return;
+            }
+            // CraftBukkit end
+            world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockRedstoneOre.a, true), 3);
+        }
+
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if ((Boolean) iblockdata.get(BlockRedstoneOre.a)) {
+            // CraftBukkit start
+            if (CraftEventFactory.callBlockFadeEvent(world, blockposition, iblockdata.set(BlockRedstoneOre.a, false)).isCancelled()) {
+                return;
+            }
+            // CraftBukkit end
+            world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockRedstoneOre.a, false), 3);
+        }
+
+    }
+
+    public IMaterial getDropType(IBlockData iblockdata, World world, BlockPosition blockposition, int i) {
+        return Items.REDSTONE;
+    }
+
+    public int getDropCount(IBlockData iblockdata, int i, World world, BlockPosition blockposition, Random random) {
+        return this.a(iblockdata, random) + random.nextInt(i + 1);
+    }
+
+    public int a(IBlockData iblockdata, Random random) {
+        return 4 + random.nextInt(2);
+    }
+
+    public void dropNaturally(IBlockData iblockdata, World world, BlockPosition blockposition, float f, int i) {
+        super.dropNaturally(iblockdata, world, blockposition, f, i);
+        /* CraftBukkit start - Delegated to getExpDrop
+        if (this.getDropType(iblockdata, world, blockposition, i) != this) {
+            int j = 1 + world.random.nextInt(5);
+
+            this.dropExperience(world, blockposition, j);
+        }
+        // */
+
+    }
+
+    @Override
+    public int getExpDrop(IBlockData iblockdata, World world, BlockPosition blockposition, int enchantmentLevel) {
+        if (this.getDropType(iblockdata, world, blockposition, enchantmentLevel) != this) {
+            int j = 1 + world.random.nextInt(5);
+
+            return j;
+        }
+        return 0;
+        // CraftBukkit end
+    }
+
+    private static void playEffect(World world, BlockPosition blockposition) {
+        double d0 = 0.5625D;
+        Random random = world.random;
+        EnumDirection[] aenumdirection = EnumDirection.values();
+        int i = aenumdirection.length;
+
+        for (int j = 0; j < i; ++j) {
+            EnumDirection enumdirection = aenumdirection[j];
+            BlockPosition blockposition1 = blockposition.shift(enumdirection);
+
+            if (!world.getType(blockposition1).f(world, blockposition1)) {
+                EnumDirection.EnumAxis enumdirection_enumaxis = enumdirection.k();
+                double d1 = enumdirection_enumaxis == EnumDirection.EnumAxis.X ? 0.5D + 0.5625D * (double) enumdirection.getAdjacentX() : (double) random.nextFloat();
+                double d2 = enumdirection_enumaxis == EnumDirection.EnumAxis.Y ? 0.5D + 0.5625D * (double) enumdirection.getAdjacentY() : (double) random.nextFloat();
+                double d3 = enumdirection_enumaxis == EnumDirection.EnumAxis.Z ? 0.5D + 0.5625D * (double) enumdirection.getAdjacentZ() : (double) random.nextFloat();
+
+                world.addParticle(ParticleParamRedstone.a, (double) blockposition.getX() + d1, (double) blockposition.getY() + d2, (double) blockposition.getZ() + d3, 0.0D, 0.0D, 0.0D);
+            }
+        }
+
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockRedstoneOre.a);
+    }
+}

src/main/java/net/minecraft/server/BlockRedstoneTorch.java

@@ -0,0 +1,187 @@
+package net.minecraft.server;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+
+import org.bukkit.event.block.BlockRedstoneEvent; // CraftBukkit
+
+public class BlockRedstoneTorch extends BlockTorch {
+
+    public static final BlockStateBoolean LIT = BlockProperties.o;
+    private static final Map<IBlockAccess, List<BlockRedstoneTorch.RedstoneUpdateInfo>> b = new java.util.WeakHashMap(); // Spigot
+
+    protected BlockRedstoneTorch(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockRedstoneTorch.LIT, true));
+    }
+
+    public int a(IWorldReader iworldreader) {
+        return 2;
+    }
+
+    public void onPlace(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1) {
+        EnumDirection[] aenumdirection = EnumDirection.values();
+        int i = aenumdirection.length;
+
+        for (int j = 0; j < i; ++j) {
+            EnumDirection enumdirection = aenumdirection[j];
+
+            world.applyPhysics(blockposition.shift(enumdirection), this);
+        }
+
+    }
+
+    public void remove(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1, boolean flag) {
+        if (!flag) {
+            EnumDirection[] aenumdirection = EnumDirection.values();
+            int i = aenumdirection.length;
+
+            for (int j = 0; j < i; ++j) {
+                EnumDirection enumdirection = aenumdirection[j];
+
+                world.applyPhysics(blockposition.shift(enumdirection), this);
+            }
+
+        }
+    }
+
+    public int a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, EnumDirection enumdirection) {
+        return (Boolean) iblockdata.get(BlockRedstoneTorch.LIT) && EnumDirection.UP != enumdirection ? 15 : 0;
+    }
+
+    protected boolean a(World world, BlockPosition blockposition, IBlockData iblockdata) {
+        return world.isBlockFacePowered(blockposition.down(), EnumDirection.DOWN);
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        a(iblockdata, world, blockposition, random, this.a(world, blockposition, iblockdata));
+    }
+
+    public static void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random, boolean flag) {
+        List list = (List) BlockRedstoneTorch.b.get(world);
+
+        // Paper start
+        if (list != null) {
+            int index = 0;
+            while (index < list.size() && world.getTime() - ((BlockRedstoneTorch.RedstoneUpdateInfo) list.get(index)).getTime() > 60L) {
+                index++;
+            }
+            if (index > 0) {
+                list.subList(0, index).clear();
+            }
+        }
+        // Paper end
+
+        // CraftBukkit start
+        org.bukkit.plugin.PluginManager manager = world.getServer().getPluginManager();
+        org.bukkit.block.Block block = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
+        int oldCurrent = ((Boolean) iblockdata.get(BlockRedstoneTorch.LIT)).booleanValue() ? 15 : 0;
+
+        BlockRedstoneEvent event = new BlockRedstoneEvent(block, oldCurrent, oldCurrent);
+        // CraftBukkit end
+        if ((Boolean) iblockdata.get(BlockRedstoneTorch.LIT)) {
+            if (flag) {
+                // CraftBukkit start
+                if (oldCurrent != 0) {
+                    event.setNewCurrent(0);
+                    manager.callEvent(event);
+                    if (event.getNewCurrent() != 0) {
+                        return;
+                    }
+                }
+                // CraftBukkit end
+                world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockRedstoneTorch.LIT, false), 3);
+                if (a(world, blockposition, true)) {
+                    world.a((EntityHuman) null, blockposition, SoundEffects.BLOCK_REDSTONE_TORCH_BURNOUT, SoundCategory.BLOCKS, 0.5F, 2.6F + (world.random.nextFloat() - world.random.nextFloat()) * 0.8F);
+
+                    for (int i = 0; i < 5; ++i) {
+                        double d0 = (double) blockposition.getX() + random.nextDouble() * 0.6D + 0.2D;
+                        double d1 = (double) blockposition.getY() + random.nextDouble() * 0.6D + 0.2D;
+                        double d2 = (double) blockposition.getZ() + random.nextDouble() * 0.6D + 0.2D;
+
+                        world.addParticle(Particles.M, d0, d1, d2, 0.0D, 0.0D, 0.0D);
+                    }
+
+                    world.getBlockTickList().a(blockposition, world.getType(blockposition).getBlock(), 160);
+                }
+            }
+        } else if (!flag && !a(world, blockposition, false)) {
+            // CraftBukkit start
+            if (oldCurrent != 15) {
+                event.setNewCurrent(15);
+                manager.callEvent(event);
+                if (event.getNewCurrent() != 15) {
+                    return;
+                }
+            }
+            // CraftBukkit end
+            world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockRedstoneTorch.LIT, true), 3);
+        }
+
+    }
+
+    public void doPhysics(IBlockData iblockdata, World world, BlockPosition blockposition, Block block, BlockPosition blockposition1) {
+        if ((Boolean) iblockdata.get(BlockRedstoneTorch.LIT) == this.a(world, blockposition, iblockdata) && !world.getBlockTickList().b(blockposition, this)) {
+            world.getBlockTickList().a(blockposition, this, this.a((IWorldReader) world));
+        }
+
+    }
+
+    public int b(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, EnumDirection enumdirection) {
+        return enumdirection == EnumDirection.DOWN ? iblockdata.a(iblockaccess, blockposition, enumdirection) : 0;
+    }
+
+    public boolean isPowerSource(IBlockData iblockdata) {
+        return true;
+    }
+
+    public int m(IBlockData iblockdata) {
+        return (Boolean) iblockdata.get(BlockRedstoneTorch.LIT) ? super.m(iblockdata) : 0;
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockRedstoneTorch.LIT);
+    }
+
+    private static boolean a(World world, BlockPosition blockposition, boolean flag) {
+        List<BlockRedstoneTorch.RedstoneUpdateInfo> list = (List) BlockRedstoneTorch.b.get(world);
+
+        if (list == null) {
+            list = Lists.newArrayList();
+            BlockRedstoneTorch.b.put(world, list);
+        }
+
+        if (flag) {
+            ((List) list).add(new BlockRedstoneTorch.RedstoneUpdateInfo(blockposition.h(), world.getTime()));
+        }
+
+        int i = 0;
+
+        for (int j = 0; j < ((List) list).size(); ++j) {
+            BlockRedstoneTorch.RedstoneUpdateInfo blockredstonetorch_redstoneupdateinfo = (BlockRedstoneTorch.RedstoneUpdateInfo) ((List) list).get(j);
+
+            if (blockredstonetorch_redstoneupdateinfo.a.equals(blockposition)) {
+                ++i;
+                if (i >= 8) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    public static class RedstoneUpdateInfo {
+
+        private final BlockPosition a;
+        private final long b; final long getTime() { return this.b; } // Paper - OBFHELPER
+
+        public RedstoneUpdateInfo(BlockPosition blockposition, long i) {
+            this.a = blockposition;
+            this.b = i;
+        }
+    }
+}

src/main/java/net/minecraft/server/BlockRedstoneWire.java

@@ -0,0 +1,585 @@
+package net.minecraft.server;
+
+import com.destroystokyo.paper.PaperConfig;
+import com.destroystokyo.paper.util.RedstoneWireTurbo;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import java.util.EnumSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import javax.annotation.Nullable;
+
+import org.bukkit.event.block.BlockRedstoneEvent; // CraftBukkit
+
+public class BlockRedstoneWire extends Block {
+
+    public static final BlockStateEnum<BlockPropertyRedstoneSide> NORTH = BlockProperties.M;
+    public static final BlockStateEnum<BlockPropertyRedstoneSide> EAST = BlockProperties.L;
+    public static final BlockStateEnum<BlockPropertyRedstoneSide> SOUTH = BlockProperties.N;
+    public static final BlockStateEnum<BlockPropertyRedstoneSide> WEST = BlockProperties.O;
+    public static final BlockStateInteger POWER = BlockProperties.al;
+    public static final Map<EnumDirection, BlockStateEnum<BlockPropertyRedstoneSide>> q = Maps.newEnumMap(ImmutableMap.of(EnumDirection.NORTH, BlockRedstoneWire.NORTH, EnumDirection.EAST, BlockRedstoneWire.EAST, EnumDirection.SOUTH, BlockRedstoneWire.SOUTH, EnumDirection.WEST, BlockRedstoneWire.WEST));
+    protected static final VoxelShape[] r = new VoxelShape[] { Block.a(3.0D, 0.0D, 3.0D, 13.0D, 1.0D, 13.0D), Block.a(3.0D, 0.0D, 3.0D, 13.0D, 1.0D, 16.0D), Block.a(0.0D, 0.0D, 3.0D, 13.0D, 1.0D, 13.0D), Block.a(0.0D, 0.0D, 3.0D, 13.0D, 1.0D, 16.0D), Block.a(3.0D, 0.0D, 0.0D, 13.0D, 1.0D, 13.0D), Block.a(3.0D, 0.0D, 0.0D, 13.0D, 1.0D, 16.0D), Block.a(0.0D, 0.0D, 0.0D, 13.0D, 1.0D, 13.0D), Block.a(0.0D, 0.0D, 0.0D, 13.0D, 1.0D, 16.0D), Block.a(3.0D, 0.0D, 3.0D, 16.0D, 1.0D, 13.0D), Block.a(3.0D, 0.0D, 3.0D, 16.0D, 1.0D, 16.0D), Block.a(0.0D, 0.0D, 3.0D, 16.0D, 1.0D, 13.0D), Block.a(0.0D, 0.0D, 3.0D, 16.0D, 1.0D, 16.0D), Block.a(3.0D, 0.0D, 0.0D, 16.0D, 1.0D, 13.0D), Block.a(3.0D, 0.0D, 0.0D, 16.0D, 1.0D, 16.0D), Block.a(0.0D, 0.0D, 0.0D, 16.0D, 1.0D, 13.0D), Block.a(0.0D, 0.0D, 0.0D, 16.0D, 1.0D, 16.0D)};
+    public boolean canProvidePower() { return this.s; } // Paper - OBFHELPER
+    public void setCanProvidePower(boolean value) { this.s = value; } // Paper - OBFHELPER
+    private boolean s = true;
+    private Set<BlockPosition> getBlocksNeedingUpdate() { return this.t; } // Paper - OBFHELPER
+    private final Set<BlockPosition> t = Sets.newHashSet();
+
+    public BlockRedstoneWire(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockRedstoneWire.NORTH, BlockPropertyRedstoneSide.NONE)).set(BlockRedstoneWire.EAST, BlockPropertyRedstoneSide.NONE)).set(BlockRedstoneWire.SOUTH, BlockPropertyRedstoneSide.NONE)).set(BlockRedstoneWire.WEST, BlockPropertyRedstoneSide.NONE)).set(BlockRedstoneWire.POWER, 0));
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return BlockRedstoneWire.r[w(iblockdata)];
+    }
+
+    private static int w(IBlockData iblockdata) {
+        int i = 0;
+        boolean flag = iblockdata.get(BlockRedstoneWire.NORTH) != BlockPropertyRedstoneSide.NONE;
+        boolean flag1 = iblockdata.get(BlockRedstoneWire.EAST) != BlockPropertyRedstoneSide.NONE;
+        boolean flag2 = iblockdata.get(BlockRedstoneWire.SOUTH) != BlockPropertyRedstoneSide.NONE;
+        boolean flag3 = iblockdata.get(BlockRedstoneWire.WEST) != BlockPropertyRedstoneSide.NONE;
+
+        if (flag || flag2 && !flag && !flag1 && !flag3) {
+            i |= 1 << EnumDirection.NORTH.get2DRotationValue();
+        }
+
+        if (flag1 || flag3 && !flag && !flag1 && !flag2) {
+            i |= 1 << EnumDirection.EAST.get2DRotationValue();
+        }
+
+        if (flag2 || flag && !flag1 && !flag2 && !flag3) {
+            i |= 1 << EnumDirection.SOUTH.get2DRotationValue();
+        }
+
+        if (flag3 || flag1 && !flag && !flag2 && !flag3) {
+            i |= 1 << EnumDirection.WEST.get2DRotationValue();
+        }
+
+        return i;
+    }
+
+    public IBlockData getPlacedState(BlockActionContext blockactioncontext) {
+        World world = blockactioncontext.getWorld();
+        BlockPosition blockposition = blockactioncontext.getClickPosition();
+
+        return (IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) this.getBlockData().set(BlockRedstoneWire.WEST, this.a((IBlockAccess) world, blockposition, EnumDirection.WEST))).set(BlockRedstoneWire.EAST, this.a((IBlockAccess) world, blockposition, EnumDirection.EAST))).set(BlockRedstoneWire.NORTH, this.a((IBlockAccess) world, blockposition, EnumDirection.NORTH))).set(BlockRedstoneWire.SOUTH, this.a((IBlockAccess) world, blockposition, EnumDirection.SOUTH));
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        return enumdirection == EnumDirection.DOWN ? iblockdata : (enumdirection == EnumDirection.UP ? (IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) iblockdata.set(BlockRedstoneWire.WEST, this.a((IBlockAccess) generatoraccess, blockposition, EnumDirection.WEST))).set(BlockRedstoneWire.EAST, this.a((IBlockAccess) generatoraccess, blockposition, EnumDirection.EAST))).set(BlockRedstoneWire.NORTH, this.a((IBlockAccess) generatoraccess, blockposition, EnumDirection.NORTH))).set(BlockRedstoneWire.SOUTH, this.a((IBlockAccess) generatoraccess, blockposition, EnumDirection.SOUTH)) : (IBlockData) iblockdata.set((IBlockState) BlockRedstoneWire.q.get(enumdirection), this.a((IBlockAccess) generatoraccess, blockposition, enumdirection)));
+    }
+
+    public void b(IBlockData iblockdata, GeneratorAccess generatoraccess, BlockPosition blockposition, int i) {
+        BlockPosition.b blockposition_b = BlockPosition.b.r();
+        Throwable throwable = null;
+
+        try {
+            Iterator iterator = EnumDirection.EnumDirectionLimit.HORIZONTAL.iterator();
+
+            while (iterator.hasNext()) {
+                EnumDirection enumdirection = (EnumDirection) iterator.next();
+                BlockPropertyRedstoneSide blockpropertyredstoneside = (BlockPropertyRedstoneSide) iblockdata.get((IBlockState) BlockRedstoneWire.q.get(enumdirection));
+
+                if (blockpropertyredstoneside != BlockPropertyRedstoneSide.NONE && generatoraccess.getType(blockposition_b.g(blockposition).c(enumdirection)).getBlock() != this) {
+                    blockposition_b.c(EnumDirection.DOWN);
+                    IBlockData iblockdata1 = generatoraccess.getType(blockposition_b);
+
+                    if (iblockdata1.getBlock() != Blocks.OBSERVER) {
+                        BlockPosition blockposition1 = blockposition_b.shift(enumdirection.opposite());
+                        IBlockData iblockdata2 = iblockdata1.updateState(enumdirection.opposite(), generatoraccess.getType(blockposition1), generatoraccess, blockposition_b, blockposition1);
+
+                        a(iblockdata1, iblockdata2, generatoraccess, blockposition_b, i);
+                    }
+
+                    blockposition_b.g(blockposition).c(enumdirection).c(EnumDirection.UP);
+                    IBlockData iblockdata3 = generatoraccess.getType(blockposition_b);
+
+                    if (iblockdata3.getBlock() != Blocks.OBSERVER) {
+                        BlockPosition blockposition2 = blockposition_b.shift(enumdirection.opposite());
+                        IBlockData iblockdata4 = iblockdata3.updateState(enumdirection.opposite(), generatoraccess.getType(blockposition2), generatoraccess, blockposition_b, blockposition2);
+
+                        a(iblockdata3, iblockdata4, generatoraccess, blockposition_b, i);
+                    }
+                }
+            }
+        } catch (Throwable throwable1) {
+            throwable = throwable1;
+            throw throwable1;
+        } finally {
+            if (blockposition_b != null) {
+                if (throwable != null) {
+                    try {
+                        blockposition_b.close();
+                    } catch (Throwable throwable2) {
+                        throwable.addSuppressed(throwable2);
+                    }
+                } else {
+                    blockposition_b.close();
+                }
+            }
+
+        }
+
+    }
+
+    private BlockPropertyRedstoneSide a(IBlockAccess iblockaccess, BlockPosition blockposition, EnumDirection enumdirection) {
+        BlockPosition blockposition1 = blockposition.shift(enumdirection);
+        IBlockData iblockdata = iblockaccess.getType(blockposition.shift(enumdirection));
+        IBlockData iblockdata1 = iblockaccess.getType(blockposition.up());
+
+        if (!iblockdata1.isOccluding()) {
+            boolean flag = iblockaccess.getType(blockposition1).q() || iblockaccess.getType(blockposition1).getBlock() == Blocks.GLOWSTONE;
+
+            if (flag && k(iblockaccess.getType(blockposition1.up()))) {
+                if (iblockdata.k()) {
+                    return BlockPropertyRedstoneSide.UP;
+                }
+
+                return BlockPropertyRedstoneSide.SIDE;
+            }
+        }
+
+        return !a(iblockaccess.getType(blockposition1), enumdirection) && (iblockdata.isOccluding() || !k(iblockaccess.getType(blockposition1.down()))) ? BlockPropertyRedstoneSide.NONE : BlockPropertyRedstoneSide.SIDE;
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public boolean canPlace(IBlockData iblockdata, IWorldReader iworldreader, BlockPosition blockposition) {
+        IBlockData iblockdata1 = iworldreader.getType(blockposition.down());
+
+        return iblockdata1.q() || iblockdata1.getBlock() == Blocks.GLOWSTONE;
+    }
+
+    // Paper start - Optimize redstone
+    // The bulk of the new functionality is found in RedstoneWireTurbo.java
+    RedstoneWireTurbo turbo = new RedstoneWireTurbo(this);
+
+    /*
+     * Modified version of pre-existing updateSurroundingRedstone, which is called from
+     * this.neighborChanged and a few other methods in this class.
+     * Note: Added 'source' argument so as to help determine direction of information flow
+     */
+    private IBlockData updateSurroundingRedstone(World worldIn, BlockPosition pos, IBlockData state, BlockPosition source) {
+        if (worldIn.paperConfig.useEigencraftRedstone) {
+            return turbo.updateSurroundingRedstone(worldIn, pos, state, source);
+        }
+        return a(worldIn, pos, state);
+    }
+
+    /*
+     * Slightly modified method to compute redstone wire power levels from neighboring blocks.
+     * Modifications cut the number of power level changes by about 45% from vanilla, and this
+     * optimization synergizes well with the breadth-first search implemented in
+     * RedstoneWireTurbo.
+     * Note:  RedstoneWireTurbo contains a faster version of this code.
+     * Note:  Made this public so that RedstoneWireTurbo can access it.
+     */
+    public IBlockData calculateCurrentChanges(World worldIn, BlockPosition pos1, BlockPosition pos2, IBlockData state) {
+        IBlockData iblockstate = state;
+        int i = state.get(POWER).intValue();
+        int j = 0;
+        j = this.getPower(j, worldIn.getType(pos2));
+        this.setCanProvidePower(false);
+        int k = worldIn.isBlockIndirectlyGettingPowered(pos1);
+        this.setCanProvidePower(true);
+
+        if (!worldIn.paperConfig.useEigencraftRedstone) {
+            // This code is totally redundant to if statements just below the loop.
+            if (k > 0 && k > j - 1) {
+                j = k;
+            }
+        }
+
+        int l = 0;
+
+        // The variable 'k' holds the maximum redstone power value of any adjacent blocks.
+        // If 'k' has the highest level of all neighbors, then the power level of this
+        // redstone wire will be set to 'k'.  If 'k' is already 15, then nothing inside the
+        // following loop can affect the power level of the wire.  Therefore, the loop is
+        // skipped if k is already 15.
+        if (!worldIn.paperConfig.useEigencraftRedstone || k < 15) {
+            for (EnumDirection enumfacing : EnumDirection.EnumDirectionLimit.HORIZONTAL) {
+                BlockPosition blockpos = pos1.shift(enumfacing);
+                boolean flag = blockpos.getX() != pos2.getX() || blockpos.getZ() != pos2.getZ();
+
+                if (flag) {
+                    l = this.getPower(l, worldIn.getType(blockpos));
+                }
+
+                if (worldIn.getType(blockpos).isOccluding() && !worldIn.getType(pos1.up()).isOccluding()) {
+                    if (flag && pos1.getY() >= pos2.getY()) {
+                        l = this.getPower(l, worldIn.getType(blockpos.up()));
+                    }
+                } else if (!worldIn.getType(blockpos).isOccluding() && flag && pos1.getY() <= pos2.getY()) {
+                    l = this.getPower(l, worldIn.getType(blockpos.down()));
+                }
+            }
+        }
+
+        if (!worldIn.paperConfig.useEigencraftRedstone) {
+            // The old code would decrement the wire value only by 1 at a time.
+            if (l > j) {
+                j = l - 1;
+            } else if (j > 0) {
+                --j;
+            } else {
+                j = 0;
+            }
+
+            if (k > j - 1) {
+                j = k;
+            }
+        } else {
+            // The new code sets this RedstoneWire block's power level to the highest neighbor
+            // minus 1.  This usually results in wire power levels dropping by 2 at a time.
+            // This optimization alone has no impact on update order, only the number of updates.
+            j = l - 1;
+
+            // If 'l' turns out to be zero, then j will be set to -1, but then since 'k' will
+            // always be in the range of 0 to 15, the following if will correct that.
+            if (k > j) j = k;
+        }
+
+        if (i != j) {
+            state = state.set(POWER, Integer.valueOf(j));
+
+            if (worldIn.getType(pos1) == iblockstate) {
+                worldIn.setTypeAndData(pos1, state, 2);
+            }
+
+            if (!worldIn.paperConfig.useEigencraftRedstone) {
+                // The new search algorithm keeps track of blocks needing updates in its own data structures,
+                // so only add anything to blocksNeedingUpdate if we're using the vanilla update algorithm.
+                this.getBlocksNeedingUpdate().add(pos1);
+
+                for (EnumDirection enumfacing1 : EnumDirection.values()) {
+                    this.getBlocksNeedingUpdate().add(pos1.shift(enumfacing1));
+                }
+            }
+        }
+
+        return state;
+    }
+    // Paper end
+    private IBlockData a(World world, BlockPosition blockposition, IBlockData iblockdata) {
+        iblockdata = this.b(world, blockposition, iblockdata);
+        List<BlockPosition> list = Lists.newArrayList(this.t);
+
+        this.t.clear();
+        Iterator iterator = list.iterator();
+
+        while (iterator.hasNext()) {
+            BlockPosition blockposition1 = (BlockPosition) iterator.next();
+
+            world.applyPhysics(blockposition1, this);
+        }
+
+        return iblockdata;
+    }
+
+    private IBlockData b(World world, BlockPosition blockposition, IBlockData iblockdata) {
+        IBlockData iblockdata1 = iblockdata;
+        int i = (Integer) iblockdata.get(BlockRedstoneWire.POWER);
+        byte b0 = 0;
+        int j = this.getPower(b0, iblockdata);
+
+        this.s = false;
+        int k = world.u(blockposition);
+
+        this.s = true;
+        if (k > 0 && k > j - 1) {
+            j = k;
+        }
+
+        int l = 0;
+        Iterator iterator = EnumDirection.EnumDirectionLimit.HORIZONTAL.iterator();
+
+        while (iterator.hasNext()) {
+            EnumDirection enumdirection = (EnumDirection) iterator.next();
+            BlockPosition blockposition1 = blockposition.shift(enumdirection);
+            boolean flag = blockposition1.getX() != blockposition.getX() || blockposition1.getZ() != blockposition.getZ();
+            IBlockData iblockdata2 = world.getType(blockposition1);
+
+            if (flag) {
+                l = this.getPower(l, iblockdata2);
+            }
+
+            if (iblockdata2.isOccluding() && !world.getType(blockposition.up()).isOccluding()) {
+                if (flag && blockposition.getY() >= blockposition.getY()) {
+                    l = this.getPower(l, world.getType(blockposition1.up()));
+                }
+            } else if (!iblockdata2.isOccluding() && flag && blockposition.getY() <= blockposition.getY()) {
+                l = this.getPower(l, world.getType(blockposition1.down()));
+            }
+        }
+
+        if (l > j) {
+            j = l - 1;
+        } else if (j > 0) {
+            --j;
+        } else {
+            j = 0;
+        }
+
+        if (k > j - 1) {
+            j = k;
+        }
+
+        // CraftBukkit start
+        if (i != j) {
+            BlockRedstoneEvent event = new BlockRedstoneEvent(world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ()), i, j);
+            world.getServer().getPluginManager().callEvent(event);
+
+            j = event.getNewCurrent();
+        }
+        // CraftBukkit end
+
+        if (i != j) {
+            iblockdata = (IBlockData) iblockdata.set(BlockRedstoneWire.POWER, j);
+            if (world.getType(blockposition) == iblockdata1) {
+                world.setTypeAndData(blockposition, iblockdata, 2);
+            }
+
+            this.t.add(blockposition);
+            EnumDirection[] aenumdirection = EnumDirection.values();
+            int i1 = aenumdirection.length;
+
+            for (int j1 = 0; j1 < i1; ++j1) {
+                EnumDirection enumdirection1 = aenumdirection[j1];
+
+                this.t.add(blockposition.shift(enumdirection1));
+            }
+        }
+
+        return iblockdata;
+    }
+
+    private void a(World world, BlockPosition blockposition) {
+        if (world.getType(blockposition).getBlock() == this) {
+            world.applyPhysics(blockposition, this);
+            EnumDirection[] aenumdirection = EnumDirection.values();
+            int i = aenumdirection.length;
+
+            for (int j = 0; j < i; ++j) {
+                EnumDirection enumdirection = aenumdirection[j];
+
+                world.applyPhysics(blockposition.shift(enumdirection), this);
+            }
+
+        }
+    }
+
+    public void onPlace(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1) {
+        if (iblockdata1.getBlock() != iblockdata.getBlock() && !world.isClientSide) {
+            this.updateSurroundingRedstone(world, blockposition, iblockdata, null); // Paper - Optimize redstone
+            Iterator iterator = EnumDirection.EnumDirectionLimit.VERTICAL.iterator();
+
+            EnumDirection enumdirection;
+
+            while (iterator.hasNext()) {
+                enumdirection = (EnumDirection) iterator.next();
+                world.applyPhysics(blockposition.shift(enumdirection), this);
+            }
+
+            iterator = EnumDirection.EnumDirectionLimit.HORIZONTAL.iterator();
+
+            while (iterator.hasNext()) {
+                enumdirection = (EnumDirection) iterator.next();
+                this.a(world, blockposition.shift(enumdirection));
+            }
+
+            iterator = EnumDirection.EnumDirectionLimit.HORIZONTAL.iterator();
+
+            while (iterator.hasNext()) {
+                enumdirection = (EnumDirection) iterator.next();
+                BlockPosition blockposition1 = blockposition.shift(enumdirection);
+
+                if (world.getType(blockposition1).isOccluding()) {
+                    this.a(world, blockposition1.up());
+                } else {
+                    this.a(world, blockposition1.down());
+                }
+            }
+
+        }
+    }
+
+    public void remove(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1, boolean flag) {
+        if (!flag && iblockdata.getBlock() != iblockdata1.getBlock()) {
+            super.remove(iblockdata, world, blockposition, iblockdata1, flag);
+            if (!world.isClientSide) {
+                EnumDirection[] aenumdirection = EnumDirection.values();
+                int i = aenumdirection.length;
+
+                for (int j = 0; j < i; ++j) {
+                    EnumDirection enumdirection = aenumdirection[j];
+
+                    world.applyPhysics(blockposition.shift(enumdirection), this);
+                }
+
+                this.updateSurroundingRedstone(world, blockposition, iblockdata, null); // Paper - Optimize redstone
+                Iterator iterator = EnumDirection.EnumDirectionLimit.HORIZONTAL.iterator();
+
+                EnumDirection enumdirection1;
+
+                while (iterator.hasNext()) {
+                    enumdirection1 = (EnumDirection) iterator.next();
+                    this.a(world, blockposition.shift(enumdirection1));
+                }
+
+                iterator = EnumDirection.EnumDirectionLimit.HORIZONTAL.iterator();
+
+                while (iterator.hasNext()) {
+                    enumdirection1 = (EnumDirection) iterator.next();
+                    BlockPosition blockposition1 = blockposition.shift(enumdirection1);
+
+                    if (world.getType(blockposition1).isOccluding()) {
+                        this.a(world, blockposition1.up());
+                    } else {
+                        this.a(world, blockposition1.down());
+                    }
+                }
+
+            }
+        }
+    }
+
+    public int getPower(int i, IBlockData iblockdata) {
+        if (iblockdata.getBlock() != this) {
+            return i;
+        } else {
+            int j = (Integer) iblockdata.get(BlockRedstoneWire.POWER);
+
+            return j > i ? j : i;
+        }
+    }
+
+    public void doPhysics(IBlockData iblockdata, World world, BlockPosition blockposition, Block block, BlockPosition blockposition1) {
+        if (!world.isClientSide) {
+            if (iblockdata.canPlace(world, blockposition)) {
+                this.updateSurroundingRedstone(world, blockposition, iblockdata, blockposition1); // Paper - Optimize redstone
+            } else {
+                iblockdata.a(world, blockposition, 0);
+                world.setAir(blockposition);
+            }
+
+        }
+    }
+
+    public int b(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, EnumDirection enumdirection) {
+        return !this.s ? 0 : iblockdata.a(iblockaccess, blockposition, enumdirection);
+    }
+
+    public int a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, EnumDirection enumdirection) {
+        if (!this.s) {
+            return 0;
+        } else {
+            int i = (Integer) iblockdata.get(BlockRedstoneWire.POWER);
+
+            if (i == 0) {
+                return 0;
+            } else if (enumdirection == EnumDirection.UP) {
+                return i;
+            } else {
+                EnumSet<EnumDirection> enumset = EnumSet.noneOf(EnumDirection.class);
+                Iterator iterator = EnumDirection.EnumDirectionLimit.HORIZONTAL.iterator();
+
+                while (iterator.hasNext()) {
+                    EnumDirection enumdirection1 = (EnumDirection) iterator.next();
+
+                    if (this.b(iblockaccess, blockposition, enumdirection1)) {
+                        enumset.add(enumdirection1);
+                    }
+                }
+
+                if (enumdirection.k().c() && enumset.isEmpty()) {
+                    return i;
+                } else if (enumset.contains(enumdirection) && !enumset.contains(enumdirection.f()) && !enumset.contains(enumdirection.e())) {
+                    return i;
+                } else {
+                    return 0;
+                }
+            }
+        }
+    }
+
+    private boolean b(IBlockAccess iblockaccess, BlockPosition blockposition, EnumDirection enumdirection) {
+        BlockPosition blockposition1 = blockposition.shift(enumdirection);
+        IBlockData iblockdata = iblockaccess.getType(blockposition1);
+        boolean flag = iblockdata.isOccluding();
+        boolean flag1 = iblockaccess.getType(blockposition.up()).isOccluding();
+
+        return !flag1 && flag && a(iblockaccess, blockposition1.up()) ? true : (a(iblockdata, enumdirection) ? true : (iblockdata.getBlock() == Blocks.REPEATER && (Boolean) iblockdata.get(BlockDiodeAbstract.c) && iblockdata.get(BlockDiodeAbstract.FACING) == enumdirection ? true : !flag && a(iblockaccess, blockposition1.down())));
+    }
+
+    protected static boolean a(IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return k(iblockaccess.getType(blockposition));
+    }
+
+    protected static boolean k(IBlockData iblockdata) {
+        return a(iblockdata, (EnumDirection) null);
+    }
+
+    protected static boolean a(IBlockData iblockdata, @Nullable EnumDirection enumdirection) {
+        Block block = iblockdata.getBlock();
+
+        if (block == Blocks.REDSTONE_WIRE) {
+            return true;
+        } else if (iblockdata.getBlock() == Blocks.REPEATER) {
+            EnumDirection enumdirection1 = (EnumDirection) iblockdata.get(BlockRepeater.FACING);
+
+            return enumdirection1 == enumdirection || enumdirection1.opposite() == enumdirection;
+        } else {
+            return Blocks.OBSERVER == iblockdata.getBlock() ? enumdirection == iblockdata.get(BlockObserver.FACING) : iblockdata.isPowerSource() && enumdirection != null;
+        }
+    }
+
+    public boolean isPowerSource(IBlockData iblockdata) {
+        return this.s;
+    }
+
+    public TextureType c() {
+        return TextureType.CUTOUT;
+    }
+
+    public IBlockData a(IBlockData iblockdata, EnumBlockRotation enumblockrotation) {
+        switch (enumblockrotation) {
+        case CLOCKWISE_180:
+            return (IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) iblockdata.set(BlockRedstoneWire.NORTH, iblockdata.get(BlockRedstoneWire.SOUTH))).set(BlockRedstoneWire.EAST, iblockdata.get(BlockRedstoneWire.WEST))).set(BlockRedstoneWire.SOUTH, iblockdata.get(BlockRedstoneWire.NORTH))).set(BlockRedstoneWire.WEST, iblockdata.get(BlockRedstoneWire.EAST));
+        case COUNTERCLOCKWISE_90:
+            return (IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) iblockdata.set(BlockRedstoneWire.NORTH, iblockdata.get(BlockRedstoneWire.EAST))).set(BlockRedstoneWire.EAST, iblockdata.get(BlockRedstoneWire.SOUTH))).set(BlockRedstoneWire.SOUTH, iblockdata.get(BlockRedstoneWire.WEST))).set(BlockRedstoneWire.WEST, iblockdata.get(BlockRedstoneWire.NORTH));
+        case CLOCKWISE_90:
+            return (IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) iblockdata.set(BlockRedstoneWire.NORTH, iblockdata.get(BlockRedstoneWire.WEST))).set(BlockRedstoneWire.EAST, iblockdata.get(BlockRedstoneWire.NORTH))).set(BlockRedstoneWire.SOUTH, iblockdata.get(BlockRedstoneWire.EAST))).set(BlockRedstoneWire.WEST, iblockdata.get(BlockRedstoneWire.SOUTH));
+        default:
+            return iblockdata;
+        }
+    }
+
+    public IBlockData a(IBlockData iblockdata, EnumBlockMirror enumblockmirror) {
+        switch (enumblockmirror) {
+        case LEFT_RIGHT:
+            return (IBlockData) ((IBlockData) iblockdata.set(BlockRedstoneWire.NORTH, iblockdata.get(BlockRedstoneWire.SOUTH))).set(BlockRedstoneWire.SOUTH, iblockdata.get(BlockRedstoneWire.NORTH));
+        case FRONT_BACK:
+            return (IBlockData) ((IBlockData) iblockdata.set(BlockRedstoneWire.EAST, iblockdata.get(BlockRedstoneWire.WEST))).set(BlockRedstoneWire.WEST, iblockdata.get(BlockRedstoneWire.EAST));
+        default:
+            return super.a(iblockdata, enumblockmirror);
+        }
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockRedstoneWire.NORTH, BlockRedstoneWire.EAST, BlockRedstoneWire.SOUTH, BlockRedstoneWire.WEST, BlockRedstoneWire.POWER);
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return EnumBlockFaceShape.UNDEFINED;
+    }
+}

src/main/java/net/minecraft/server/BlockReed.java

@@ -0,0 +1,86 @@
+package net.minecraft.server;
+
+import java.util.Iterator;
+import java.util.Random;
+
+public class BlockReed extends Block {
+
+    public static final BlockStateInteger AGE = BlockProperties.X;
+    protected static final VoxelShape b = Block.a(2.0D, 0.0D, 2.0D, 14.0D, 16.0D, 14.0D);
+
+    protected BlockReed(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockReed.AGE, 0));
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return BlockReed.b;
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if (iblockdata.canPlace(world, blockposition) && world.isEmpty(blockposition.up())) {
+            int i;
+
+            for (i = 1; world.getType(blockposition.down(i)).getBlock() == this; ++i) {
+                ;
+            }
+
+                if (i < world.paperConfig.reedMaxHeight) { // Paper - Configurable growth height
+                int j = (Integer) iblockdata.get(BlockReed.AGE);
+
+                if (j >= (byte) range(3, ((100.0F / world.spigotConfig.caneModifier) * 15) + 0.5F, 15)) { // Spigot
+                    org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockGrowEvent(world, blockposition.up(), this.getBlockData()); // CraftBukkit
+                    world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockReed.AGE, 0), 4);
+                } else {
+                    world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockReed.AGE, j + 1), 4);
+                }
+            }
+        }
+
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        return !iblockdata.canPlace(generatoraccess, blockposition) ? Blocks.AIR.getBlockData() : super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
+    }
+
+    public boolean canPlace(IBlockData iblockdata, IWorldReader iworldreader, BlockPosition blockposition) {
+        Block block = iworldreader.getType(blockposition.down()).getBlock();
+
+        if (block == this) {
+            return true;
+        } else {
+            if (block == Blocks.GRASS_BLOCK || block == Blocks.DIRT || block == Blocks.COARSE_DIRT || block == Blocks.PODZOL || block == Blocks.SAND || block == Blocks.RED_SAND) {
+                BlockPosition blockposition1 = blockposition.down();
+                Iterator iterator = EnumDirection.EnumDirectionLimit.HORIZONTAL.iterator();
+
+                while (iterator.hasNext()) {
+                    EnumDirection enumdirection = (EnumDirection) iterator.next();
+                    IBlockData iblockdata1 = iworldreader.getType(blockposition1.shift(enumdirection));
+                    Fluid fluid = iworldreader.getFluid(blockposition1.shift(enumdirection));
+
+                    if (fluid.a(TagsFluid.WATER) || iblockdata1.getBlock() == Blocks.FROSTED_ICE) {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public TextureType c() {
+        return TextureType.CUTOUT;
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockReed.AGE);
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return EnumBlockFaceShape.UNDEFINED;
+    }
+}

src/main/java/net/minecraft/server/BlockSapling.java

@@ -0,0 +1,86 @@
+package net.minecraft.server;
+
+import java.util.Random;
+
+// CraftBukkit start
+import java.util.List;
+
+import org.bukkit.Location;
+import org.bukkit.TreeType;
+import org.bukkit.block.BlockState;
+import org.bukkit.event.world.StructureGrowEvent;
+// CraftBukkit end
+
+public class BlockSapling extends BlockPlant implements IBlockFragilePlantElement {
+
+    public static final BlockStateInteger STAGE = BlockProperties.am;
+    protected static final VoxelShape b = Block.a(2.0D, 0.0D, 2.0D, 14.0D, 12.0D, 14.0D);
+    private final WorldGenTreeProvider c;
+    public static TreeType treeType; // CraftBukkit
+
+    protected BlockSapling(WorldGenTreeProvider worldgentreeprovider, Block.Info block_info) {
+        super(block_info);
+        this.c = worldgentreeprovider;
+        this.v((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockSapling.STAGE, 0));
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return BlockSapling.b;
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        super.a(iblockdata, world, blockposition, random);
+        if (world.isLightLevel(blockposition.up(), 9) && random.nextInt(Math.max(2, (int) (((100.0F / world.spigotConfig.saplingModifier) * 7) + 0.5F))) == 0) { // Spigot // Paper
+            // CraftBukkit start
+            world.captureTreeGeneration = true;
+            // CraftBukkit end
+            this.grow(world, blockposition, iblockdata, random);
+            // CraftBukkit start
+            world.captureTreeGeneration = false;
+            if (world.capturedBlockStates.size() > 0) {
+                TreeType treeType = BlockSapling.treeType;
+                BlockSapling.treeType = null;
+                Location location = new Location(world.getWorld(), blockposition.getX(), blockposition.getY(), blockposition.getZ());
+                List<BlockState> blocks = (List<BlockState>) world.capturedBlockStates.clone();
+                world.capturedBlockStates.clear();
+                StructureGrowEvent event = null;
+                if (treeType != null) {
+                    event = new StructureGrowEvent(location, treeType, false, null, blocks);
+                    org.bukkit.Bukkit.getPluginManager().callEvent(event);
+                }
+                if (event == null || !event.isCancelled()) {
+                    for (BlockState blockstate : blocks) {
+                        blockstate.update(true);
+                    }
+                }
+            }
+            // CraftBukkit end
+        }
+
+    }
+
+    public void grow(GeneratorAccess generatoraccess, BlockPosition blockposition, IBlockData iblockdata, Random random) {
+        if ((Integer) iblockdata.get(BlockSapling.STAGE) == 0) {
+            generatoraccess.setTypeAndData(blockposition, (IBlockData) iblockdata.a((IBlockState) BlockSapling.STAGE), 4);
+        } else {
+            this.c.a(generatoraccess, blockposition, iblockdata, random);
+        }
+
+    }
+
+    public boolean a(IBlockAccess iblockaccess, BlockPosition blockposition, IBlockData iblockdata, boolean flag) {
+        return true;
+    }
+
+    public boolean a(World world, Random random, BlockPosition blockposition, IBlockData iblockdata) {
+        return (double) world.random.nextFloat() < 0.45D;
+    }
+
+    public void b(World world, Random random, BlockPosition blockposition, IBlockData iblockdata) {
+        this.grow(world, blockposition, iblockdata, random);
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockSapling.STAGE);
+    }
+}

src/main/java/net/minecraft/server/BlockShulkerBox.java

@@ -0,0 +1,242 @@
+package net.minecraft.server;
+
+import javax.annotation.Nullable;
+
+public class BlockShulkerBox extends BlockTileEntity {
+
+    public static final BlockStateEnum<EnumDirection> a = BlockDirectional.FACING;
+    @Nullable
+    public final EnumColor color;
+
+    public BlockShulkerBox(@Nullable EnumColor enumcolor, Block.Info block_info) {
+        super(block_info);
+        this.color = enumcolor;
+        this.v((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockShulkerBox.a, EnumDirection.UP));
+    }
+
+    public TileEntity a(IBlockAccess iblockaccess) {
+        return new TileEntityShulkerBox(this.color);
+    }
+
+    public boolean q(IBlockData iblockdata) {
+        return true;
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public EnumRenderType c(IBlockData iblockdata) {
+        return EnumRenderType.ENTITYBLOCK_ANIMATED;
+    }
+
+    public boolean interact(IBlockData iblockdata, World world, BlockPosition blockposition, EntityHuman entityhuman, EnumHand enumhand, EnumDirection enumdirection, float f, float f1, float f2) {
+        if (world.isClientSide) {
+            return true;
+        } else if (entityhuman.isSpectator()) {
+            return true;
+        } else {
+            TileEntity tileentity = world.getTileEntity(blockposition);
+
+            if (tileentity instanceof TileEntityShulkerBox) {
+                EnumDirection enumdirection1 = (EnumDirection) iblockdata.get(BlockShulkerBox.a);
+                boolean flag;
+
+                if (((TileEntityShulkerBox) tileentity).r() == TileEntityShulkerBox.AnimationPhase.CLOSED) {
+                    AxisAlignedBB axisalignedbb = VoxelShapes.b().getBoundingBox().b((double) (0.5F * (float) enumdirection1.getAdjacentX()), (double) (0.5F * (float) enumdirection1.getAdjacentY()), (double) (0.5F * (float) enumdirection1.getAdjacentZ())).a((double) enumdirection1.getAdjacentX(), (double) enumdirection1.getAdjacentY(), (double) enumdirection1.getAdjacentZ());
+
+                    flag = world.getCubes((Entity) null, axisalignedbb.a(blockposition.shift(enumdirection1)));
+                } else {
+                    flag = true;
+                }
+
+                if (flag) {
+                    entityhuman.a(StatisticList.OPEN_SHULKER_BOX);
+                    entityhuman.openContainer((IInventory) tileentity);
+                }
+
+                return true;
+            } else {
+                return false;
+            }
+        }
+    }
+
+    public IBlockData getPlacedState(BlockActionContext blockactioncontext) {
+        return (IBlockData) this.getBlockData().set(BlockShulkerBox.a, blockactioncontext.getClickedFace());
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockShulkerBox.a);
+    }
+
+    public void a(World world, BlockPosition blockposition, IBlockData iblockdata, EntityHuman entityhuman) {
+        if (world.getTileEntity(blockposition) instanceof TileEntityShulkerBox) {
+            TileEntityShulkerBox tileentityshulkerbox = (TileEntityShulkerBox) world.getTileEntity(blockposition);
+
+            tileentityshulkerbox.a(entityhuman.abilities.canInstantlyBuild);
+            tileentityshulkerbox.d(entityhuman);
+        }
+
+        super.a(world, blockposition, iblockdata, entityhuman);
+    }
+
+    // CraftBukkit start - override to prevent duplication when dropping
+    @Override
+    public void dropNaturally(IBlockData iblockdata, World world, BlockPosition blockposition, float f, int i) {
+        if (true) {
+            TileEntity tileentity = world.getTileEntity(blockposition);
+
+            if (tileentity instanceof TileEntityShulkerBox) {
+                TileEntityShulkerBox tileentityshulkerbox = (TileEntityShulkerBox) tileentity;
+
+                if (!tileentityshulkerbox.s() && tileentityshulkerbox.G()) {
+                    ItemStack itemstack = new ItemStack(this);
+
+                    itemstack.getOrCreateTag().set("BlockEntityTag", ((TileEntityShulkerBox) tileentity).g(new NBTTagCompound()));
+                    if (tileentityshulkerbox.hasCustomName()) {
+                        itemstack.a(tileentityshulkerbox.getCustomName());
+                        tileentityshulkerbox.setCustomName((IChatBaseComponent) null);
+                    }
+
+                    a(world, blockposition, itemstack);
+                    tileentityshulkerbox.clear(); // Paper - This was intended to be called in Vanilla (is checked in the if statement above if has been called) - Fixes dupe issues
+                }
+            }
+            world.updateAdjacentComparators(blockposition, iblockdata.getBlock());
+        }
+    }
+    // CraftBukkit end
+
+    public void postPlace(World world, BlockPosition blockposition, IBlockData iblockdata, EntityLiving entityliving, ItemStack itemstack) {
+        if (itemstack.hasName()) {
+            TileEntity tileentity = world.getTileEntity(blockposition);
+
+            if (tileentity instanceof TileEntityShulkerBox) {
+                ((TileEntityShulkerBox) tileentity).setCustomName(itemstack.getName());
+            }
+        }
+
+    }
+
+    public void remove(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1, boolean flag) {
+        if (iblockdata.getBlock() != iblockdata1.getBlock()) {
+            TileEntity tileentity = world.getTileEntity(blockposition);
+
+            if (false && tileentity instanceof TileEntityShulkerBox) { // CraftBukkit - moved up
+                TileEntityShulkerBox tileentityshulkerbox = (TileEntityShulkerBox) tileentity;
+
+                if (!tileentityshulkerbox.s() && tileentityshulkerbox.G()) {
+                    ItemStack itemstack = new ItemStack(this);
+
+                    itemstack.getOrCreateTag().set("BlockEntityTag", ((TileEntityShulkerBox) tileentity).g(new NBTTagCompound()));
+                    if (tileentityshulkerbox.hasCustomName()) {
+                        itemstack.a(tileentityshulkerbox.getCustomName());
+                        tileentityshulkerbox.setCustomName((IChatBaseComponent) null);
+                    }
+
+                    a(world, blockposition, itemstack);
+                }
+
+            }
+            world.updateAdjacentComparators(blockposition, iblockdata.getBlock()); // CraftBukkit - moved down
+
+            super.remove(iblockdata, world, blockposition, iblockdata1, flag);
+        }
+    }
+
+    public EnumPistonReaction getPushReaction(IBlockData iblockdata) {
+        return EnumPistonReaction.DESTROY;
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        TileEntity tileentity = iblockaccess.getTileEntity(blockposition);
+
+        return tileentity instanceof TileEntityShulkerBox ? VoxelShapes.a(((TileEntityShulkerBox) tileentity).a(iblockdata)) : VoxelShapes.b();
+    }
+
+    public boolean f(IBlockData iblockdata) {
+        return false;
+    }
+
+    public boolean isComplexRedstone(IBlockData iblockdata) {
+        return true;
+    }
+
+    public int a(IBlockData iblockdata, World world, BlockPosition blockposition) {
+        return Container.b((IInventory) world.getTileEntity(blockposition));
+    }
+
+    public ItemStack a(IBlockAccess iblockaccess, BlockPosition blockposition, IBlockData iblockdata) {
+        ItemStack itemstack = super.a(iblockaccess, blockposition, iblockdata);
+        TileEntityShulkerBox tileentityshulkerbox = (TileEntityShulkerBox) iblockaccess.getTileEntity(blockposition);
+        NBTTagCompound nbttagcompound = tileentityshulkerbox.g(new NBTTagCompound());
+
+        if (!nbttagcompound.isEmpty()) {
+            itemstack.a("BlockEntityTag", (NBTBase) nbttagcompound);
+        }
+
+        return itemstack;
+    }
+
+    public static Block a(EnumColor enumcolor) {
+        if (enumcolor == null) {
+            return Blocks.SHULKER_BOX;
+        } else {
+            switch (enumcolor) {
+            case WHITE:
+                return Blocks.WHITE_SHULKER_BOX;
+            case ORANGE:
+                return Blocks.ORANGE_SHULKER_BOX;
+            case MAGENTA:
+                return Blocks.MAGENTA_SHULKER_BOX;
+            case LIGHT_BLUE:
+                return Blocks.LIGHT_BLUE_SHULKER_BOX;
+            case YELLOW:
+                return Blocks.YELLOW_SHULKER_BOX;
+            case LIME:
+                return Blocks.LIME_SHULKER_BOX;
+            case PINK:
+                return Blocks.PINK_SHULKER_BOX;
+            case GRAY:
+                return Blocks.GRAY_SHULKER_BOX;
+            case LIGHT_GRAY:
+                return Blocks.LIGHT_GRAY_SHULKER_BOX;
+            case CYAN:
+                return Blocks.CYAN_SHULKER_BOX;
+            case PURPLE:
+            default:
+                return Blocks.PURPLE_SHULKER_BOX;
+            case BLUE:
+                return Blocks.BLUE_SHULKER_BOX;
+            case BROWN:
+                return Blocks.BROWN_SHULKER_BOX;
+            case GREEN:
+                return Blocks.GREEN_SHULKER_BOX;
+            case RED:
+                return Blocks.RED_SHULKER_BOX;
+            case BLACK:
+                return Blocks.BLACK_SHULKER_BOX;
+            }
+        }
+    }
+
+    public static ItemStack b(EnumColor enumcolor) {
+        return new ItemStack(a(enumcolor));
+    }
+
+    public IBlockData a(IBlockData iblockdata, EnumBlockRotation enumblockrotation) {
+        return (IBlockData) iblockdata.set(BlockShulkerBox.a, enumblockrotation.a((EnumDirection) iblockdata.get(BlockShulkerBox.a)));
+    }
+
+    public IBlockData a(IBlockData iblockdata, EnumBlockMirror enumblockmirror) {
+        return iblockdata.a(enumblockmirror.a((EnumDirection) iblockdata.get(BlockShulkerBox.a)));
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        EnumDirection enumdirection1 = (EnumDirection) iblockdata.get(BlockShulkerBox.a);
+        TileEntityShulkerBox.AnimationPhase tileentityshulkerbox_animationphase = ((TileEntityShulkerBox) iblockaccess.getTileEntity(blockposition)).r();
+
+        return tileentityshulkerbox_animationphase != TileEntityShulkerBox.AnimationPhase.CLOSED && (tileentityshulkerbox_animationphase != TileEntityShulkerBox.AnimationPhase.OPENED || enumdirection1 != enumdirection.opposite() && enumdirection1 != enumdirection) ? EnumBlockFaceShape.UNDEFINED : EnumBlockFaceShape.SOLID;
+    }
+}

src/main/java/net/minecraft/server/BlockSkullAbstract.java

@@ -0,0 +1,84 @@
+package net.minecraft.server;
+
+public abstract class BlockSkullAbstract extends BlockTileEntity {
+
+    private final BlockSkull.a a;
+
+    public BlockSkullAbstract(BlockSkull.a blockskull_a, Block.Info block_info) {
+        super(block_info);
+        this.a = blockskull_a;
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public TileEntity a(IBlockAccess iblockaccess) {
+        return new TileEntitySkull();
+    }
+
+    // CraftBukkit start - Special case dropping so we can get info from the tile entity
+    @Override
+    public void dropNaturally(IBlockData iblockdata, World world, BlockPosition blockposition, float f, int i) {
+        if (world.random.nextFloat() < f) {
+            TileEntity tileentity = world.getTileEntity(blockposition);
+
+            if (tileentity instanceof TileEntitySkull) {
+                TileEntitySkull tileentityskull = (TileEntitySkull) tileentity;
+
+                if (tileentityskull.shouldDrop()) {
+                    ItemStack itemstack = this.a((IBlockAccess) world, blockposition, iblockdata);
+                    Block block = tileentityskull.getBlock().getBlock();
+
+                    if ((block == Blocks.PLAYER_HEAD || block == Blocks.PLAYER_WALL_HEAD) && tileentityskull.getGameProfile() != null) {
+                        NBTTagCompound nbttagcompound = new NBTTagCompound();
+
+                        GameProfileSerializer.serialize(nbttagcompound, tileentityskull.getGameProfile());
+                        itemstack.getOrCreateTag().set("SkullOwner", nbttagcompound);
+                    }
+
+                    a(world, blockposition, itemstack);
+                }
+            }
+        }
+    }
+    // CraftBukkit end
+
+    public void a(World world, BlockPosition blockposition, IBlockData iblockdata, EntityHuman entityhuman) {
+        if (!world.isClientSide && entityhuman.abilities.canInstantlyBuild) {
+            TileEntitySkull.a(world, blockposition);
+        }
+
+        super.a(world, blockposition, iblockdata, entityhuman);
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return EnumBlockFaceShape.UNDEFINED;
+    }
+
+    public void remove(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1, boolean flag) {
+        if (iblockdata.getBlock() != iblockdata1.getBlock() && !world.isClientSide) {
+            TileEntity tileentity = world.getTileEntity(blockposition);
+
+            if (false && tileentity instanceof TileEntitySkull) { // CraftBukkit - Drop item in code above, not here
+                TileEntitySkull tileentityskull = (TileEntitySkull) tileentity;
+
+                if (tileentityskull.shouldDrop()) {
+                    ItemStack itemstack = this.a((IBlockAccess) world, blockposition, iblockdata);
+                    Block block = tileentityskull.getBlock().getBlock();
+
+                    if ((block == Blocks.PLAYER_HEAD || block == Blocks.PLAYER_WALL_HEAD) && tileentityskull.getGameProfile() != null) {
+                        NBTTagCompound nbttagcompound = new NBTTagCompound();
+
+                        GameProfileSerializer.serialize(nbttagcompound, tileentityskull.getGameProfile());
+                        itemstack.getOrCreateTag().set("SkullOwner", nbttagcompound);
+                    }
+
+                    a(world, blockposition, itemstack);
+                }
+            }
+
+            super.remove(iblockdata, world, blockposition, iblockdata1, flag);
+        }
+    }
+}

src/main/java/net/minecraft/server/BlockSnow.java

@@ -0,0 +1,125 @@
+package net.minecraft.server;
+
+import java.util.Random;
+import javax.annotation.Nullable;
+
+public class BlockSnow extends Block {
+
+    public static final BlockStateInteger LAYERS = BlockProperties.ae;
+    protected static final VoxelShape[] b = new VoxelShape[] { VoxelShapes.a(), Block.a(0.0D, 0.0D, 0.0D, 16.0D, 2.0D, 16.0D), Block.a(0.0D, 0.0D, 0.0D, 16.0D, 4.0D, 16.0D), Block.a(0.0D, 0.0D, 0.0D, 16.0D, 6.0D, 16.0D), Block.a(0.0D, 0.0D, 0.0D, 16.0D, 8.0D, 16.0D), Block.a(0.0D, 0.0D, 0.0D, 16.0D, 10.0D, 16.0D), Block.a(0.0D, 0.0D, 0.0D, 16.0D, 12.0D, 16.0D), Block.a(0.0D, 0.0D, 0.0D, 16.0D, 14.0D, 16.0D), Block.a(0.0D, 0.0D, 0.0D, 16.0D, 16.0D, 16.0D)};
+
+    protected BlockSnow(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockSnow.LAYERS, 1));
+    }
+
+    public boolean a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, PathMode pathmode) {
+        switch (pathmode) {
+        case LAND:
+            return (Integer) iblockdata.get(BlockSnow.LAYERS) < 5;
+        case WATER:
+            return false;
+        case AIR:
+            return false;
+        default:
+            return false;
+        }
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return (Integer) iblockdata.get(BlockSnow.LAYERS) == 8;
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return enumdirection == EnumDirection.DOWN ? EnumBlockFaceShape.SOLID : EnumBlockFaceShape.UNDEFINED;
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return BlockSnow.b[(Integer) iblockdata.get(BlockSnow.LAYERS)];
+    }
+
+    public VoxelShape f(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return BlockSnow.b[(Integer) iblockdata.get(BlockSnow.LAYERS) - 1];
+    }
+
+    public boolean canPlace(IBlockData iblockdata, IWorldReader iworldreader, BlockPosition blockposition) {
+        IBlockData iblockdata1 = iworldreader.getType(blockposition.down());
+        Block block = iblockdata1.getBlock();
+
+        if (block != Blocks.ICE && block != Blocks.PACKED_ICE && block != Blocks.BARRIER) {
+            EnumBlockFaceShape enumblockfaceshape = iblockdata1.c(iworldreader, blockposition.down(), EnumDirection.UP);
+
+            return enumblockfaceshape == EnumBlockFaceShape.SOLID || iblockdata1.a(TagsBlock.LEAVES) || block == this && (Integer) iblockdata1.get(BlockSnow.LAYERS) == 8;
+        } else {
+            return false;
+        }
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        return !iblockdata.canPlace(generatoraccess, blockposition) ? Blocks.AIR.getBlockData() : super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
+    }
+
+    public void a(World world, EntityHuman entityhuman, BlockPosition blockposition, IBlockData iblockdata, @Nullable TileEntity tileentity, ItemStack itemstack) {
+        Integer integer = (Integer) iblockdata.get(BlockSnow.LAYERS);
+
+        if (this.X_() && EnchantmentManager.getEnchantmentLevel(Enchantments.SILK_TOUCH, itemstack) > 0) {
+            if (integer == 8) {
+                a(world, blockposition, new ItemStack(Blocks.SNOW_BLOCK));
+            } else {
+                for (int i = 0; i < integer; ++i) {
+                    a(world, blockposition, this.t(iblockdata));
+                }
+            }
+        } else {
+            a(world, blockposition, new ItemStack(Items.SNOWBALL, integer));
+        }
+
+        world.setAir(blockposition);
+        entityhuman.b(StatisticList.BLOCK_MINED.b(this));
+        entityhuman.applyExhaustion(0.005F);
+    }
+
+    public IMaterial getDropType(IBlockData iblockdata, World world, BlockPosition blockposition, int i) {
+        return Items.AIR;
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if (world.getBrightness(EnumSkyBlock.BLOCK, blockposition) > 11) {
+            // CraftBukkit start
+            if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockFadeEvent(world, blockposition, Blocks.AIR.getBlockData()).isCancelled()) {
+                return;
+            }
+            // CraftBukkit end
+            iblockdata.a(world, blockposition, 0);
+            world.setAir(blockposition);
+        }
+
+    }
+
+    public boolean a(IBlockData iblockdata, BlockActionContext blockactioncontext) {
+        int i = (Integer) iblockdata.get(BlockSnow.LAYERS);
+
+        return blockactioncontext.getItemStack().getItem() == this.getItem() && i < 8 ? (blockactioncontext.c() ? blockactioncontext.getClickedFace() == EnumDirection.UP : true) : i == 1;
+    }
+
+    @Nullable
+    public IBlockData getPlacedState(BlockActionContext blockactioncontext) {
+        IBlockData iblockdata = blockactioncontext.getWorld().getType(blockactioncontext.getClickPosition());
+
+        if (iblockdata.getBlock() == this) {
+            int i = (Integer) iblockdata.get(BlockSnow.LAYERS);
+
+            return (IBlockData) iblockdata.set(BlockSnow.LAYERS, Math.min(8, i + 1));
+        } else {
+            return super.getPlacedState(blockactioncontext);
+        }
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockSnow.LAYERS);
+    }
+
+    protected boolean X_() {
+        return true;
+    }
+}

src/main/java/net/minecraft/server/BlockSnowBlock.java

@@ -0,0 +1,35 @@
+package net.minecraft.server;
+
+import java.util.Random;
+
+public class BlockSnowBlock extends Block {
+
+    protected BlockSnowBlock(Block.Info block_info) {
+        super(block_info);
+    }
+
+    public IMaterial getDropType(IBlockData iblockdata, World world, BlockPosition blockposition, int i) {
+        return Items.SNOWBALL;
+    }
+
+    public int a(IBlockData iblockdata, Random random) {
+        return 4;
+    }
+
+    // Paper start - snow blocks don't need to tick
+    /*
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if (world.getBrightness(EnumSkyBlock.BLOCK, blockposition) > 11) {
+            // CraftBukkit start
+            if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockFadeEvent(world, blockposition, Blocks.AIR.getBlockData()).isCancelled()) {
+                return;
+            }
+            // CraftBukkit end
+            iblockdata.a(world, blockposition, 0);
+            world.setAir(blockposition);
+        }
+
+    }
+    */
+    //Paper end
+}

src/main/java/net/minecraft/server/BlockSoil.java

@@ -0,0 +1,142 @@
+package net.minecraft.server;
+
+import java.util.Iterator;
+import java.util.Random;
+
+// CraftBukkit start
+import org.bukkit.event.entity.EntityInteractEvent;
+import org.bukkit.craftbukkit.event.CraftEventFactory;
+// CraftBukkit end
+
+public class BlockSoil extends Block {
+
+    public static final BlockStateInteger MOISTURE = BlockProperties.ai;
+    protected static final VoxelShape b = Block.a(0.0D, 0.0D, 0.0D, 16.0D, 15.0D, 16.0D);
+
+    protected BlockSoil(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockSoil.MOISTURE, 0));
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        if (enumdirection == EnumDirection.UP && !iblockdata.canPlace(generatoraccess, blockposition)) {
+            generatoraccess.getBlockTickList().a(blockposition, this, 1);
+        }
+
+        return super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
+    }
+
+    public boolean canPlace(IBlockData iblockdata, IWorldReader iworldreader, BlockPosition blockposition) {
+        IBlockData iblockdata1 = iworldreader.getType(blockposition.up());
+
+        return !iblockdata1.getMaterial().isBuildable() || iblockdata1.getBlock() instanceof BlockFenceGate;
+    }
+
+    public IBlockData getPlacedState(BlockActionContext blockactioncontext) {
+        return !this.getBlockData().canPlace(blockactioncontext.getWorld(), blockactioncontext.getClickPosition()) ? Blocks.DIRT.getBlockData() : super.getPlacedState(blockactioncontext);
+    }
+
+    public int j(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return iblockaccess.K();
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return BlockSoil.b;
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if (!iblockdata.canPlace(world, blockposition)) {
+            b(iblockdata, world, blockposition);
+        } else {
+            int i = (Integer) iblockdata.get(BlockSoil.MOISTURE);
+
+            if (!a((IWorldReader) world, blockposition) && !world.isRainingAt(blockposition.up())) {
+                if (i > 0) {
+                    org.bukkit.craftbukkit.event.CraftEventFactory.handleMoistureChangeEvent(world, blockposition, (IBlockData) iblockdata.set(BlockSoil.MOISTURE, i - 1), 2); // CraftBukkit
+                } else if (!a((IBlockAccess) world, blockposition)) {
+                    b(iblockdata, world, blockposition);
+                }
+            } else if (i < 7) {
+                org.bukkit.craftbukkit.event.CraftEventFactory.handleMoistureChangeEvent(world, blockposition, (IBlockData) iblockdata.set(BlockSoil.MOISTURE, 7), 2); // CraftBukkit
+            }
+
+        }
+    }
+
+    public void fallOn(World world, BlockPosition blockposition, Entity entity, float f) {
+        super.fallOn(world, blockposition, entity, f); // CraftBukkit - moved here as game rules / events shouldn't affect fall damage.
+        if (!world.isClientSide && world.random.nextFloat() < f - 0.5F && entity instanceof EntityLiving && (entity instanceof EntityHuman || world.getGameRules().getBoolean("mobGriefing")) && entity.width * entity.width * entity.length > 0.512F) {
+            // CraftBukkit start - Interact soil
+            org.bukkit.event.Cancellable cancellable;
+            if (entity instanceof EntityHuman) {
+                cancellable = CraftEventFactory.callPlayerInteractEvent((EntityHuman) entity, org.bukkit.event.block.Action.PHYSICAL, blockposition, null, null, null);
+            } else {
+                cancellable = new EntityInteractEvent(entity.getBukkitEntity(), world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ()));
+                world.getServer().getPluginManager().callEvent((EntityInteractEvent) cancellable);
+            }
+
+            if (cancellable.isCancelled()) {
+                return;
+            }
+
+            if (CraftEventFactory.callEntityChangeBlockEvent(entity, blockposition, Blocks.DIRT.getBlockData()).isCancelled()) {
+                return;
+            }
+            // CraftBukkit end
+            b(world.getType(blockposition), world, blockposition);
+        }
+
+        // super.fallOn(world, blockposition, entity, f); // CraftBukkit - moved up
+    }
+
+    public static void b(IBlockData iblockdata, World world, BlockPosition blockposition) {
+        // CraftBukkit start
+        if (CraftEventFactory.callBlockFadeEvent(world, blockposition, Blocks.DIRT.getBlockData()).isCancelled()) {
+            return;
+        }
+        // CraftBukkit end
+        world.setTypeUpdate(blockposition, a(iblockdata, Blocks.DIRT.getBlockData(), world, blockposition));
+    }
+
+    private static boolean a(IBlockAccess iblockaccess, BlockPosition blockposition) {
+        Block block = iblockaccess.getType(blockposition.up()).getBlock();
+
+        return block instanceof BlockCrops || block instanceof BlockStem || block instanceof BlockStemAttached;
+    }
+
+    private static boolean a(IWorldReader iworldreader, BlockPosition blockposition) {
+        Iterator iterator = BlockPosition.b(blockposition.a(-4, 0, -4), blockposition.a(4, 1, 4)).iterator();
+
+        BlockPosition.MutableBlockPosition blockposition_mutableblockposition;
+
+        do {
+            if (!iterator.hasNext()) {
+                return false;
+            }
+
+            blockposition_mutableblockposition = (BlockPosition.MutableBlockPosition) iterator.next();
+        } while (!iworldreader.getFluid(blockposition_mutableblockposition).a(TagsFluid.WATER));
+
+        return true;
+    }
+
+    public IMaterial getDropType(IBlockData iblockdata, World world, BlockPosition blockposition, int i) {
+        return Blocks.DIRT;
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockSoil.MOISTURE);
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return enumdirection == EnumDirection.DOWN ? EnumBlockFaceShape.SOLID : EnumBlockFaceShape.UNDEFINED;
+    }
+
+    public boolean a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, PathMode pathmode) {
+        return false;
+    }
+}

src/main/java/net/minecraft/server/BlockSponge.java

@@ -0,0 +1,124 @@
+package net.minecraft.server;
+
+import com.google.common.collect.Lists;
+import java.util.Queue;
+// CraftBukkit start
+import java.util.List;
+import org.bukkit.craftbukkit.block.CraftBlockState;
+import org.bukkit.craftbukkit.util.BlockStateListPopulator;
+import org.bukkit.event.block.SpongeAbsorbEvent;
+// CraftBukkit end
+
+public class BlockSponge extends Block {
+
+    protected BlockSponge(Block.Info block_info) {
+        super(block_info);
+    }
+
+    public void onPlace(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1) {
+        if (iblockdata1.getBlock() != iblockdata.getBlock()) {
+            this.a(world, blockposition);
+        }
+    }
+
+    public void doPhysics(IBlockData iblockdata, World world, BlockPosition blockposition, Block block, BlockPosition blockposition1) {
+        this.a(world, blockposition);
+        super.doPhysics(iblockdata, world, blockposition, block, blockposition1);
+    }
+
+    protected void a(World world, BlockPosition blockposition) {
+        if (this.b(world, blockposition)) {
+            world.setTypeAndData(blockposition, Blocks.WET_SPONGE.getBlockData(), 2);
+            world.triggerEffect(2001, blockposition, Block.getCombinedId(Blocks.WATER.getBlockData()));
+        }
+
+    }
+
+    private boolean b(World world, BlockPosition blockposition) {
+        Queue<Tuple<BlockPosition, Integer>> queue = Lists.newLinkedList();
+
+        queue.add(new Tuple<>(blockposition, 0));
+        int i = 0;
+        BlockStateListPopulator blockList = new BlockStateListPopulator(world); // CraftBukkit - Use BlockStateListPopulator
+
+        while (!queue.isEmpty()) {
+            Tuple<BlockPosition, Integer> tuple = (Tuple) queue.poll();
+            BlockPosition blockposition1 = (BlockPosition) tuple.a();
+            int j = (Integer) tuple.b();
+            EnumDirection[] aenumdirection = EnumDirection.values();
+            int k = aenumdirection.length;
+
+            for (int l = 0; l < k; ++l) {
+                EnumDirection enumdirection = aenumdirection[l];
+                BlockPosition blockposition2 = blockposition1.shift(enumdirection);
+                IBlockData iblockdata = world.getType(blockposition2);
+                Fluid fluid = world.getFluid(blockposition2);
+                Material material = iblockdata.getMaterial();
+
+                if (fluid.a(TagsFluid.WATER)) {
+                    if (iblockdata.getBlock() instanceof IFluidSource && ((IFluidSource) iblockdata.getBlock()).removeFluid(blockList, blockposition2, iblockdata) != FluidTypes.EMPTY) { // CraftBukkit
+                        ++i;
+                        if (j < 6) {
+                            queue.add(new Tuple<>(blockposition2, j + 1));
+                        }
+                    } else if (iblockdata.getBlock() instanceof BlockFluids) {
+                        blockList.setTypeAndData(blockposition2, Blocks.AIR.getBlockData(), 3); // CraftBukkit
+                        ++i;
+                        if (j < 6) {
+                            queue.add(new Tuple<>(blockposition2, j + 1));
+                        }
+                    } else if (material == Material.WATER_PLANT || material == Material.REPLACEABLE_WATER_PLANT) {
+                        // iblockdata.a(world, blockposition2, 0);
+                        blockList.setTypeAndData(blockposition2, Blocks.AIR.getBlockData(), 3); // CraftBukkit
+                        ++i;
+                        if (j < 6) {
+                            queue.add(new Tuple<>(blockposition2, j + 1));
+                        }
+                    }
+                }
+            }
+
+            if (i > 64) {
+                break;
+            }
+        }
+        // CraftBukkit start
+        List<CraftBlockState> blocks = blockList.getList(); // Is a clone
+        if (!blocks.isEmpty()) {
+            final org.bukkit.block.Block bblock = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
+
+            SpongeAbsorbEvent event = new SpongeAbsorbEvent(bblock, (List<org.bukkit.block.BlockState>) (List) blocks);
+            world.getServer().getPluginManager().callEvent(event);
+
+            if (event.isCancelled()) {
+                return false;
+            }
+
+            for (CraftBlockState block : blocks) {
+                BlockPosition blockposition2 = block.getPosition();
+                IBlockData iblockdata = world.getType(blockposition2);
+                Fluid fluid = world.getFluid(blockposition2);
+                Material material = iblockdata.getMaterial();
+
+                if (fluid.a(TagsFluid.WATER)) {
+                    if (iblockdata.getBlock() instanceof IFluidSource && ((IFluidSource) iblockdata.getBlock()).removeFluid(blockList, blockposition2, iblockdata) != FluidTypes.EMPTY) {
+                        // NOP
+                    } else if (iblockdata.getBlock() instanceof BlockFluids) {
+                        // NOP
+                    } else if (material == Material.WATER_PLANT || material == Material.REPLACEABLE_WATER_PLANT) {
+                        // Paper start
+                        if (block.getHandle().getMaterial() == Material.AIR) {
+                            iblockdata.dropNaturally(world, blockposition2, 0);
+                        }
+                        // Paper end
+                    }
+                }
+                world.setTypeAndData(blockposition2, block.getHandle(), block.getFlag());
+            }
+        }
+        // CraftBukkit end
+
+        return i > 0;
+    }
+}
+

src/main/java/net/minecraft/server/BlockState.java

@@ -0,0 +1,41 @@
+package net.minecraft.server;
+
+import com.google.common.base.MoreObjects;
+
+public abstract class BlockState<T extends Comparable<T>> implements IBlockState<T> {
+
+    private final Class<T> a;
+    private final String b;
+    private Integer c;
+
+    protected BlockState(String s, Class<T> oclass) {
+        this.a = oclass;
+        this.b = s;
+    }
+
+    public String a() {
+        return this.b;
+    }
+
+    public Class<T> b() {
+        return this.a;
+    }
+
+    public String toString() {
+        return MoreObjects.toStringHelper(this).add("name", this.b).add("clazz", this.a).add("values", this.d()).toString();
+    }
+
+    public boolean equals(Object object) {
+        return this == object; // Paper - only one instance per configuration
+    }
+
+    private static java.util.concurrent.atomic.AtomicInteger hashId = new java.util.concurrent.atomic.AtomicInteger(1);// Paper - only one instance per configuration
+    private final int hashCode = 92821 * hashId.getAndIncrement(); // Paper - only one instance per configuration
+    public final int hashCode() {
+        return hashCode; // Paper - only one instance per configuration
+    }
+
+    public int c() {
+        return 31 * this.a.hashCode() + this.b.hashCode();
+    }
+}

src/main/java/net/minecraft/server/BlockStateBoolean.java

@@ -0,0 +1,46 @@
+package net.minecraft.server;
+
+import com.google.common.collect.ImmutableSet;
+import java.util.Collection;
+import java.util.Optional;
+
+public class BlockStateBoolean extends BlockState<Boolean> {
+
+    private final ImmutableSet<Boolean> a = ImmutableSet.of(true, false);
+
+    protected BlockStateBoolean(String s) {
+        super(s, Boolean.class);
+    }
+
+    public Collection<Boolean> d() {
+        return this.a;
+    }
+
+    public static BlockStateBoolean of(String s) {
+        return new BlockStateBoolean(s);
+    }
+
+    public Optional<Boolean> b(String s) {
+        return !"true".equals(s) && !"false".equals(s) ? Optional.empty() : Optional.of(Boolean.valueOf(s));
+    }
+
+    public String a(Boolean obool) {
+        return obool.toString();
+    }
+
+    public boolean equals_unused(Object object) { // Paper
+        if (this == object) {
+            return true;
+        } else if (object instanceof BlockStateBoolean && super.equals(object)) {
+            BlockStateBoolean blockstateboolean = (BlockStateBoolean) object;
+
+            return this.a.equals(blockstateboolean.a);
+        } else {
+            return false;
+        }
+    }
+
+    public int c() {
+        return 31 * super.c() + this.a.hashCode();
+    }
+}

src/main/java/net/minecraft/server/BlockStateEnum.java

@@ -0,0 +1,85 @@
+package net.minecraft.server;
+
+import com.google.common.base.Predicates;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+public class BlockStateEnum<T extends Enum<T> & INamable> extends BlockState<T> {
+
+    private final ImmutableSet<T> a;
+    private final Map<String, T> b = Maps.newHashMap();
+
+    protected BlockStateEnum(String s, Class<T> oclass, Collection<T> collection) {
+        super(s, oclass);
+        this.a = ImmutableSet.copyOf(collection);
+        Iterator<T> iterator = collection.iterator(); // Paper - decompile fix
+
+        while (iterator.hasNext()) {
+            T t0 = iterator.next(); // Paper - Decompile fix
+            String s1 = ((INamable) t0).getName();
+
+            if (this.b.containsKey(s1)) {
+                throw new IllegalArgumentException("Multiple values have the same name '" + s1 + "'");
+            }
+
+            this.b.put(s1, t0);
+        }
+
+    }
+
+    public Collection<T> d() {
+        return this.a;
+    }
+
+    public Optional<T> b(String s) {
+        return Optional.ofNullable(this.b.get(s));
+    }
+
+    public String a(T t0) {
+        return ((INamable) t0).getName();
+    }
+
+    public boolean equals_unused(Object object) { // Paper
+        if (this == object) {
+            return true;
+        } else if (object instanceof BlockStateEnum && super.equals(object)) {
+            BlockStateEnum<?> blockstateenum = (BlockStateEnum) object;
+
+            return this.a.equals(blockstateenum.a) && this.b.equals(blockstateenum.b);
+        } else {
+            return false;
+        }
+    }
+
+    public int c() {
+        int i = super.c();
+
+        i = 31 * i + this.a.hashCode();
+        i = 31 * i + this.b.hashCode();
+        return i;
+    }
+
+    public static <T extends Enum<T> & INamable> BlockStateEnum<T> of(String s, Class<T> oclass) {
+        return a(s, oclass, (Predicate) Predicates.alwaysTrue());
+    }
+
+    public static <T extends Enum<T> & INamable> BlockStateEnum<T> a(String s, Class<T> oclass, Predicate<T> predicate) {
+        return a(s, oclass, (Collection) Arrays.stream(oclass.getEnumConstants()).filter(predicate).collect(Collectors.toList()));
+    }
+
+    public static <T extends Enum<T> & INamable> BlockStateEnum<T> of(String s, Class<T> oclass, T... at) {
+        return a(s, oclass, (Collection) Lists.newArrayList(at));
+    }
+
+    public static <T extends Enum<T> & INamable> BlockStateEnum<T> a(String s, Class<T> oclass, Collection<T> collection) {
+        return new BlockStateEnum<>(s, oclass, collection);
+    }
+}

src/main/java/net/minecraft/server/BlockStateInteger.java

@@ -0,0 +1,73 @@
+package net.minecraft.server;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+import java.util.Collection;
+import java.util.Optional;
+import java.util.Set;
+
+public class BlockStateInteger extends BlockState<Integer> {
+
+    private final ImmutableSet<Integer> a;
+    // CraftBukkit start
+    public final int min;
+    public final int max;
+
+    protected BlockStateInteger(String s, int i, int j) {
+        super(s, Integer.class);
+        this.min = i;
+        this.max = j;
+        // CraftBukkit end
+        if (i < 0) {
+            throw new IllegalArgumentException("Min value of " + s + " must be 0 or greater");
+        } else if (j <= i) {
+            throw new IllegalArgumentException("Max value of " + s + " must be greater than min (" + i + ")");
+        } else {
+            Set<Integer> set = Sets.newHashSet();
+
+            for (int k = i; k <= j; ++k) {
+                set.add(k);
+            }
+
+            this.a = ImmutableSet.copyOf(set);
+        }
+    }
+
+    public Collection<Integer> d() {
+        return this.a;
+    }
+
+    public boolean equals_unused(Object object) { // Paper
+        if (this == object) {
+            return true;
+        } else if (object instanceof BlockStateInteger && super.equals(object)) {
+            BlockStateInteger blockstateinteger = (BlockStateInteger) object;
+
+            return this.a.equals(blockstateinteger.a);
+        } else {
+            return false;
+        }
+    }
+
+    public int c() {
+        return 31 * super.c() + this.a.hashCode();
+    }
+
+    public static BlockStateInteger of(String s, int i, int j) {
+        return new BlockStateInteger(s, i, j);
+    }
+
+    public Optional<Integer> b(String s) {
+        try {
+            Integer integer = Integer.valueOf(s);
+
+            return this.a.contains(integer) ? Optional.of(integer) : Optional.empty();
+        } catch (NumberFormatException numberformatexception) {
+            return Optional.empty();
+        }
+    }
+
+    public String a(Integer integer) {
+        return integer.toString();
+    }
+}

src/main/java/net/minecraft/server/BlockStem.java

@@ -0,0 +1,117 @@
+package net.minecraft.server;
+
+import java.util.Random;
+import javax.annotation.Nullable;
+
+import org.bukkit.craftbukkit.event.CraftEventFactory; // CraftBukkit
+
+public class BlockStem extends BlockPlant implements IBlockFragilePlantElement {
+
+    public static final BlockStateInteger AGE = BlockProperties.W;
+    protected static final VoxelShape[] b = new VoxelShape[] { Block.a(7.0D, 0.0D, 7.0D, 9.0D, 2.0D, 9.0D), Block.a(7.0D, 0.0D, 7.0D, 9.0D, 4.0D, 9.0D), Block.a(7.0D, 0.0D, 7.0D, 9.0D, 6.0D, 9.0D), Block.a(7.0D, 0.0D, 7.0D, 9.0D, 8.0D, 9.0D), Block.a(7.0D, 0.0D, 7.0D, 9.0D, 10.0D, 9.0D), Block.a(7.0D, 0.0D, 7.0D, 9.0D, 12.0D, 9.0D), Block.a(7.0D, 0.0D, 7.0D, 9.0D, 14.0D, 9.0D), Block.a(7.0D, 0.0D, 7.0D, 9.0D, 16.0D, 9.0D)};
+    private final BlockStemmed blockFruit;
+
+    protected BlockStem(BlockStemmed blockstemmed, Block.Info block_info) {
+        super(block_info);
+        this.blockFruit = blockstemmed;
+        this.v((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockStem.AGE, 0));
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return BlockStem.b[(Integer) iblockdata.get(BlockStem.AGE)];
+    }
+
+    protected boolean b(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return iblockdata.getBlock() == Blocks.FARMLAND;
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        super.a(iblockdata, world, blockposition, random);
+        if (world.isLightLevel(blockposition.up(), 9)) { // Paper
+            float f = BlockCrops.a((Block) this, (IBlockAccess) world, blockposition);
+
+            if (random.nextInt((int) ((100.0F / (this == Blocks.PUMPKIN_STEM ? world.spigotConfig.pumpkinModifier : world.spigotConfig.melonModifier)) * (25.0F / f)) + 1) == 0) { // Spigot
+                int i = (Integer) iblockdata.get(BlockStem.AGE);
+
+                if (i < 7) {
+                    iblockdata = (IBlockData) iblockdata.set(BlockStem.AGE, i + 1);
+                    CraftEventFactory.handleBlockGrowEvent(world, blockposition, iblockdata, 2); // CraftBukkit
+                } else {
+                    EnumDirection enumdirection = EnumDirection.EnumDirectionLimit.HORIZONTAL.a(random);
+                    BlockPosition blockposition1 = blockposition.shift(enumdirection);
+                    Block block = world.getType(blockposition1.down()).getBlock();
+
+                    if (world.getType(blockposition1).isAir() && (block == Blocks.FARMLAND || block == Blocks.DIRT || block == Blocks.COARSE_DIRT || block == Blocks.PODZOL || block == Blocks.GRASS_BLOCK)) {
+                        // CraftBukkit start
+                        if (!CraftEventFactory.handleBlockGrowEvent(world, blockposition1, this.blockFruit.getBlockData())) {
+                            return;
+                        }
+                        // CraftBukkit end
+                        world.setTypeUpdate(blockposition, (IBlockData) this.blockFruit.e().getBlockData().set(BlockFacingHorizontal.FACING, enumdirection));
+                    }
+                }
+            }
+
+        }
+    }
+
+    public void dropNaturally(IBlockData iblockdata, World world, BlockPosition blockposition, float f, int i) {
+        super.dropNaturally(iblockdata, world, blockposition, f, i);
+        if (!world.isClientSide) {
+            Item item = this.d();
+
+            if (item != null) {
+                int j = (Integer) iblockdata.get(BlockStem.AGE);
+
+                for (int k = 0; k < 3; ++k) {
+                    if (world.random.nextInt(15) <= j) {
+                        a(world, blockposition, new ItemStack(item));
+                    }
+                }
+
+            }
+        }
+    }
+
+    @Nullable
+    protected Item d() {
+        return this.blockFruit == Blocks.PUMPKIN ? Items.PUMPKIN_SEEDS : (this.blockFruit == Blocks.MELON ? Items.MELON_SEEDS : null);
+    }
+
+    public IMaterial getDropType(IBlockData iblockdata, World world, BlockPosition blockposition, int i) {
+        return Items.AIR;
+    }
+
+    public ItemStack a(IBlockAccess iblockaccess, BlockPosition blockposition, IBlockData iblockdata) {
+        Item item = this.d();
+
+        return item == null ? ItemStack.a : new ItemStack(item);
+    }
+
+    public boolean a(IBlockAccess iblockaccess, BlockPosition blockposition, IBlockData iblockdata, boolean flag) {
+        return (Integer) iblockdata.get(BlockStem.AGE) != 7;
+    }
+
+    public boolean a(World world, Random random, BlockPosition blockposition, IBlockData iblockdata) {
+        return true;
+    }
+
+    public void b(World world, Random random, BlockPosition blockposition, IBlockData iblockdata) {
+        int i = Math.min(7, (Integer) iblockdata.get(BlockStem.AGE) + MathHelper.nextInt(world.random, 2, 5));
+        IBlockData iblockdata1 = (IBlockData) iblockdata.set(BlockStem.AGE, i);
+
+        CraftEventFactory.handleBlockGrowEvent(world, blockposition, iblockdata1, 2); // CraftBukkit
+        if (i == 7) {
+            iblockdata1.a(world, blockposition, world.random);
+        }
+
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockStem.AGE);
+    }
+
+    public BlockStemmed e() {
+        return this.blockFruit;
+    }
+}

src/main/java/net/minecraft/server/BlockTNT.java

@@ -0,0 +1,140 @@
+package net.minecraft.server;
+
+import javax.annotation.Nullable;
+import com.destroystokyo.paper.event.block.TNTPrimeEvent; // Paper - TNTPrimeEvent
+
+public class BlockTNT extends Block {
+
+    public static final BlockStateBoolean a = BlockProperties.x;
+
+    public BlockTNT(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) this.getBlockData().set(BlockTNT.a, false));
+    }
+
+    public void onPlace(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1) {
+        if (iblockdata1.getBlock() != iblockdata.getBlock()) {
+            if (world.isBlockIndirectlyPowered(blockposition)) {
+                // Paper start - TNTPrimeEvent
+                org.bukkit.block.Block tntBlock = MCUtil.toBukkitBlock(world, blockposition);;
+                if(!new TNTPrimeEvent(tntBlock, TNTPrimeEvent.PrimeReason.REDSTONE, null).callEvent())
+                    return;
+                // Paper end
+                this.a(world, blockposition);
+                world.setAir(blockposition);
+            }
+
+        }
+    }
+
+    public void doPhysics(IBlockData iblockdata, World world, BlockPosition blockposition, Block block, BlockPosition blockposition1) {
+        if (world.isBlockIndirectlyPowered(blockposition)) {
+            // Paper start - TNTPrimeEvent
+            org.bukkit.block.Block tntBlock = MCUtil.toBukkitBlock(world, blockposition);;
+            if(!new TNTPrimeEvent(tntBlock, TNTPrimeEvent.PrimeReason.REDSTONE, null).callEvent())
+                return;
+            // Paper end
+            this.a(world, blockposition);
+            world.setAir(blockposition);
+        }
+
+    }
+
+    public void dropNaturally(IBlockData iblockdata, World world, BlockPosition blockposition, float f, int i) {
+        if (!(Boolean) iblockdata.get(BlockTNT.a)) {
+            super.dropNaturally(iblockdata, world, blockposition, f, i);
+        }
+    }
+
+    public void a(World world, BlockPosition blockposition, IBlockData iblockdata, EntityHuman entityhuman) {
+        if (!world.e() && !entityhuman.u() && (Boolean) iblockdata.get(BlockTNT.a)) {
+            this.a(world, blockposition);
+        }
+
+        super.a(world, blockposition, iblockdata, entityhuman);
+    }
+
+    public void wasExploded(World world, BlockPosition blockposition, Explosion explosion) {
+        if (!world.isClientSide) {
+            // Paper start - TNTPrimeEvent
+            org.bukkit.block.Block tntBlock = MCUtil.toBukkitBlock(world, blockposition);;
+            org.bukkit.entity.Entity source = explosion.source != null ? explosion.source.bukkitEntity : null;
+            if(!new TNTPrimeEvent(tntBlock, TNTPrimeEvent.PrimeReason.EXPLOSION, source).callEvent())
+                return;
+            // Paper end
+            EntityTNTPrimed entitytntprimed = new EntityTNTPrimed(world, (double) ((float) blockposition.getX() + 0.5F), (double) blockposition.getY(), (double) ((float) blockposition.getZ() + 0.5F), explosion.getSource());
+
+            entitytntprimed.setFuseTicks((short) (world.random.nextInt(entitytntprimed.getFuseTicks() / 4) + entitytntprimed.getFuseTicks() / 8));
+            world.addEntity(entitytntprimed);
+        }
+    }
+
+    public void a(World world, BlockPosition blockposition) {
+        this.a(world, blockposition, (EntityLiving) null);
+    }
+
+    private void a(World world, BlockPosition blockposition, @Nullable EntityLiving entityliving) {
+        if (!world.isClientSide) {
+            EntityTNTPrimed entitytntprimed = new EntityTNTPrimed(world, (double) ((float) blockposition.getX() + 0.5F), (double) blockposition.getY(), (double) ((float) blockposition.getZ() + 0.5F), entityliving);
+
+            world.addEntity(entitytntprimed);
+            world.a((EntityHuman) null, entitytntprimed.locX, entitytntprimed.locY, entitytntprimed.locZ, SoundEffects.ENTITY_TNT_PRIMED, SoundCategory.BLOCKS, 1.0F, 1.0F);
+        }
+    }
+
+    public boolean interact(IBlockData iblockdata, World world, BlockPosition blockposition, EntityHuman entityhuman, EnumHand enumhand, EnumDirection enumdirection, float f, float f1, float f2) {
+        ItemStack itemstack = entityhuman.b(enumhand);
+        Item item = itemstack.getItem();
+
+        if (item != Items.FLINT_AND_STEEL && item != Items.FIRE_CHARGE) {
+            return super.interact(iblockdata, world, blockposition, entityhuman, enumhand, enumdirection, f, f1, f2);
+        } else {
+            // Paper start - TNTPrimeEvent
+            org.bukkit.block.Block tntBlock = MCUtil.toBukkitBlock(world, blockposition);
+            if(!new TNTPrimeEvent(tntBlock, TNTPrimeEvent.PrimeReason.ITEM, entityhuman.bukkitEntity).callEvent())
+                return true;
+            // Paper end
+            this.a(world, blockposition, (EntityLiving) entityhuman);
+            world.setTypeAndData(blockposition, Blocks.AIR.getBlockData(), 11);
+            if (item == Items.FLINT_AND_STEEL) {
+                itemstack.damage(1, entityhuman);
+            } else {
+                itemstack.subtract(1);
+            }
+
+            return true;
+        }
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
+        if (!world.isClientSide && entity instanceof EntityArrow) {
+            EntityArrow entityarrow = (EntityArrow) entity;
+            Entity entity1 = entityarrow.getShooter();
+
+            if (entityarrow.isBurning()) {
+                // CraftBukkit start
+                if (org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(entityarrow, blockposition, Blocks.AIR.getBlockData()).isCancelled()) {
+                    return;
+                }
+                // CraftBukkit end
+                // Paper start - TNTPrimeEvent
+                org.bukkit.block.Block tntBlock = MCUtil.toBukkitBlock(world, blockposition);
+                if (!new TNTPrimeEvent(tntBlock, TNTPrimeEvent.PrimeReason.PROJECTILE, entityarrow.bukkitEntity).callEvent()) {
+                    return;
+                }
+                // Paper end
+                this.a(world, blockposition, entity1 instanceof EntityLiving ? (EntityLiving) entity1 : null);
+                world.setAir(blockposition);
+            }
+        }
+
+    }
+
+    public boolean a(Explosion explosion) {
+        return false;
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockTNT.a);
+    }
+}

src/main/java/net/minecraft/server/BlockTallPlant.java

@@ -0,0 +1,91 @@
+package net.minecraft.server;
+
+import javax.annotation.Nullable;
+
+public class BlockTallPlant extends BlockPlant {
+
+    public static final BlockStateEnum<BlockPropertyDoubleBlockHalf> HALF = BlockProperties.P;
+
+    public BlockTallPlant(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockTallPlant.HALF, BlockPropertyDoubleBlockHalf.LOWER));
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        BlockPropertyDoubleBlockHalf blockpropertydoubleblockhalf = (BlockPropertyDoubleBlockHalf) iblockdata.get(BlockTallPlant.HALF);
+
+        return enumdirection.k() == EnumDirection.EnumAxis.Y && blockpropertydoubleblockhalf == BlockPropertyDoubleBlockHalf.LOWER == (enumdirection == EnumDirection.UP) && (iblockdata1.getBlock() != this || iblockdata1.get(BlockTallPlant.HALF) == blockpropertydoubleblockhalf) ? Blocks.AIR.getBlockData() : (blockpropertydoubleblockhalf == BlockPropertyDoubleBlockHalf.LOWER && enumdirection == EnumDirection.DOWN && !iblockdata.canPlace(generatoraccess, blockposition) ? Blocks.AIR.getBlockData() : super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1));
+    }
+
+    @Nullable
+    public IBlockData getPlacedState(BlockActionContext blockactioncontext) {
+        BlockPosition blockposition = blockactioncontext.getClickPosition();
+
+        return blockposition.getY() < 255 && blockactioncontext.getWorld().getType(blockposition.up()).a(blockactioncontext) ? super.getPlacedState(blockactioncontext) : null;
+    }
+
+    public void postPlace(World world, BlockPosition blockposition, IBlockData iblockdata, EntityLiving entityliving, ItemStack itemstack) {
+        world.setTypeAndData(blockposition.up(), (IBlockData) this.getBlockData().set(BlockTallPlant.HALF, BlockPropertyDoubleBlockHalf.UPPER), 3);
+    }
+
+    public boolean canPlace(IBlockData iblockdata, IWorldReader iworldreader, BlockPosition blockposition) {
+        if (iblockdata.get(BlockTallPlant.HALF) != BlockPropertyDoubleBlockHalf.UPPER) {
+            return super.canPlace(iblockdata, iworldreader, blockposition);
+        } else {
+            IBlockData iblockdata1 = iworldreader.getType(blockposition.down());
+
+            return iblockdata1.getBlock() == this && iblockdata1.get(BlockTallPlant.HALF) == BlockPropertyDoubleBlockHalf.LOWER;
+        }
+    }
+
+    public void a(GeneratorAccess generatoraccess, BlockPosition blockposition, int i) {
+        generatoraccess.setTypeAndData(blockposition, (IBlockData) this.getBlockData().set(BlockTallPlant.HALF, BlockPropertyDoubleBlockHalf.LOWER), i);
+        generatoraccess.setTypeAndData(blockposition.up(), (IBlockData) this.getBlockData().set(BlockTallPlant.HALF, BlockPropertyDoubleBlockHalf.UPPER), i);
+    }
+
+    public void a(World world, EntityHuman entityhuman, BlockPosition blockposition, IBlockData iblockdata, @Nullable TileEntity tileentity, ItemStack itemstack) {
+        super.a(world, entityhuman, blockposition, Blocks.AIR.getBlockData(), tileentity, itemstack);
+    }
+
+    public void a(World world, BlockPosition blockposition, IBlockData iblockdata, EntityHuman entityhuman) {
+        // CraftBukkit start
+        if (((WorldServer)world).hasPhysicsEvent && org.bukkit.craftbukkit.event.CraftEventFactory.callBlockPhysicsEvent(world, blockposition).isCancelled()) { // Paper
+            return;
+        }
+        // CraftBukkit end
+        BlockPropertyDoubleBlockHalf blockpropertydoubleblockhalf = (BlockPropertyDoubleBlockHalf) iblockdata.get(BlockTallPlant.HALF);
+        boolean flag = blockpropertydoubleblockhalf == BlockPropertyDoubleBlockHalf.LOWER;
+        BlockPosition blockposition1 = flag ? blockposition.up() : blockposition.down();
+        IBlockData iblockdata1 = world.getType(blockposition1);
+
+        if (iblockdata1.getBlock() == this && iblockdata1.get(BlockTallPlant.HALF) != blockpropertydoubleblockhalf) {
+            world.setTypeAndData(blockposition1, Blocks.AIR.getBlockData(), 35);
+            world.a(entityhuman, 2001, blockposition1, Block.getCombinedId(iblockdata1));
+            if (!world.isClientSide && !entityhuman.u()) {
+                if (flag) {
+                    this.a(iblockdata, world, blockposition, entityhuman.getItemInMainHand());
+                } else {
+                    this.a(iblockdata1, world, blockposition1, entityhuman.getItemInMainHand());
+                }
+            }
+        }
+
+        super.a(world, blockposition, iblockdata, entityhuman);
+    }
+
+    protected void a(IBlockData iblockdata, World world, BlockPosition blockposition, ItemStack itemstack) {
+        iblockdata.a(world, blockposition, 0);
+    }
+
+    public IMaterial getDropType(IBlockData iblockdata, World world, BlockPosition blockposition, int i) {
+        return (IMaterial) (iblockdata.get(BlockTallPlant.HALF) == BlockPropertyDoubleBlockHalf.LOWER ? super.getDropType(iblockdata, world, blockposition, i) : Items.AIR);
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockTallPlant.HALF);
+    }
+
+    public Block.EnumRandomOffset q() {
+        return Block.EnumRandomOffset.XZ;
+    }
+}

src/main/java/net/minecraft/server/BlockTrapdoor.java

@@ -0,0 +1,186 @@
+package net.minecraft.server;
+
+import javax.annotation.Nullable;
+import org.bukkit.event.block.BlockRedstoneEvent; // CraftBukkit
+
+public class BlockTrapdoor extends BlockFacingHorizontal implements IFluidSource, IFluidContainer {
+
+    public static final BlockStateBoolean OPEN = BlockProperties.r;
+    public static final BlockStateEnum<BlockPropertyHalf> HALF = BlockProperties.Q;
+    public static final BlockStateBoolean c = BlockProperties.t;
+    public static final BlockStateBoolean o = BlockProperties.y;
+    protected static final VoxelShape p = Block.a(0.0D, 0.0D, 0.0D, 3.0D, 16.0D, 16.0D);
+    protected static final VoxelShape q = Block.a(13.0D, 0.0D, 0.0D, 16.0D, 16.0D, 16.0D);
+    protected static final VoxelShape r = Block.a(0.0D, 0.0D, 0.0D, 16.0D, 16.0D, 3.0D);
+    protected static final VoxelShape s = Block.a(0.0D, 0.0D, 13.0D, 16.0D, 16.0D, 16.0D);
+    protected static final VoxelShape t = Block.a(0.0D, 0.0D, 0.0D, 16.0D, 3.0D, 16.0D);
+    protected static final VoxelShape u = Block.a(0.0D, 13.0D, 0.0D, 16.0D, 16.0D, 16.0D);
+
+    protected BlockTrapdoor(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockTrapdoor.FACING, EnumDirection.NORTH)).set(BlockTrapdoor.OPEN, false)).set(BlockTrapdoor.HALF, BlockPropertyHalf.BOTTOM)).set(BlockTrapdoor.c, false)).set(BlockTrapdoor.o, false));
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        if (!(Boolean) iblockdata.get(BlockTrapdoor.OPEN)) {
+            return iblockdata.get(BlockTrapdoor.HALF) == BlockPropertyHalf.TOP ? BlockTrapdoor.u : BlockTrapdoor.t;
+        } else {
+            switch ((EnumDirection) iblockdata.get(BlockTrapdoor.FACING)) {
+            case NORTH:
+            default:
+                return BlockTrapdoor.s;
+            case SOUTH:
+                return BlockTrapdoor.r;
+            case WEST:
+                return BlockTrapdoor.q;
+            case EAST:
+                return BlockTrapdoor.p;
+            }
+        }
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public boolean a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, PathMode pathmode) {
+        switch (pathmode) {
+        case LAND:
+            return (Boolean) iblockdata.get(BlockTrapdoor.OPEN);
+        case WATER:
+            return (Boolean) iblockdata.get(BlockTrapdoor.o);
+        case AIR:
+            return (Boolean) iblockdata.get(BlockTrapdoor.OPEN);
+        default:
+            return false;
+        }
+    }
+
+    public boolean interact(IBlockData iblockdata, World world, BlockPosition blockposition, EntityHuman entityhuman, EnumHand enumhand, EnumDirection enumdirection, float f, float f1, float f2) {
+        if (this.material == Material.ORE) {
+            return false;
+        } else {
+            iblockdata = (IBlockData) iblockdata.a((IBlockState) BlockTrapdoor.OPEN);
+            world.setTypeAndData(blockposition, iblockdata, 2);
+            if ((Boolean) iblockdata.get(BlockTrapdoor.o)) {
+                world.getFluidTickList().a(blockposition, FluidTypes.WATER, FluidTypes.WATER.a((IWorldReader) world));
+            }
+
+            this.a(entityhuman, world, blockposition, (Boolean) iblockdata.get(BlockTrapdoor.OPEN));
+            return true;
+        }
+    }
+
+    protected void a(@Nullable EntityHuman entityhuman, World world, BlockPosition blockposition, boolean flag) {
+        int i;
+
+        if (flag) {
+            i = this.material == Material.ORE ? 1037 : 1007;
+            world.a(entityhuman, i, blockposition, 0);
+        } else {
+            i = this.material == Material.ORE ? 1036 : 1013;
+            world.a(entityhuman, i, blockposition, 0);
+        }
+
+    }
+
+    public void doPhysics(IBlockData iblockdata, World world, BlockPosition blockposition, Block block, BlockPosition blockposition1) {
+        if (!world.isClientSide) {
+            boolean flag = world.isBlockIndirectlyPowered(blockposition);
+
+            if (flag != (Boolean) iblockdata.get(BlockTrapdoor.c)) {
+                // CraftBukkit start
+                org.bukkit.World bworld = world.getWorld();
+                org.bukkit.block.Block bblock = bworld.getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
+
+                int power = bblock.getBlockPower();
+                int oldPower = (Boolean) iblockdata.get(OPEN) ? 15 : 0;
+
+                if (oldPower == 0 ^ power == 0 || block.getBlockData().isPowerSource()) {
+                    BlockRedstoneEvent eventRedstone = new BlockRedstoneEvent(bblock, oldPower, power);
+                    world.getServer().getPluginManager().callEvent(eventRedstone);
+                    flag = eventRedstone.getNewCurrent() > 0;
+                }
+                // CraftBukkit end
+                if ((Boolean) iblockdata.get(BlockTrapdoor.OPEN) != flag) {
+                    iblockdata = (IBlockData) iblockdata.set(BlockTrapdoor.OPEN, flag);
+                    this.a((EntityHuman) null, world, blockposition, flag);
+                }
+
+                world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockTrapdoor.c, flag), 2);
+                if ((Boolean) iblockdata.get(BlockTrapdoor.o)) {
+                    world.getFluidTickList().a(blockposition, FluidTypes.WATER, FluidTypes.WATER.a((IWorldReader) world));
+                }
+            }
+
+        }
+    }
+
+    public IBlockData getPlacedState(BlockActionContext blockactioncontext) {
+        IBlockData iblockdata = this.getBlockData();
+        Fluid fluid = blockactioncontext.getWorld().getFluid(blockactioncontext.getClickPosition());
+        EnumDirection enumdirection = blockactioncontext.getClickedFace();
+
+        if (!blockactioncontext.c() && enumdirection.k().c()) {
+            iblockdata = (IBlockData) ((IBlockData) iblockdata.set(BlockTrapdoor.FACING, enumdirection)).set(BlockTrapdoor.HALF, blockactioncontext.n() > 0.5F ? BlockPropertyHalf.TOP : BlockPropertyHalf.BOTTOM);
+        } else {
+            iblockdata = (IBlockData) ((IBlockData) iblockdata.set(BlockTrapdoor.FACING, blockactioncontext.f().opposite())).set(BlockTrapdoor.HALF, enumdirection == EnumDirection.UP ? BlockPropertyHalf.BOTTOM : BlockPropertyHalf.TOP);
+        }
+
+        if (blockactioncontext.getWorld().isBlockIndirectlyPowered(blockactioncontext.getClickPosition())) {
+            iblockdata = (IBlockData) ((IBlockData) iblockdata.set(BlockTrapdoor.OPEN, true)).set(BlockTrapdoor.c, true);
+        }
+
+        return (IBlockData) iblockdata.set(BlockTrapdoor.o, fluid.c() == FluidTypes.WATER);
+    }
+
+    public TextureType c() {
+        return TextureType.CUTOUT;
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockTrapdoor.FACING, BlockTrapdoor.OPEN, BlockTrapdoor.HALF, BlockTrapdoor.c, BlockTrapdoor.o);
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return (enumdirection == EnumDirection.UP && iblockdata.get(BlockTrapdoor.HALF) == BlockPropertyHalf.TOP || enumdirection == EnumDirection.DOWN && iblockdata.get(BlockTrapdoor.HALF) == BlockPropertyHalf.BOTTOM) && !(Boolean) iblockdata.get(BlockTrapdoor.OPEN) ? EnumBlockFaceShape.SOLID : EnumBlockFaceShape.UNDEFINED;
+    }
+
+    public FluidType removeFluid(GeneratorAccess generatoraccess, BlockPosition blockposition, IBlockData iblockdata) {
+        if ((Boolean) iblockdata.get(BlockTrapdoor.o)) {
+            generatoraccess.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockTrapdoor.o, false), 3);
+            return FluidTypes.WATER;
+        } else {
+            return FluidTypes.EMPTY;
+        }
+    }
+
+    public Fluid h(IBlockData iblockdata) {
+        return (Boolean) iblockdata.get(BlockTrapdoor.o) ? FluidTypes.WATER.a(false) : super.h(iblockdata);
+    }
+
+    public boolean canPlace(IBlockAccess iblockaccess, BlockPosition blockposition, IBlockData iblockdata, FluidType fluidtype) {
+        return !(Boolean) iblockdata.get(BlockTrapdoor.o) && fluidtype == FluidTypes.WATER;
+    }
+
+    public boolean place(GeneratorAccess generatoraccess, BlockPosition blockposition, IBlockData iblockdata, Fluid fluid) {
+        if (!(Boolean) iblockdata.get(BlockTrapdoor.o) && fluid.c() == FluidTypes.WATER) {
+            if (!generatoraccess.e()) {
+                generatoraccess.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockTrapdoor.o, true), 3);
+                generatoraccess.getFluidTickList().a(blockposition, fluid.c(), fluid.c().a((IWorldReader) generatoraccess));
+            }
+
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        if ((Boolean) iblockdata.get(BlockTrapdoor.o)) {
+            generatoraccess.getFluidTickList().a(blockposition, FluidTypes.WATER, FluidTypes.WATER.a((IWorldReader) generatoraccess));
+        }
+
+        return super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
+    }
+}

src/main/java/net/minecraft/server/BlockTripwire.java

@@ -0,0 +1,222 @@
+package net.minecraft.server;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+
+import org.bukkit.event.entity.EntityInteractEvent; // CraftBukkit
+
+public class BlockTripwire extends Block {
+
+    public static final BlockStateBoolean POWERED = BlockProperties.t;
+    public static final BlockStateBoolean ATTACHED = BlockProperties.a;
+    public static final BlockStateBoolean DISARMED = BlockProperties.c;
+    public static final BlockStateBoolean NORTH = BlockSprawling.a;
+    public static final BlockStateBoolean EAST = BlockSprawling.b;
+    public static final BlockStateBoolean SOUTH = BlockSprawling.c;
+    public static final BlockStateBoolean WEST = BlockSprawling.o;
+    private static final Map<EnumDirection, BlockStateBoolean> u = BlockTall.q;
+    protected static final VoxelShape s = Block.a(0.0D, 1.0D, 0.0D, 16.0D, 2.5D, 16.0D);
+    protected static final VoxelShape t = Block.a(0.0D, 0.0D, 0.0D, 16.0D, 8.0D, 16.0D);
+    private final BlockTripwireHook v;
+
+    public BlockTripwire(BlockTripwireHook blocktripwirehook, Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockTripwire.POWERED, false)).set(BlockTripwire.ATTACHED, false)).set(BlockTripwire.DISARMED, false)).set(BlockTripwire.NORTH, false)).set(BlockTripwire.EAST, false)).set(BlockTripwire.SOUTH, false)).set(BlockTripwire.WEST, false));
+        this.v = blocktripwirehook;
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return (Boolean) iblockdata.get(BlockTripwire.ATTACHED) ? BlockTripwire.s : BlockTripwire.t;
+    }
+
+    public IBlockData getPlacedState(BlockActionContext blockactioncontext) {
+        World world = blockactioncontext.getWorld();
+        BlockPosition blockposition = blockactioncontext.getClickPosition();
+
+        return (IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) this.getBlockData().set(BlockTripwire.NORTH, this.a(world.getType(blockposition.north()), EnumDirection.NORTH))).set(BlockTripwire.EAST, this.a(world.getType(blockposition.east()), EnumDirection.EAST))).set(BlockTripwire.SOUTH, this.a(world.getType(blockposition.south()), EnumDirection.SOUTH))).set(BlockTripwire.WEST, this.a(world.getType(blockposition.west()), EnumDirection.WEST));
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        return enumdirection.k().c() ? (IBlockData) iblockdata.set((IBlockState) BlockTripwire.u.get(enumdirection), this.a(iblockdata1, enumdirection)) : super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public TextureType c() {
+        return TextureType.TRANSLUCENT;
+    }
+
+    public void onPlace(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1) {
+        if (iblockdata1.getBlock() != iblockdata.getBlock()) {
+            this.a(world, blockposition, iblockdata);
+        }
+    }
+
+    public void remove(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1, boolean flag) {
+        if (!flag && iblockdata.getBlock() != iblockdata1.getBlock()) {
+            this.a(world, blockposition, (IBlockData) iblockdata.set(BlockTripwire.POWERED, true));
+        }
+    }
+
+    public void a(World world, BlockPosition blockposition, IBlockData iblockdata, EntityHuman entityhuman) {
+        if (!world.isClientSide && !entityhuman.getItemInMainHand().isEmpty() && entityhuman.getItemInMainHand().getItem() == Items.SHEARS) {
+            world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockTripwire.DISARMED, true), 4);
+        }
+
+        super.a(world, blockposition, iblockdata, entityhuman);
+    }
+
+    private void a(World world, BlockPosition blockposition, IBlockData iblockdata) {
+        EnumDirection[] aenumdirection = new EnumDirection[] { EnumDirection.SOUTH, EnumDirection.WEST};
+        int i = aenumdirection.length;
+        int j = 0;
+
+        while (j < i) {
+            EnumDirection enumdirection = aenumdirection[j];
+            int k = 1;
+
+            while (true) {
+                if (k < 42) {
+                    BlockPosition blockposition1 = blockposition.shift(enumdirection, k);
+                    IBlockData iblockdata1 = world.getType(blockposition1);
+
+                    if (iblockdata1.getBlock() == this.v) {
+                        if (iblockdata1.get(BlockTripwireHook.FACING) == enumdirection.opposite()) {
+                            this.v.a(world, blockposition1, iblockdata1, false, true, k, iblockdata);
+                        }
+                    } else if (iblockdata1.getBlock() == this) {
+                        ++k;
+                        continue;
+                    }
+                }
+
+                ++j;
+                break;
+            }
+        }
+
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
+        if (!world.isClientSide) {
+            if (!(Boolean) iblockdata.get(BlockTripwire.POWERED)) {
+                this.a(world, blockposition);
+            }
+        }
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if (!world.isClientSide) {
+            if ((Boolean) world.getType(blockposition).get(BlockTripwire.POWERED)) {
+                this.a(world, blockposition);
+            }
+        }
+    }
+
+    private void a(World world, BlockPosition blockposition) {
+        IBlockData iblockdata = world.getType(blockposition);
+        boolean flag = (Boolean) iblockdata.get(BlockTripwire.POWERED);
+        boolean flag1 = false;
+        List<? extends Entity> list = world.getEntities((Entity) null, iblockdata.getShape(world, blockposition).getBoundingBox().a(blockposition));
+
+        if (!list.isEmpty()) {
+            Iterator iterator = list.iterator();
+
+            while (iterator.hasNext()) {
+                Entity entity = (Entity) iterator.next();
+
+                if (!entity.isIgnoreBlockTrigger()) {
+                    flag1 = true;
+                    break;
+                }
+            }
+        }
+
+        // CraftBukkit start - Call interact even when triggering connected tripwire
+        if (flag != flag1 && flag1 && (Boolean)iblockdata.get(ATTACHED)) {
+            org.bukkit.World bworld = world.getWorld();
+            org.bukkit.plugin.PluginManager manager = world.getServer().getPluginManager();
+            org.bukkit.block.Block block = bworld.getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
+            boolean allowed = false;
+
+            // If all of the events are cancelled block the tripwire trigger, else allow
+            for (Object object : list) {
+                if (object != null) {
+                    org.bukkit.event.Cancellable cancellable;
+
+                    if (object instanceof EntityHuman) {
+                        cancellable = org.bukkit.craftbukkit.event.CraftEventFactory.callPlayerInteractEvent((EntityHuman) object, org.bukkit.event.block.Action.PHYSICAL, blockposition, null, null, null);
+                    } else if (object instanceof Entity) {
+                        cancellable = new EntityInteractEvent(((Entity) object).getBukkitEntity(), block);
+                        manager.callEvent((EntityInteractEvent) cancellable);
+                    } else {
+                        continue;
+                    }
+
+                    if (!cancellable.isCancelled()) {
+                        allowed = true;
+                        break;
+                    }
+                }
+            }
+
+            if (!allowed) {
+                return;
+            }
+        }
+        // CraftBukkit end
+
+        if (flag1 != flag) {
+            iblockdata = (IBlockData) iblockdata.set(BlockTripwire.POWERED, flag1);
+            world.setTypeAndData(blockposition, iblockdata, 3);
+            this.a(world, blockposition, iblockdata);
+        }
+
+        if (flag1) {
+            world.getBlockTickList().a(new BlockPosition(blockposition), this, this.a((IWorldReader) world));
+        }
+
+    }
+
+    public boolean a(IBlockData iblockdata, EnumDirection enumdirection) {
+        Block block = iblockdata.getBlock();
+
+        return block == this.v ? iblockdata.get(BlockTripwireHook.FACING) == enumdirection.opposite() : block == this;
+    }
+
+    public IBlockData a(IBlockData iblockdata, EnumBlockRotation enumblockrotation) {
+        switch (enumblockrotation) {
+        case CLOCKWISE_180:
+            return (IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) iblockdata.set(BlockTripwire.NORTH, iblockdata.get(BlockTripwire.SOUTH))).set(BlockTripwire.EAST, iblockdata.get(BlockTripwire.WEST))).set(BlockTripwire.SOUTH, iblockdata.get(BlockTripwire.NORTH))).set(BlockTripwire.WEST, iblockdata.get(BlockTripwire.EAST));
+        case COUNTERCLOCKWISE_90:
+            return (IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) iblockdata.set(BlockTripwire.NORTH, iblockdata.get(BlockTripwire.EAST))).set(BlockTripwire.EAST, iblockdata.get(BlockTripwire.SOUTH))).set(BlockTripwire.SOUTH, iblockdata.get(BlockTripwire.WEST))).set(BlockTripwire.WEST, iblockdata.get(BlockTripwire.NORTH));
+        case CLOCKWISE_90:
+            return (IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) iblockdata.set(BlockTripwire.NORTH, iblockdata.get(BlockTripwire.WEST))).set(BlockTripwire.EAST, iblockdata.get(BlockTripwire.NORTH))).set(BlockTripwire.SOUTH, iblockdata.get(BlockTripwire.EAST))).set(BlockTripwire.WEST, iblockdata.get(BlockTripwire.SOUTH));
+        default:
+            return iblockdata;
+        }
+    }
+
+    public IBlockData a(IBlockData iblockdata, EnumBlockMirror enumblockmirror) {
+        switch (enumblockmirror) {
+        case LEFT_RIGHT:
+            return (IBlockData) ((IBlockData) iblockdata.set(BlockTripwire.NORTH, iblockdata.get(BlockTripwire.SOUTH))).set(BlockTripwire.SOUTH, iblockdata.get(BlockTripwire.NORTH));
+        case FRONT_BACK:
+            return (IBlockData) ((IBlockData) iblockdata.set(BlockTripwire.EAST, iblockdata.get(BlockTripwire.WEST))).set(BlockTripwire.WEST, iblockdata.get(BlockTripwire.EAST));
+        default:
+            return super.a(iblockdata, enumblockmirror);
+        }
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockTripwire.POWERED, BlockTripwire.ATTACHED, BlockTripwire.DISARMED, BlockTripwire.NORTH, BlockTripwire.EAST, BlockTripwire.WEST, BlockTripwire.SOUTH);
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return EnumBlockFaceShape.UNDEFINED;
+    }
+}

src/main/java/net/minecraft/server/BlockTripwireHook.java

@@ -0,0 +1,245 @@
+package net.minecraft.server;
+
+import com.google.common.base.MoreObjects;
+import java.util.Random;
+import javax.annotation.Nullable;
+
+import org.bukkit.event.block.BlockRedstoneEvent; // CraftBukkit
+
+public class BlockTripwireHook extends Block {
+
+    public static final BlockStateDirection FACING = BlockFacingHorizontal.FACING;
+    public static final BlockStateBoolean POWERED = BlockProperties.t;
+    public static final BlockStateBoolean ATTACHED = BlockProperties.a;
+    protected static final VoxelShape o = Block.a(5.0D, 0.0D, 10.0D, 11.0D, 10.0D, 16.0D);
+    protected static final VoxelShape p = Block.a(5.0D, 0.0D, 0.0D, 11.0D, 10.0D, 6.0D);
+    protected static final VoxelShape q = Block.a(10.0D, 0.0D, 5.0D, 16.0D, 10.0D, 11.0D);
+    protected static final VoxelShape r = Block.a(0.0D, 0.0D, 5.0D, 6.0D, 10.0D, 11.0D);
+
+    public BlockTripwireHook(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockTripwireHook.FACING, EnumDirection.NORTH)).set(BlockTripwireHook.POWERED, false)).set(BlockTripwireHook.ATTACHED, false));
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        switch ((EnumDirection) iblockdata.get(BlockTripwireHook.FACING)) {
+        case EAST:
+        default:
+            return BlockTripwireHook.r;
+        case WEST:
+            return BlockTripwireHook.q;
+        case SOUTH:
+            return BlockTripwireHook.p;
+        case NORTH:
+            return BlockTripwireHook.o;
+        }
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public boolean canPlace(IBlockData iblockdata, IWorldReader iworldreader, BlockPosition blockposition) {
+        EnumDirection enumdirection = (EnumDirection) iblockdata.get(BlockTripwireHook.FACING);
+        BlockPosition blockposition1 = blockposition.shift(enumdirection.opposite());
+        IBlockData iblockdata1 = iworldreader.getType(blockposition1);
+        boolean flag = b(iblockdata1.getBlock());
+
+        return !flag && enumdirection.k().c() && iblockdata1.c(iworldreader, blockposition1, enumdirection) == EnumBlockFaceShape.SOLID && !iblockdata1.isPowerSource();
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        return enumdirection.opposite() == iblockdata.get(BlockTripwireHook.FACING) && !iblockdata.canPlace(generatoraccess, blockposition) ? Blocks.AIR.getBlockData() : super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
+    }
+
+    @Nullable
+    public IBlockData getPlacedState(BlockActionContext blockactioncontext) {
+        IBlockData iblockdata = (IBlockData) ((IBlockData) this.getBlockData().set(BlockTripwireHook.POWERED, false)).set(BlockTripwireHook.ATTACHED, false);
+        World world = blockactioncontext.getWorld();
+        BlockPosition blockposition = blockactioncontext.getClickPosition();
+        EnumDirection[] aenumdirection = blockactioncontext.e();
+        EnumDirection[] aenumdirection1 = aenumdirection;
+        int i = aenumdirection.length;
+
+        for (int j = 0; j < i; ++j) {
+            EnumDirection enumdirection = aenumdirection1[j];
+
+            if (enumdirection.k().c()) {
+                EnumDirection enumdirection1 = enumdirection.opposite();
+
+                iblockdata = (IBlockData) iblockdata.set(BlockTripwireHook.FACING, enumdirection1);
+                if (iblockdata.canPlace(world, blockposition)) {
+                    return iblockdata;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    public void postPlace(World world, BlockPosition blockposition, IBlockData iblockdata, EntityLiving entityliving, ItemStack itemstack) {
+        this.a(world, blockposition, iblockdata, false, false, -1, (IBlockData) null);
+    }
+
+    public void a(World world, BlockPosition blockposition, IBlockData iblockdata, boolean flag, boolean flag1, int i, @Nullable IBlockData iblockdata1) {
+        EnumDirection enumdirection = (EnumDirection) iblockdata.get(BlockTripwireHook.FACING);
+        boolean flag2 = (Boolean) iblockdata.get(BlockTripwireHook.ATTACHED);
+        boolean flag3 = (Boolean) iblockdata.get(BlockTripwireHook.POWERED);
+        boolean flag4 = !flag;
+        boolean flag5 = false;
+        int j = 0;
+        IBlockData[] aiblockdata = new IBlockData[42];
+
+        BlockPosition blockposition1;
+
+        for (int k = 1; k < 42; ++k) {
+            blockposition1 = blockposition.shift(enumdirection, k);
+            IBlockData iblockdata2 = world.getType(blockposition1);
+
+            if (iblockdata2.getBlock() == Blocks.TRIPWIRE_HOOK) {
+                if (iblockdata2.get(BlockTripwireHook.FACING) == enumdirection.opposite()) {
+                    j = k;
+                }
+                break;
+            }
+
+            if (iblockdata2.getBlock() != Blocks.TRIPWIRE && k != i) {
+                aiblockdata[k] = null;
+                flag4 = false;
+            } else {
+                if (k == i) {
+                    iblockdata2 = (IBlockData) MoreObjects.firstNonNull(iblockdata1, iblockdata2);
+                }
+
+                boolean flag6 = !(Boolean) iblockdata2.get(BlockTripwire.DISARMED);
+                boolean flag7 = (Boolean) iblockdata2.get(BlockTripwire.POWERED);
+
+                flag5 |= flag6 && flag7;
+                aiblockdata[k] = iblockdata2;
+                if (k == i) {
+                    world.getBlockTickList().a(blockposition, this, this.a((IWorldReader) world));
+                    flag4 &= flag6;
+                }
+            }
+        }
+
+        flag4 &= j > 1;
+        flag5 &= flag4;
+        IBlockData iblockdata3 = (IBlockData) ((IBlockData) this.getBlockData().set(BlockTripwireHook.ATTACHED, flag4)).set(BlockTripwireHook.POWERED, flag5);
+
+        if (j > 0) {
+            blockposition1 = blockposition.shift(enumdirection, j);
+            EnumDirection enumdirection1 = enumdirection.opposite();
+
+            world.setTypeAndData(blockposition1, (IBlockData) iblockdata3.set(BlockTripwireHook.FACING, enumdirection1), 3);
+            this.a(world, blockposition1, enumdirection1);
+            this.a(world, blockposition1, flag4, flag5, flag2, flag3);
+        }
+
+        // CraftBukkit start
+        org.bukkit.block.Block block = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
+
+        BlockRedstoneEvent eventRedstone = new BlockRedstoneEvent(block, 15, 0);
+        world.getServer().getPluginManager().callEvent(eventRedstone);
+
+        if (eventRedstone.getNewCurrent() > 0) {
+            return;
+        }
+        // CraftBukkit end
+
+        this.a(world, blockposition, flag4, flag5, flag2, flag3);
+        if (!flag) {
+            world.setTypeAndData(blockposition, (IBlockData) iblockdata3.set(BlockTripwireHook.FACING, enumdirection), 3);
+            if (flag1) {
+                this.a(world, blockposition, enumdirection);
+            }
+        }
+
+        if (flag2 != flag4) {
+            for (int l = 1; l < j; ++l) {
+                BlockPosition blockposition2 = blockposition.shift(enumdirection, l);
+                IBlockData iblockdata4 = aiblockdata[l];
+
+                if (iblockdata4 != null) {
+                    world.setTypeAndData(blockposition2, (IBlockData) iblockdata4.set(BlockTripwireHook.ATTACHED, flag4), 3);
+                    if (!world.getType(blockposition2).isAir()) {
+                        ;
+                    }
+                }
+            }
+        }
+
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        this.a(world, blockposition, iblockdata, false, true, -1, (IBlockData) null);
+    }
+
+    private void a(World world, BlockPosition blockposition, boolean flag, boolean flag1, boolean flag2, boolean flag3) {
+        if (flag1 && !flag3) {
+            world.a((EntityHuman) null, blockposition, SoundEffects.BLOCK_TRIPWIRE_CLICK_ON, SoundCategory.BLOCKS, 0.4F, 0.6F);
+        } else if (!flag1 && flag3) {
+            world.a((EntityHuman) null, blockposition, SoundEffects.BLOCK_TRIPWIRE_CLICK_OFF, SoundCategory.BLOCKS, 0.4F, 0.5F);
+        } else if (flag && !flag2) {
+            world.a((EntityHuman) null, blockposition, SoundEffects.BLOCK_TRIPWIRE_ATTACH, SoundCategory.BLOCKS, 0.4F, 0.7F);
+        } else if (!flag && flag2) {
+            world.a((EntityHuman) null, blockposition, SoundEffects.BLOCK_TRIPWIRE_DETACH, SoundCategory.BLOCKS, 0.4F, 1.2F / (world.random.nextFloat() * 0.2F + 0.9F));
+        }
+
+    }
+
+    private void a(World world, BlockPosition blockposition, EnumDirection enumdirection) {
+        world.applyPhysics(blockposition, this);
+        world.applyPhysics(blockposition.shift(enumdirection.opposite()), this);
+    }
+
+    public void remove(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1, boolean flag) {
+        if (!flag && iblockdata.getBlock() != iblockdata1.getBlock()) {
+            boolean flag1 = (Boolean) iblockdata.get(BlockTripwireHook.ATTACHED);
+            boolean flag2 = (Boolean) iblockdata.get(BlockTripwireHook.POWERED);
+
+            if (flag1 || flag2) {
+                this.a(world, blockposition, iblockdata, true, false, -1, (IBlockData) null);
+            }
+
+            if (flag2) {
+                world.applyPhysics(blockposition, this);
+                world.applyPhysics(blockposition.shift(((EnumDirection) iblockdata.get(BlockTripwireHook.FACING)).opposite()), this);
+            }
+
+            super.remove(iblockdata, world, blockposition, iblockdata1, flag);
+        }
+    }
+
+    public int a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, EnumDirection enumdirection) {
+        return (Boolean) iblockdata.get(BlockTripwireHook.POWERED) ? 15 : 0;
+    }
+
+    public int b(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition, EnumDirection enumdirection) {
+        return !(Boolean) iblockdata.get(BlockTripwireHook.POWERED) ? 0 : (iblockdata.get(BlockTripwireHook.FACING) == enumdirection ? 15 : 0);
+    }
+
+    public boolean isPowerSource(IBlockData iblockdata) {
+        return true;
+    }
+
+    public TextureType c() {
+        return TextureType.CUTOUT_MIPPED;
+    }
+
+    public IBlockData a(IBlockData iblockdata, EnumBlockRotation enumblockrotation) {
+        return (IBlockData) iblockdata.set(BlockTripwireHook.FACING, enumblockrotation.a((EnumDirection) iblockdata.get(BlockTripwireHook.FACING)));
+    }
+
+    public IBlockData a(IBlockData iblockdata, EnumBlockMirror enumblockmirror) {
+        return iblockdata.a(enumblockmirror.a((EnumDirection) iblockdata.get(BlockTripwireHook.FACING)));
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockTripwireHook.FACING, BlockTripwireHook.POWERED, BlockTripwireHook.ATTACHED);
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return EnumBlockFaceShape.UNDEFINED;
+    }
+}

src/main/java/net/minecraft/server/BlockTurtleEgg.java

@@ -0,0 +1,174 @@
+package net.minecraft.server;
+
+import java.util.Random;
+import javax.annotation.Nullable;
+import org.bukkit.craftbukkit.block.CraftBlock;
+
+// CraftBukkit start
+import org.bukkit.event.entity.EntityInteractEvent;
+import org.bukkit.craftbukkit.event.CraftEventFactory;
+// CraftBukkit end
+
+public class BlockTurtleEgg extends Block {
+
+    private static final VoxelShape c = Block.a(3.0D, 0.0D, 3.0D, 12.0D, 7.0D, 12.0D);
+    private static final VoxelShape o = Block.a(1.0D, 0.0D, 1.0D, 15.0D, 7.0D, 15.0D);
+    public static final BlockStateInteger a = BlockProperties.ad;
+    public static final BlockStateInteger b = BlockProperties.ac;
+
+    public BlockTurtleEgg(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockTurtleEgg.a, 0)).set(BlockTurtleEgg.b, 1));
+    }
+
+    public void stepOn(World world, BlockPosition blockposition, Entity entity) {
+        this.a(world, blockposition, entity, 100);
+        super.stepOn(world, blockposition, entity);
+    }
+
+    public void fallOn(World world, BlockPosition blockposition, Entity entity, float f) {
+        if (!(entity instanceof EntityZombie)) {
+            this.a(world, blockposition, entity, 3);
+        }
+
+        super.fallOn(world, blockposition, entity, f);
+    }
+
+    private void a(World world, BlockPosition blockposition, Entity entity, int i) {
+        if (!this.a(world, entity)) {
+            super.stepOn(world, blockposition, entity);
+        } else {
+            if (!world.isClientSide && world.random.nextInt(i) == 0) {
+                // CraftBukkit start - Step on eggs
+                org.bukkit.event.Cancellable cancellable;
+                if (entity instanceof EntityHuman) {
+                    cancellable = CraftEventFactory.callPlayerInteractEvent((EntityHuman) entity, org.bukkit.event.block.Action.PHYSICAL, blockposition, null, null, null);
+                } else {
+                    cancellable = new EntityInteractEvent(entity.getBukkitEntity(), CraftBlock.at(world, blockposition));
+                    world.getServer().getPluginManager().callEvent((EntityInteractEvent) cancellable);
+                }
+
+                if (cancellable.isCancelled()) {
+                    return;
+                }
+                // CraftBukkit end
+                this.a(world, blockposition, world.getType(blockposition));
+            }
+
+        }
+    }
+
+    private void a(World world, BlockPosition blockposition, IBlockData iblockdata) {
+        world.a((EntityHuman) null, blockposition, SoundEffects.ENTITY_TURTLE_EGG_BREAK, SoundCategory.BLOCKS, 0.7F, 0.9F + world.random.nextFloat() * 0.2F);
+        int i = (Integer) iblockdata.get(BlockTurtleEgg.b);
+
+        if (i <= 1) {
+            world.setAir(blockposition, false);
+        } else {
+            world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockTurtleEgg.b, i - 1), 2);
+            world.triggerEffect(2001, blockposition, Block.getCombinedId(iblockdata));
+        }
+
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if (this.a(world) && this.a((IBlockAccess) world, blockposition)) {
+            int i = (Integer) iblockdata.get(BlockTurtleEgg.a);
+
+            if (i < 2) {
+                // CraftBukkit start - Call BlockGrowEvent
+                if (!CraftEventFactory.handleBlockGrowEvent(world, blockposition, iblockdata.set(BlockTurtleEgg.a, i + 1), 2)) {
+                    return;
+                }
+                // CraftBukkit end
+                world.a((EntityHuman) null, blockposition, SoundEffects.ENTITY_TURTLE_EGG_CRACK, SoundCategory.BLOCKS, 0.7F, 0.9F + random.nextFloat() * 0.2F);
+                // world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockTurtleEgg.a, i + 1), 2); // CraftBukkit - handled above
+            } else {
+                // CraftBukkit start - Call BlockFadeEvent
+                if (CraftEventFactory.callBlockFadeEvent(world, blockposition, Blocks.AIR.getBlockData()).isCancelled()) {
+                    return;
+                }
+                // CraftBukkit end
+                world.a((EntityHuman) null, blockposition, SoundEffects.ENTITY_TURTLE_EGG_HATCH, SoundCategory.BLOCKS, 0.7F, 0.9F + random.nextFloat() * 0.2F);
+                world.setAir(blockposition);
+                if (!world.isClientSide) {
+                    for (int j = 0; j < (Integer) iblockdata.get(BlockTurtleEgg.b); ++j) {
+                        world.triggerEffect(2001, blockposition, Block.getCombinedId(iblockdata));
+                        EntityTurtle entityturtle = EntityTypes.TURTLE.create(world); // Paper
+
+                        entityturtle.setAgeRaw(-24000);
+                        entityturtle.g(blockposition);
+                        entityturtle.setPositionRotation((double) blockposition.getX() + 0.3D + (double) j * 0.2D, (double) blockposition.getY(), (double) blockposition.getZ() + 0.3D, 0.0F, 0.0F);
+                        world.addEntity(entityturtle, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.EGG); // CraftBukkit
+                    }
+                }
+            }
+        }
+
+    }
+
+    private boolean a(IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return iblockaccess.getType(blockposition.down()).getBlock() == Blocks.SAND;
+    }
+
+    public void onPlace(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1) {
+        if (this.a((IBlockAccess) world, blockposition) && !world.isClientSide) {
+            world.triggerEffect(2005, blockposition, 0);
+        }
+
+    }
+
+    private boolean a(World world) {
+        float f = world.k(1.0F);
+
+        return (double) f < 0.69D && (double) f > 0.65D ? true : world.random.nextInt(500) == 0;
+    }
+
+    protected boolean X_() {
+        return true;
+    }
+
+    public void a(World world, EntityHuman entityhuman, BlockPosition blockposition, IBlockData iblockdata, @Nullable TileEntity tileentity, ItemStack itemstack) {
+        super.a(world, entityhuman, blockposition, iblockdata, tileentity, itemstack);
+        this.a(world, blockposition, iblockdata);
+    }
+
+    public IMaterial getDropType(IBlockData iblockdata, World world, BlockPosition blockposition, int i) {
+        return Items.AIR;
+    }
+
+    public boolean a(IBlockData iblockdata, BlockActionContext blockactioncontext) {
+        return blockactioncontext.getItemStack().getItem() == this.getItem() && (Integer) iblockdata.get(BlockTurtleEgg.b) < 4 ? true : super.a(iblockdata, blockactioncontext);
+    }
+
+    @Nullable
+    public IBlockData getPlacedState(BlockActionContext blockactioncontext) {
+        IBlockData iblockdata = blockactioncontext.getWorld().getType(blockactioncontext.getClickPosition());
+
+        return iblockdata.getBlock() == this ? (IBlockData) iblockdata.set(BlockTurtleEgg.b, Math.min(4, (Integer) iblockdata.get(BlockTurtleEgg.b) + 1)) : super.getPlacedState(blockactioncontext);
+    }
+
+    public TextureType c() {
+        return TextureType.CUTOUT;
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return (Integer) iblockdata.get(BlockTurtleEgg.b) > 1 ? BlockTurtleEgg.o : BlockTurtleEgg.c;
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return EnumBlockFaceShape.UNDEFINED;
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockTurtleEgg.a, BlockTurtleEgg.b);
+    }
+
+    private boolean a(World world, Entity entity) {
+        return entity instanceof EntityTurtle ? false : (entity instanceof EntityLiving && !(entity instanceof EntityHuman) ? world.getGameRules().getBoolean("mobGriefing") : true);
+    }
+}

src/main/java/net/minecraft/server/BlockVine.java

@@ -0,0 +1,385 @@
+package net.minecraft.server;
+
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Random;
+import java.util.Map.Entry;
+import javax.annotation.Nullable;
+
+import org.bukkit.craftbukkit.event.CraftEventFactory; // CraftBukkit
+
+public class BlockVine extends Block {
+
+    public static final BlockStateBoolean UP = BlockSprawling.p;
+    public static final BlockStateBoolean NORTH = BlockSprawling.a;
+    public static final BlockStateBoolean EAST = BlockSprawling.b;
+    public static final BlockStateBoolean SOUTH = BlockSprawling.c;
+    public static final BlockStateBoolean WEST = BlockSprawling.o;
+    public static final Map<EnumDirection, BlockStateBoolean> q = (Map) BlockSprawling.r.entrySet().stream().filter((entry) -> {
+        return entry.getKey() != EnumDirection.DOWN;
+    }).collect(SystemUtils.a());
+    protected static final VoxelShape r = Block.a(0.0D, 15.0D, 0.0D, 16.0D, 16.0D, 16.0D);
+    protected static final VoxelShape s = Block.a(0.0D, 0.0D, 0.0D, 1.0D, 16.0D, 16.0D);
+    protected static final VoxelShape t = Block.a(15.0D, 0.0D, 0.0D, 16.0D, 16.0D, 16.0D);
+    protected static final VoxelShape u = Block.a(0.0D, 0.0D, 0.0D, 16.0D, 16.0D, 1.0D);
+    protected static final VoxelShape v = Block.a(0.0D, 0.0D, 15.0D, 16.0D, 16.0D, 16.0D);
+
+    public BlockVine(Block.Info block_info) {
+        super(block_info);
+        this.v((IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockVine.UP, false)).set(BlockVine.NORTH, false)).set(BlockVine.EAST, false)).set(BlockVine.SOUTH, false)).set(BlockVine.WEST, false));
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        VoxelShape voxelshape = VoxelShapes.a();
+
+        if ((Boolean) iblockdata.get(BlockVine.UP)) {
+            voxelshape = VoxelShapes.a(voxelshape, BlockVine.r);
+        }
+
+        if ((Boolean) iblockdata.get(BlockVine.NORTH)) {
+            voxelshape = VoxelShapes.a(voxelshape, BlockVine.u);
+        }
+
+        if ((Boolean) iblockdata.get(BlockVine.EAST)) {
+            voxelshape = VoxelShapes.a(voxelshape, BlockVine.t);
+        }
+
+        if ((Boolean) iblockdata.get(BlockVine.SOUTH)) {
+            voxelshape = VoxelShapes.a(voxelshape, BlockVine.v);
+        }
+
+        if ((Boolean) iblockdata.get(BlockVine.WEST)) {
+            voxelshape = VoxelShapes.a(voxelshape, BlockVine.s);
+        }
+
+        return voxelshape;
+    }
+
+    public boolean a(IBlockData iblockdata) {
+        return false;
+    }
+
+    public boolean canPlace(IBlockData iblockdata, IWorldReader iworldreader, BlockPosition blockposition) {
+        return this.k(this.m(iblockdata, iworldreader, blockposition));
+    }
+
+    private boolean k(IBlockData iblockdata) {
+        return this.w(iblockdata) > 0;
+    }
+
+    private int w(IBlockData iblockdata) {
+        int i = 0;
+        Iterator iterator = BlockVine.q.values().iterator();
+
+        while (iterator.hasNext()) {
+            BlockStateBoolean blockstateboolean = (BlockStateBoolean) iterator.next();
+
+            if ((Boolean) iblockdata.get(blockstateboolean)) {
+                ++i;
+            }
+        }
+
+        return i;
+    }
+
+    private boolean a(IBlockAccess iblockaccess, BlockPosition blockposition, EnumDirection enumdirection) {
+        if (enumdirection == EnumDirection.DOWN) {
+            return false;
+        } else {
+            BlockPosition blockposition1 = blockposition.shift(enumdirection);
+
+            if (this.b(iblockaccess, blockposition1, enumdirection)) {
+                return true;
+            } else if (enumdirection.k() == EnumDirection.EnumAxis.Y) {
+                return false;
+            } else {
+                BlockStateBoolean blockstateboolean = (BlockStateBoolean) BlockVine.q.get(enumdirection);
+                IBlockData iblockdata = iblockaccess.getType(blockposition.up());
+
+                return iblockdata.getBlock() == this && (Boolean) iblockdata.get(blockstateboolean);
+            }
+        }
+    }
+
+    private boolean b(IBlockAccess iblockaccess, BlockPosition blockposition, EnumDirection enumdirection) {
+        IBlockData iblockdata = iblockaccess.getType(blockposition);
+
+        return iblockdata.c(iblockaccess, blockposition, enumdirection.opposite()) == EnumBlockFaceShape.SOLID && !f(iblockdata.getBlock());
+    }
+
+    protected static boolean f(Block block) {
+        return block instanceof BlockShulkerBox || block instanceof BlockStainedGlass || block == Blocks.BEACON || block == Blocks.CAULDRON || block == Blocks.GLASS || block == Blocks.PISTON || block == Blocks.STICKY_PISTON || block == Blocks.PISTON_HEAD || block.a(TagsBlock.WOODEN_TRAPDOORS);
+    }
+
+    private IBlockData m(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        BlockPosition blockposition1 = blockposition.up();
+
+        if ((Boolean) iblockdata.get(BlockVine.UP)) {
+            iblockdata = (IBlockData) iblockdata.set(BlockVine.UP, this.b(iblockaccess, blockposition1, EnumDirection.DOWN));
+        }
+
+        IBlockData iblockdata1 = null;
+        Iterator iterator = EnumDirection.EnumDirectionLimit.HORIZONTAL.iterator();
+
+        while (iterator.hasNext()) {
+            EnumDirection enumdirection = (EnumDirection) iterator.next();
+            BlockStateBoolean blockstateboolean = getDirection(enumdirection);
+
+            if ((Boolean) iblockdata.get(blockstateboolean)) {
+                boolean flag = this.a(iblockaccess, blockposition, enumdirection);
+
+                if (!flag) {
+                    if (iblockdata1 == null) {
+                        iblockdata1 = iblockaccess.getType(blockposition1);
+                    }
+
+                    flag = iblockdata1.getBlock() == this && (Boolean) iblockdata1.get(blockstateboolean);
+                }
+
+                iblockdata = (IBlockData) iblockdata.set(blockstateboolean, flag);
+            }
+        }
+
+        return iblockdata;
+    }
+
+    public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+        if (enumdirection == EnumDirection.DOWN) {
+            return super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
+        } else {
+            IBlockData iblockdata2 = this.m(iblockdata, generatoraccess, blockposition);
+
+            return !this.k(iblockdata2) ? Blocks.AIR.getBlockData() : iblockdata2;
+        }
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Random random) {
+        if (!world.isClientSide) {
+            IBlockData iblockdata1 = this.m(iblockdata, world, blockposition);
+
+            if (iblockdata1 != iblockdata) {
+                if (this.k(iblockdata1)) {
+                    world.setTypeAndData(blockposition, iblockdata1, 2);
+                } else {
+                    iblockdata.a(world, blockposition, 0);
+                    world.setAir(blockposition);
+                }
+
+            } else if (world.random.nextInt(Math.max(1, (int) (100.0F / world.spigotConfig.vineModifier) * 4)) == 0) { // Spigot
+                EnumDirection enumdirection = EnumDirection.a(random);
+                BlockPosition blockposition1 = blockposition.up();
+                BlockPosition blockposition2;
+                IBlockData iblockdata2;
+                EnumDirection enumdirection1;
+
+                if (enumdirection.k().c() && !(Boolean) iblockdata.get(getDirection(enumdirection))) {
+                    if (this.a((IBlockAccess) world, blockposition)) {
+                        blockposition2 = blockposition.shift(enumdirection);
+                        iblockdata2 = world.getType(blockposition2);
+                        if (iblockdata2.isAir()) {
+                            enumdirection1 = enumdirection.e();
+                            EnumDirection enumdirection2 = enumdirection.f();
+                            boolean flag = (Boolean) iblockdata.get(getDirection(enumdirection1));
+                            boolean flag1 = (Boolean) iblockdata.get(getDirection(enumdirection2));
+                            BlockPosition blockposition3 = blockposition2.shift(enumdirection1);
+                            BlockPosition blockposition4 = blockposition2.shift(enumdirection2);
+
+                            // CraftBukkit start - Call BlockSpreadEvent
+                            BlockPosition source = blockposition;
+
+                            if (flag && this.b((IBlockAccess) world, blockposition3, enumdirection1)) {
+                                CraftEventFactory.handleBlockSpreadEvent(world, source, blockposition2, (IBlockData) this.getBlockData().set(getDirection(enumdirection1), true), 2);
+                            } else if (flag1 && this.b((IBlockAccess) world, blockposition4, enumdirection2)) {
+                                CraftEventFactory.handleBlockSpreadEvent(world, source, blockposition2, (IBlockData) this.getBlockData().set(getDirection(enumdirection2), true), 2);
+                            } else {
+                                EnumDirection enumdirection3 = enumdirection.opposite();
+
+                                if (flag && world.isEmpty(blockposition3) && this.b((IBlockAccess) world, blockposition.shift(enumdirection1), enumdirection3)) {
+                                    CraftEventFactory.handleBlockSpreadEvent(world, source, blockposition3, (IBlockData) this.getBlockData().set(getDirection(enumdirection3), true), 2);
+                                } else if (flag1 && world.isEmpty(blockposition4) && this.b((IBlockAccess) world, blockposition.shift(enumdirection2), enumdirection3)) {
+                                    CraftEventFactory.handleBlockSpreadEvent(world, source, blockposition4, (IBlockData) this.getBlockData().set(getDirection(enumdirection3), true), 2);
+                                } else if ((double) world.random.nextFloat() < 0.05D && this.b((IBlockAccess) world, blockposition2.up(), EnumDirection.UP)) {
+                                    CraftEventFactory.handleBlockSpreadEvent(world, source, blockposition2, (IBlockData) this.getBlockData().set(BlockVine.UP, true), 2);
+                                }
+                                // CraftBukkit end
+                            }
+                        } else if (this.b((IBlockAccess) world, blockposition2, enumdirection)) {
+                            world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(getDirection(enumdirection), true), 2);
+                        }
+
+                    }
+                } else {
+                    if (enumdirection == EnumDirection.UP && blockposition.getY() < 255) {
+                        if (this.a((IBlockAccess) world, blockposition, enumdirection)) {
+                            world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockVine.UP, true), 2);
+                            return;
+                        }
+
+                        if (world.isEmpty(blockposition1)) {
+                            if (!this.a((IBlockAccess) world, blockposition)) {
+                                return;
+                            }
+
+                            IBlockData iblockdata3 = iblockdata;
+                            Iterator iterator = EnumDirection.EnumDirectionLimit.HORIZONTAL.iterator();
+
+                            while (iterator.hasNext()) {
+                                enumdirection1 = (EnumDirection) iterator.next();
+                                if (random.nextBoolean() || !this.b((IBlockAccess) world, blockposition1.shift(enumdirection1), EnumDirection.UP)) {
+                                    iblockdata3 = (IBlockData) iblockdata3.set(getDirection(enumdirection1), false);
+                                }
+                            }
+
+                            if (this.x(iblockdata3)) {
+                                CraftEventFactory.handleBlockSpreadEvent(world, blockposition, blockposition1, iblockdata3, 2); // CraftBukkit
+                            }
+
+                            return;
+                        }
+                    }
+
+                    if (blockposition.getY() > 0) {
+                        blockposition2 = blockposition.down();
+                        iblockdata2 = world.getType(blockposition2);
+                        if (iblockdata2.isAir() || iblockdata2.getBlock() == this) {
+                            IBlockData iblockdata4 = iblockdata2.isAir() ? this.getBlockData() : iblockdata2;
+                            IBlockData iblockdata5 = this.a(iblockdata, iblockdata4, random);
+
+                            if (iblockdata4 != iblockdata5 && this.x(iblockdata5)) {
+                                CraftEventFactory.handleBlockSpreadEvent(world, blockposition, blockposition2, iblockdata5, 2); // CraftBukkit
+                            }
+                        }
+                    }
+
+                }
+            }
+        }
+    }
+
+    private IBlockData a(IBlockData iblockdata, IBlockData iblockdata1, Random random) {
+        Iterator iterator = EnumDirection.EnumDirectionLimit.HORIZONTAL.iterator();
+
+        while (iterator.hasNext()) {
+            EnumDirection enumdirection = (EnumDirection) iterator.next();
+
+            if (random.nextBoolean()) {
+                BlockStateBoolean blockstateboolean = getDirection(enumdirection);
+
+                if ((Boolean) iblockdata.get(blockstateboolean)) {
+                    iblockdata1 = (IBlockData) iblockdata1.set(blockstateboolean, true);
+                }
+            }
+        }
+
+        return iblockdata1;
+    }
+
+    private boolean x(IBlockData iblockdata) {
+        return (Boolean) iblockdata.get(BlockVine.NORTH) || (Boolean) iblockdata.get(BlockVine.EAST) || (Boolean) iblockdata.get(BlockVine.SOUTH) || (Boolean) iblockdata.get(BlockVine.WEST);
+    }
+
+    private boolean a(IBlockAccess iblockaccess, BlockPosition blockposition) {
+        boolean flag = true;
+        Iterable<BlockPosition.MutableBlockPosition> iterable = BlockPosition.MutableBlockPosition.b(blockposition.getX() - 4, blockposition.getY() - 1, blockposition.getZ() - 4, blockposition.getX() + 4, blockposition.getY() + 1, blockposition.getZ() + 4);
+        int i = 5;
+        Iterator iterator = iterable.iterator();
+
+        while (iterator.hasNext()) {
+            BlockPosition blockposition1 = (BlockPosition) iterator.next();
+
+            if (iblockaccess.getType(blockposition1).getBlock() == this) {
+                --i;
+                if (i <= 0) {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    public boolean a(IBlockData iblockdata, BlockActionContext blockactioncontext) {
+        IBlockData iblockdata1 = blockactioncontext.getWorld().getType(blockactioncontext.getClickPosition());
+
+        return iblockdata1.getBlock() == this ? this.w(iblockdata1) < BlockVine.q.size() : super.a(iblockdata, blockactioncontext);
+    }
+
+    @Nullable
+    public IBlockData getPlacedState(BlockActionContext blockactioncontext) {
+        IBlockData iblockdata = blockactioncontext.getWorld().getType(blockactioncontext.getClickPosition());
+        boolean flag = iblockdata.getBlock() == this;
+        IBlockData iblockdata1 = flag ? iblockdata : this.getBlockData();
+        EnumDirection[] aenumdirection = blockactioncontext.e();
+        int i = aenumdirection.length;
+
+        for (int j = 0; j < i; ++j) {
+            EnumDirection enumdirection = aenumdirection[j];
+
+            if (enumdirection != EnumDirection.DOWN) {
+                BlockStateBoolean blockstateboolean = getDirection(enumdirection);
+                boolean flag1 = flag && (Boolean) iblockdata.get(blockstateboolean);
+
+                if (!flag1 && this.a((IBlockAccess) blockactioncontext.getWorld(), blockactioncontext.getClickPosition(), enumdirection)) {
+                    return (IBlockData) iblockdata1.set(blockstateboolean, true);
+                }
+            }
+        }
+
+        return flag ? iblockdata1 : null;
+    }
+
+    public IMaterial getDropType(IBlockData iblockdata, World world, BlockPosition blockposition, int i) {
+        return Items.AIR;
+    }
+
+    public void a(World world, EntityHuman entityhuman, BlockPosition blockposition, IBlockData iblockdata, @Nullable TileEntity tileentity, ItemStack itemstack) {
+        if (!world.isClientSide && itemstack.getItem() == Items.SHEARS) {
+            entityhuman.b(StatisticList.BLOCK_MINED.b(this));
+            entityhuman.applyExhaustion(0.005F);
+            a(world, blockposition, new ItemStack(Blocks.VINE));
+        } else {
+            super.a(world, entityhuman, blockposition, iblockdata, tileentity, itemstack);
+        }
+
+    }
+
+    public TextureType c() {
+        return TextureType.CUTOUT;
+    }
+
+    protected void a(BlockStateList.a<Block, IBlockData> blockstatelist_a) {
+        blockstatelist_a.a(BlockVine.UP, BlockVine.NORTH, BlockVine.EAST, BlockVine.SOUTH, BlockVine.WEST);
+    }
+
+    public IBlockData a(IBlockData iblockdata, EnumBlockRotation enumblockrotation) {
+        switch (enumblockrotation) {
+        case CLOCKWISE_180:
+            return (IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) iblockdata.set(BlockVine.NORTH, iblockdata.get(BlockVine.SOUTH))).set(BlockVine.EAST, iblockdata.get(BlockVine.WEST))).set(BlockVine.SOUTH, iblockdata.get(BlockVine.NORTH))).set(BlockVine.WEST, iblockdata.get(BlockVine.EAST));
+        case COUNTERCLOCKWISE_90:
+            return (IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) iblockdata.set(BlockVine.NORTH, iblockdata.get(BlockVine.EAST))).set(BlockVine.EAST, iblockdata.get(BlockVine.SOUTH))).set(BlockVine.SOUTH, iblockdata.get(BlockVine.WEST))).set(BlockVine.WEST, iblockdata.get(BlockVine.NORTH));
+        case CLOCKWISE_90:
+            return (IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) iblockdata.set(BlockVine.NORTH, iblockdata.get(BlockVine.WEST))).set(BlockVine.EAST, iblockdata.get(BlockVine.NORTH))).set(BlockVine.SOUTH, iblockdata.get(BlockVine.EAST))).set(BlockVine.WEST, iblockdata.get(BlockVine.SOUTH));
+        default:
+            return iblockdata;
+        }
+    }
+
+    public IBlockData a(IBlockData iblockdata, EnumBlockMirror enumblockmirror) {
+        switch (enumblockmirror) {
+        case LEFT_RIGHT:
+            return (IBlockData) ((IBlockData) iblockdata.set(BlockVine.NORTH, iblockdata.get(BlockVine.SOUTH))).set(BlockVine.SOUTH, iblockdata.get(BlockVine.NORTH));
+        case FRONT_BACK:
+            return (IBlockData) ((IBlockData) iblockdata.set(BlockVine.EAST, iblockdata.get(BlockVine.WEST))).set(BlockVine.WEST, iblockdata.get(BlockVine.EAST));
+        default:
+            return super.a(iblockdata, enumblockmirror);
+        }
+    }
+
+    public static BlockStateBoolean getDirection(EnumDirection enumdirection) {
+        return (BlockStateBoolean) BlockVine.q.get(enumdirection);
+    }
+
+    public EnumBlockFaceShape a(IBlockAccess iblockaccess, IBlockData iblockdata, BlockPosition blockposition, EnumDirection enumdirection) {
+        return EnumBlockFaceShape.UNDEFINED;
+    }
+}

src/main/java/net/minecraft/server/BlockWaterLily.java

@@ -0,0 +1,28 @@
+package net.minecraft.server;
+
+public class BlockWaterLily extends BlockPlant {
+
+    protected static final VoxelShape a = Block.a(1.0D, 0.0D, 1.0D, 15.0D, 1.5D, 15.0D);
+
+    protected BlockWaterLily(Block.Info block_info) {
+        super(block_info);
+    }
+
+    public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
+        super.a(iblockdata, world, blockposition, entity);
+        if (entity instanceof EntityBoat && !org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(entity, blockposition, Blocks.AIR.getBlockData()).isCancelled()) { // CraftBukkit
+            world.setAir(new BlockPosition(blockposition), true);
+        }
+
+    }
+
+    public VoxelShape a(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        return BlockWaterLily.a;
+    }
+
+    protected boolean b(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
+        Fluid fluid = iblockaccess.getFluid(blockposition);
+
+        return fluid.c() == FluidTypes.WATER || iblockdata.getMaterial() == Material.ICE;
+    }
+}

src/main/java/net/minecraft/server/BlockWitherSkull.java

@@ -0,0 +1,116 @@
+package net.minecraft.server;
+
+import java.util.Iterator;
+import javax.annotation.Nullable;
+
+// CraftBukkit start
+import org.bukkit.craftbukkit.util.BlockStateListPopulator;
+import org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason;
+// CraftBukkit end
+
+public class BlockWitherSkull extends BlockSkull {
+
+    private static ShapeDetector c;
+    private static ShapeDetector o;
+
+    protected BlockWitherSkull(Block.Info block_info) {
+        super(BlockSkull.Type.WITHER_SKELETON, block_info);
+    }
+
+    public void postPlace(World world, BlockPosition blockposition, IBlockData iblockdata, @Nullable EntityLiving entityliving, ItemStack itemstack) {
+        super.postPlace(world, blockposition, iblockdata, entityliving, itemstack);
+        TileEntity tileentity = world.getTileEntity(blockposition);
+
+        if (tileentity instanceof TileEntitySkull) {
+            a(world, blockposition, (TileEntitySkull) tileentity);
+        }
+
+    }
+
+    public static void a(World world, BlockPosition blockposition, TileEntitySkull tileentityskull) {
+        if (world.captureBlockStates) return; // CraftBukkit
+        Block block = tileentityskull.getBlock().getBlock();
+        boolean flag = block == Blocks.WITHER_SKELETON_SKULL || block == Blocks.WITHER_SKELETON_WALL_SKULL;
+
+        if (flag && blockposition.getY() >= 2 && world.getDifficulty() != EnumDifficulty.PEACEFUL && !world.isClientSide) {
+            ShapeDetector shapedetector = d();
+            ShapeDetector.ShapeDetectorCollection shapedetector_shapedetectorcollection = shapedetector.a(world, blockposition);
+
+            if (shapedetector_shapedetectorcollection != null) {
+                // CraftBukkit start - Use BlockStateListPopulator
+                BlockStateListPopulator blockList = new BlockStateListPopulator(world);
+                int i;
+
+                for (i = 0; i < 3; ++i) {
+                    TileEntitySkull.a(world, shapedetector_shapedetectorcollection.a(i, 0, 0).getPosition());
+                }
+
+                for (i = 0; i < shapedetector.c(); ++i) {
+                    for (int j = 0; j < shapedetector.b(); ++j) {
+                        blockList.setTypeAndData(shapedetector_shapedetectorcollection.a(i, j, 0).getPosition(), Blocks.AIR.getBlockData(), 2); // CraftBukkit
+                    }
+                }
+
+                BlockPosition blockposition1 = shapedetector_shapedetectorcollection.a(1, 0, 0).getPosition();
+                EntityWither entitywither = EntityTypes.WITHER.create(world); // Paper
+                BlockPosition blockposition2 = shapedetector_shapedetectorcollection.a(1, 2, 0).getPosition();
+
+                entitywither.setPositionRotation((double) blockposition2.getX() + 0.5D, (double) blockposition2.getY() + 0.55D, (double) blockposition2.getZ() + 0.5D, shapedetector_shapedetectorcollection.getFacing().k() == EnumDirection.EnumAxis.X ? 0.0F : 90.0F, 0.0F);
+                entitywither.aQ = shapedetector_shapedetectorcollection.getFacing().k() == EnumDirection.EnumAxis.X ? 0.0F : 90.0F;
+                entitywither.l();
+                // CraftBukkit start
+                if (!world.addEntity(entitywither, SpawnReason.BUILD_WITHER)) {
+                    // Restore drop status from above
+                    for (i = 0; i < 3; ++i) {
+                        TileEntitySkull.setShouldDrop(world, shapedetector_shapedetectorcollection.a(i, 0, 0).getPosition(), true);
+                    }
+                    return;
+                }
+                blockList.updateList();
+                // CraftBukkit end
+                Iterator iterator = world.a(EntityPlayer.class, entitywither.getBoundingBox().g(50.0D)).iterator();
+
+                while (iterator.hasNext()) {
+                    EntityPlayer entityplayer = (EntityPlayer) iterator.next();
+
+                    CriterionTriggers.n.a(entityplayer, (Entity) entitywither);
+                }
+
+                // world.addEntity(entitywither); // CraftBukkit - moved up
+
+                int k;
+
+                for (k = 0; k < 120; ++k) {
+                    world.addParticle(Particles.E, (double) blockposition1.getX() + world.random.nextDouble(), (double) (blockposition1.getY() - 2) + world.random.nextDouble() * 3.9D, (double) blockposition1.getZ() + world.random.nextDouble(), 0.0D, 0.0D, 0.0D);
+                }
+
+                for (k = 0; k < shapedetector.c(); ++k) {
+                    for (int l = 0; l < shapedetector.b(); ++l) {
+                        world.update(shapedetector_shapedetectorcollection.a(k, l, 0).getPosition(), Blocks.AIR);
+                    }
+                }
+
+            }
+        }
+    }
+
+    public static boolean b(World world, BlockPosition blockposition, ItemStack itemstack) {
+        return itemstack.getItem() == Items.WITHER_SKELETON_SKULL && blockposition.getY() >= 2 && world.getDifficulty() != EnumDifficulty.PEACEFUL && !world.isClientSide ? e().a(world, blockposition) != null : false;
+    }
+
+    protected static ShapeDetector d() {
+        if (BlockWitherSkull.c == null) {
+            BlockWitherSkull.c = ShapeDetectorBuilder.a().a("^^^", "###", "~#~").a('#', ShapeDetectorBlock.a(BlockStatePredicate.a(Blocks.SOUL_SAND))).a('^', ShapeDetectorBlock.a(BlockStatePredicate.a(Blocks.WITHER_SKELETON_SKULL).or(BlockStatePredicate.a(Blocks.WITHER_SKELETON_WALL_SKULL)))).a('~', ShapeDetectorBlock.a(MaterialPredicate.a(Material.AIR))).b();
+        }
+
+        return BlockWitherSkull.c;
+    }
+
+    protected static ShapeDetector e() {
+        if (BlockWitherSkull.o == null) {
+            BlockWitherSkull.o = ShapeDetectorBuilder.a().a("   ", "###", "~#~").a('#', ShapeDetectorBlock.a(BlockStatePredicate.a(Blocks.SOUL_SAND))).a('~', ShapeDetectorBlock.a(MaterialPredicate.a(Material.AIR))).b();
+        }
+
+        return BlockWitherSkull.o;
+    }
+}

src/main/java/net/minecraft/server/BossBattleCustom.java

@@ -0,0 +1,230 @@
+package net.minecraft.server;
+
+import com.google.common.collect.Sets;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Set;
+import java.util.UUID;
+
+// CraftBukkit start
+import org.bukkit.boss.KeyedBossBar;
+import org.bukkit.craftbukkit.boss.CraftKeyedBossbar;
+// CraftBukkit end
+
+public class BossBattleCustom extends BossBattleServer {
+
+    private final MinecraftKey h;
+    private final Set<UUID> i = Sets.newHashSet();
+    private int j;
+    private int k = 100;
+    // CraftBukkit start
+    private KeyedBossBar bossBar;
+
+    public KeyedBossBar getBukkitEntity() {
+        if (bossBar == null) {
+            bossBar = new CraftKeyedBossbar(this);
+        }
+        return bossBar;
+    }
+    // CraftBukkit end
+
+    public BossBattleCustom(MinecraftKey minecraftkey, IChatBaseComponent ichatbasecomponent) {
+        super(ichatbasecomponent, BossBattle.BarColor.WHITE, BossBattle.BarStyle.PROGRESS);
+        this.h = minecraftkey;
+        this.setProgress(0.0F);
+    }
+
+    public MinecraftKey getKey() {
+        return this.h;
+    }
+
+    public void addPlayer(EntityPlayer entityplayer) {
+        super.addPlayer(entityplayer);
+        this.i.add(entityplayer.getUniqueID());
+    }
+
+    public void a(UUID uuid) {
+        this.i.add(uuid);
+    }
+
+    public void removePlayer(EntityPlayer entityplayer) {
+        super.removePlayer(entityplayer);
+        this.i.remove(entityplayer.getUniqueID());
+    }
+
+    public void b() {
+        super.b();
+        this.i.clear();
+    }
+
+    public int c() {
+        return this.j;
+    }
+
+    public int d() {
+        return this.k;
+    }
+
+    public void a(int i) {
+        this.j = i;
+        this.setProgress(MathHelper.a((float) i / (float) this.k, 0.0F, 1.0F));
+    }
+
+    public void b(int i) {
+        this.k = i;
+        this.setProgress(MathHelper.a((float) this.j / (float) i, 0.0F, 1.0F));
+    }
+
+    public final IChatBaseComponent e() {
+        return ChatComponentUtils.a(this.j()).a((chatmodifier) -> {
+            chatmodifier.setColor(this.l().a()).setChatHoverable(new ChatHoverable(ChatHoverable.EnumHoverAction.SHOW_TEXT, new ChatComponentText(this.getKey().toString()))).setInsertion(this.getKey().toString());
+        });
+    }
+
+    public boolean a(Collection<EntityPlayer> collection) {
+        Set<UUID> set = Sets.newHashSet();
+        Set<EntityPlayer> set1 = Sets.newHashSet();
+        Iterator iterator = this.i.iterator();
+
+        UUID uuid;
+        boolean flag;
+        Iterator iterator1;
+
+        while (iterator.hasNext()) {
+            uuid = (UUID) iterator.next();
+            flag = false;
+            iterator1 = collection.iterator();
+
+            while (true) {
+                if (iterator1.hasNext()) {
+                    EntityPlayer entityplayer = (EntityPlayer) iterator1.next();
+
+                    if (!entityplayer.getUniqueID().equals(uuid)) {
+                        continue;
+                    }
+
+                    flag = true;
+                }
+
+                if (!flag) {
+                    set.add(uuid);
+                }
+                break;
+            }
+        }
+
+        iterator = collection.iterator();
+
+        EntityPlayer entityplayer1;
+
+        while (iterator.hasNext()) {
+            entityplayer1 = (EntityPlayer) iterator.next();
+            flag = false;
+            iterator1 = this.i.iterator();
+
+            while (true) {
+                if (iterator1.hasNext()) {
+                    UUID uuid1 = (UUID) iterator1.next();
+
+                    if (!entityplayer1.getUniqueID().equals(uuid1)) {
+                        continue;
+                    }
+
+                    flag = true;
+                }
+
+                if (!flag) {
+                    set1.add(entityplayer1);
+                }
+                break;
+            }
+        }
+
+        iterator = set.iterator();
+
+        while (iterator.hasNext()) {
+            uuid = (UUID) iterator.next();
+            Iterator iterator2 = this.getPlayers().iterator();
+
+            while (true) {
+                if (iterator2.hasNext()) {
+                    EntityPlayer entityplayer2 = (EntityPlayer) iterator2.next();
+
+                    if (!entityplayer2.getUniqueID().equals(uuid)) {
+                        continue;
+                    }
+
+                    this.removePlayer(entityplayer2);
+                }
+
+                this.i.remove(uuid);
+                break;
+            }
+        }
+
+        iterator = set1.iterator();
+
+        while (iterator.hasNext()) {
+            entityplayer1 = (EntityPlayer) iterator.next();
+            this.addPlayer(entityplayer1);
+        }
+
+        return !set.isEmpty() || !set1.isEmpty();
+    }
+
+    public NBTTagCompound f() {
+        NBTTagCompound nbttagcompound = new NBTTagCompound();
+
+        nbttagcompound.setString("Name", IChatBaseComponent.ChatSerializer.a(this.title));
+        nbttagcompound.setBoolean("Visible", this.g());
+        nbttagcompound.setInt("Value", this.j);
+        nbttagcompound.setInt("Max", this.k);
+        nbttagcompound.setString("Color", this.l().b());
+        nbttagcompound.setString("Overlay", this.m().a());
+        nbttagcompound.setBoolean("DarkenScreen", this.isDarkenSky());
+        nbttagcompound.setBoolean("PlayBossMusic", this.isPlayMusic());
+        nbttagcompound.setBoolean("CreateWorldFog", this.isCreateFog());
+        NBTTagList nbttaglist = new NBTTagList();
+        Iterator iterator = this.i.iterator();
+
+        while (iterator.hasNext()) {
+            UUID uuid = (UUID) iterator.next();
+
+            nbttaglist.add((NBTBase) GameProfileSerializer.a(uuid));
+        }
+
+        nbttagcompound.set("Players", nbttaglist);
+        return nbttagcompound;
+    }
+
+    public static BossBattleCustom a(NBTTagCompound nbttagcompound, MinecraftKey minecraftkey) {
+        BossBattleCustom bossbattlecustom = new BossBattleCustom(minecraftkey, IChatBaseComponent.ChatSerializer.a(nbttagcompound.getString("Name")));
+
+        bossbattlecustom.setVisible(nbttagcompound.getBoolean("Visible"));
+        bossbattlecustom.a(nbttagcompound.getInt("Value"));
+        bossbattlecustom.b(nbttagcompound.getInt("Max"));
+        bossbattlecustom.a(BossBattle.BarColor.a(nbttagcompound.getString("Color")));
+        bossbattlecustom.a(BossBattle.BarStyle.a(nbttagcompound.getString("Overlay")));
+        bossbattlecustom.setDarkenSky(nbttagcompound.getBoolean("DarkenScreen"));
+        bossbattlecustom.setPlayMusic(nbttagcompound.getBoolean("PlayBossMusic"));
+        bossbattlecustom.setCreateFog(nbttagcompound.getBoolean("CreateWorldFog"));
+        NBTTagList nbttaglist = nbttagcompound.getList("Players", 10);
+
+        for (int i = 0; i < nbttaglist.size(); ++i) {
+            bossbattlecustom.a(GameProfileSerializer.b(nbttaglist.getCompound(i)));
+        }
+
+        return bossbattlecustom;
+    }
+
+    public void c(EntityPlayer entityplayer) {
+        if (this.i.contains(entityplayer.getUniqueID())) {
+            this.addPlayer(entityplayer);
+        }
+
+    }
+
+    public void d(EntityPlayer entityplayer) {
+        super.removePlayer(entityplayer);
+    }
+}

src/main/java/net/minecraft/server/ChunkCache.java

@@ -0,0 +1,220 @@
+package net.minecraft.server;
+
+import java.util.function.Predicate;
+import javax.annotation.Nullable;
+
+public class ChunkCache implements IIBlockAccess {
+
+    protected int a;
+    protected int b;
+    protected Chunk[][] c;
+    protected boolean d;
+    protected World e;
+
+    public ChunkCache(World world, BlockPosition blockposition, BlockPosition blockposition1, int i) {
+        this.e = world;
+        this.a = blockposition.getX() - i >> 4;
+        this.b = blockposition.getZ() - i >> 4;
+        int j = blockposition1.getX() + i >> 4;
+        int k = blockposition1.getZ() + i >> 4;
+
+        this.c = new Chunk[j - this.a + 1][k - this.b + 1];
+        this.d = true;
+
+        int l;
+        int i1;
+
+        for (l = this.a; l <= j; ++l) {
+            for (i1 = this.b; i1 <= k; ++i1) {
+                this.c[l - this.a][i1 - this.b] = world.getChunkIfLoaded(l, i1); // Paper
+            }
+        }
+
+        for (l = blockposition.getX() >> 4; l <= blockposition1.getX() >> 4; ++l) {
+            for (i1 = blockposition.getZ() >> 4; i1 <= blockposition1.getZ() >> 4; ++i1) {
+                Chunk chunk = this.c[l - this.a][i1 - this.b];
+
+                if (chunk != null && !chunk.b(blockposition.getY(), blockposition1.getY())) {
+                    this.d = false;
+                }
+            }
+        }
+
+    }
+
+    @Nullable
+    public TileEntity getTileEntity(BlockPosition blockposition) {
+        return this.a(blockposition, Chunk.EnumTileEntityState.IMMEDIATE);
+    }
+
+    @Nullable
+    public TileEntity a(BlockPosition blockposition, Chunk.EnumTileEntityState chunk_enumtileentitystate) {
+        int i = (blockposition.getX() >> 4) - this.a;
+        int j = (blockposition.getZ() >> 4) - this.b;
+
+        return this.c[i][j].a(blockposition, chunk_enumtileentitystate);
+    }
+
+    public float A(BlockPosition blockposition) {
+        return this.e.worldProvider.i()[this.getLightLevel(blockposition)];
+    }
+
+    public int d(BlockPosition blockposition, int i) {
+        if (this.getType(blockposition).c(this, blockposition)) {
+            int j = 0;
+            EnumDirection[] aenumdirection = EnumDirection.values();
+            int k = aenumdirection.length;
+
+            for (int l = 0; l < k; ++l) {
+                EnumDirection enumdirection = aenumdirection[l];
+                int i1 = this.getLightLevel(blockposition.shift(enumdirection), i);
+
+                if (i1 > j) {
+                    j = i1;
+                }
+
+                if (j >= 15) {
+                    return j;
+                }
+            }
+
+            return j;
+        } else {
+            return this.getLightLevel(blockposition, i);
+        }
+    }
+
+    public WorldProvider o() {
+        return this.e.o();
+    }
+
+    public int getLightLevel(BlockPosition blockposition, int i) {
+        if (blockposition.getX() >= -30000000 && blockposition.getZ() >= -30000000 && blockposition.getX() < 30000000 && blockposition.getZ() <= 30000000) {
+            if (blockposition.getY() < 0) {
+                return 0;
+            } else {
+                int j;
+
+                if (blockposition.getY() >= 256) {
+                    j = 15 - i;
+                    if (j < 0) {
+                        j = 0;
+                    }
+
+                    return j;
+                } else {
+                    j = (blockposition.getX() >> 4) - this.a;
+                    int k = (blockposition.getZ() >> 4) - this.b;
+
+                    return this.c[j][k].a(blockposition, i);
+                }
+            }
+        } else {
+            return 15;
+        }
+    }
+
+    public boolean isChunkLoaded(int i, int j, boolean flag) {
+        return this.a(i, j);
+    }
+
+    public boolean e(BlockPosition blockposition) {
+        return false;
+    }
+
+    public boolean a(int i, int j) {
+        int k = i - this.a;
+        int l = j - this.b;
+
+        return k >= 0 && k < this.c.length && l >= 0 && l < this.c[k].length;
+    }
+
+    public int a(HeightMap.Type heightmap_type, int i, int j) {
+        throw new RuntimeException("NOT IMPLEMENTED!");
+    }
+
+    public WorldBorder getWorldBorder() {
+        return this.e.getWorldBorder();
+    }
+
+    public boolean a(@Nullable Entity entity, VoxelShape voxelshape) {
+        throw new RuntimeException("This method should never be called here. No entity logic inside Region");
+    }
+
+    @Nullable
+    public EntityHuman a(double d0, double d1, double d2, double d3, Predicate<Entity> predicate) {
+        throw new RuntimeException("This method should never be called here. No entity logic inside Region");
+    }
+
+    public IBlockData getType(BlockPosition blockposition) {
+        if (blockposition.getY() >= 0 && blockposition.getY() < 256) {
+            int i = (blockposition.getX() >> 4) - this.a;
+            int j = (blockposition.getZ() >> 4) - this.b;
+
+            if (i >= 0 && i < this.c.length && j >= 0 && j < this.c[i].length) {
+                Chunk chunk = this.c[i][j];
+
+                if (chunk != null) {
+                    return chunk.getType(blockposition);
+                }
+            }
+        }
+
+        return Blocks.AIR.getBlockData();
+    }
+
+    public Fluid getFluid(BlockPosition blockposition) {
+        if (blockposition.getY() >= 0 && blockposition.getY() < 256) {
+            int i = (blockposition.getX() >> 4) - this.a;
+            int j = (blockposition.getZ() >> 4) - this.b;
+
+            if (i >= 0 && i < this.c.length && j >= 0 && j < this.c[i].length) {
+                Chunk chunk = this.c[i][j];
+
+                if (chunk != null) {
+                    return chunk.getFluid(blockposition);
+                }
+            }
+        }
+
+        return FluidTypes.EMPTY.i();
+    }
+
+    public int c() {
+        return 0;
+    }
+
+    public BiomeBase getBiome(BlockPosition blockposition) {
+        int i = (blockposition.getX() >> 4) - this.a;
+        int j = (blockposition.getZ() >> 4) - this.b;
+
+        return this.c[i][j].getBiome(blockposition);
+    }
+
+    public boolean isEmpty(BlockPosition blockposition) {
+        return this.getType(blockposition).isAir();
+    }
+
+    public int getBrightness(EnumSkyBlock enumskyblock, BlockPosition blockposition) {
+        if (blockposition.getY() >= 0 && blockposition.getY() < 256) {
+            int i = (blockposition.getX() >> 4) - this.a;
+            int j = (blockposition.getZ() >> 4) - this.b;
+
+            return this.c[i][j].getBrightness(enumskyblock, blockposition);
+        } else {
+            return enumskyblock.c;
+        }
+    }
+
+    public int a(BlockPosition blockposition, EnumDirection enumdirection) {
+        return this.getType(blockposition).b((IBlockAccess) this, blockposition, enumdirection);
+    }
+
+    public boolean e() {
+        throw new RuntimeException("Not yet implemented");
+    }
+
+    public int getSeaLevel() {
+        throw new RuntimeException("Not yet implemented");
+    }
+}

src/main/java/net/minecraft/server/ChunkCoordIntPair.java

@@ -0,0 +1,97 @@
+package net.minecraft.server;
+
+public class ChunkCoordIntPair {
+
+    public final int x;
+    public final int z;
+
+    public ChunkCoordIntPair(int i, int j) {
+        this.x = i;
+        this.z = j;
+    }
+
+    public ChunkCoordIntPair(BlockPosition blockposition) {
+        this.x = blockposition.getX() >> 4;
+        this.z = blockposition.getZ() >> 4;
+    }
+
+    public ChunkCoordIntPair(long i) {
+        this.x = (int) i;
+        this.z = (int) (i >> 32);
+    }
+
+    public long asLong() { return a(); } // Paper
+    public long a() {
+        return a(this.x, this.z);
+    }
+
+    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) {
+        return (long) i & 4294967295L | ((long) j & 4294967295L) << 32;
+    }
+
+    public static int a(long i) {
+        return (int) (i & 4294967295L);
+    }
+
+    public static int b(long i) {
+        return (int) (i >>> 32 & 4294967295L);
+    }
+
+    public int hashCode() {
+        int i = 1664525 * this.x + 1013904223;
+        int j = 1664525 * (this.z ^ -559038737) + 1013904223;
+
+        return i ^ j;
+    }
+
+    public boolean equals(Object object) {
+        if (this == object) {
+            return true;
+        } else if (!(object instanceof ChunkCoordIntPair)) {
+            return false;
+        } else {
+            ChunkCoordIntPair chunkcoordintpair = (ChunkCoordIntPair) object;
+
+            return this.x == chunkcoordintpair.x && this.z == chunkcoordintpair.z;
+        }
+    }
+
+    public double a(Entity entity) {
+        double d0 = (double) (this.x * 16 + 8);
+        double d1 = (double) (this.z * 16 + 8);
+        double d2 = d0 - entity.locX;
+        double d3 = d1 - entity.locZ;
+
+        return d2 * d2 + d3 * d3;
+    }
+
+    public int d() {
+        return this.x << 4;
+    }
+
+    public int e() {
+        return this.z << 4;
+    }
+
+    public int f() {
+        return (this.x << 4) + 15;
+    }
+
+    public int g() {
+        return (this.z << 4) + 15;
+    }
+
+    public BlockPosition a(int i, int j, int k) {
+        return new BlockPosition((this.x << 4) + i, j, (this.z << 4) + k);
+    }
+
+    public String toString() {
+        return "[" + this.x + ", " + this.z + "]";
+    }
+
+    public BlockPosition h() {
+        return new BlockPosition(this.x << 4, 0, this.z << 4);
+    }
+}

src/main/java/net/minecraft/server/ChunkGenerator.java

@@ -0,0 +1,45 @@
+package net.minecraft.server;
+
+import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
+import it.unimi.dsi.fastutil.longs.LongSet;
+import java.util.List;
+import javax.annotation.Nullable;
+
+public interface ChunkGenerator<C extends GeneratorSettings> {
+
+    void createChunk(IChunkAccess ichunkaccess);
+
+    void addFeatures(RegionLimitedWorldAccess regionlimitedworldaccess, WorldGenStage.Features worldgenstage_features);
+
+    void addDecorations(RegionLimitedWorldAccess regionlimitedworldaccess);
+
+    void addMobs(RegionLimitedWorldAccess regionlimitedworldaccess);
+
+    List<BiomeBase.BiomeMeta> getMobsFor(EnumCreatureType enumcreaturetype, BlockPosition blockposition);
+
+    @Nullable
+    BlockPosition findNearestMapFeature(World world, String s, BlockPosition blockposition, int i, boolean flag);
+
+    C getSettings();
+
+    int a(World world, boolean flag, boolean flag1);
+
+    boolean canSpawnStructure(BiomeBase biomebase, StructureGenerator<? extends WorldGenFeatureConfiguration> structuregenerator);
+
+    @Nullable
+    WorldGenFeatureConfiguration getFeatureConfiguration(BiomeBase biomebase, StructureGenerator<? extends WorldGenFeatureConfiguration> structuregenerator);
+
+    Long2ObjectMap<StructureStart> getStructureStartCache(StructureGenerator<? extends WorldGenFeatureConfiguration> structuregenerator);
+
+    Long2ObjectMap<LongSet> getStructureCache(StructureGenerator<? extends WorldGenFeatureConfiguration> structuregenerator);
+
+    WorldChunkManager getWorldChunkManager();
+
+    long getSeed();
+
+    int getSpawnHeight();
+
+    int getGenerationDepth();
+
+    World getWorld(); // Spigot
+}

src/main/java/net/minecraft/server/ChunkGeneratorAbstract.java

@@ -0,0 +1,165 @@
+package net.minecraft.server;
+
+import com.google.common.collect.Maps;
+import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
+import it.unimi.dsi.fastutil.longs.Long2ObjectMaps;
+import it.unimi.dsi.fastutil.longs.LongSet;
+import java.util.BitSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Random;
+import javax.annotation.Nullable;
+
+public abstract class ChunkGeneratorAbstract<C extends GeneratorSettings> implements ChunkGenerator<C> {
+
+    protected final GeneratorAccess a;
+    protected final long b;
+    protected final WorldChunkManager c;
+    protected final Map<StructureGenerator<? extends WorldGenFeatureConfiguration>, Long2ObjectMap<StructureStart>> d = Maps.newHashMap();
+    protected final Map<StructureGenerator<? extends WorldGenFeatureConfiguration>, Long2ObjectMap<LongSet>> e = Maps.newHashMap();
+
+    public ChunkGeneratorAbstract(GeneratorAccess generatoraccess, WorldChunkManager worldchunkmanager) {
+        this.a = generatoraccess;
+        this.b = generatoraccess.getSeed();
+        this.c = worldchunkmanager;
+    }
+
+    public void addFeatures(RegionLimitedWorldAccess regionlimitedworldaccess, WorldGenStage.Features worldgenstage_features) {
+        SeededRandom seededrandom = new SeededRandom(this.b);
+        boolean flag = true;
+        int i = regionlimitedworldaccess.a();
+        int j = regionlimitedworldaccess.b();
+        BitSet bitset = regionlimitedworldaccess.getChunkAt(i, j).a(worldgenstage_features);
+
+        for (int k = i - 8; k <= i + 8; ++k) {
+            for (int l = j - 8; l <= j + 8; ++l) {
+                List<WorldGenCarverWrapper<?>> list = regionlimitedworldaccess.getChunkProvider().getChunkGenerator().getWorldChunkManager().getBiome(new BlockPosition(k * 16, 0, l * 16), (BiomeBase) null).a(worldgenstage_features);
+                ListIterator listiterator = list.listIterator();
+
+                while (listiterator.hasNext()) {
+                    int i1 = listiterator.nextIndex();
+                    WorldGenCarverWrapper<?> worldgencarverwrapper = (WorldGenCarverWrapper) listiterator.next();
+
+                    seededrandom.c(regionlimitedworldaccess.getMinecraftWorld().getSeed() + (long) i1, k, l);
+                    if (worldgencarverwrapper.a(regionlimitedworldaccess, seededrandom, k, l, WorldGenFeatureConfiguration.e)) {
+                        worldgencarverwrapper.a(regionlimitedworldaccess, seededrandom, k, l, i, j, bitset, WorldGenFeatureConfiguration.e);
+                    }
+                }
+            }
+        }
+
+    }
+
+    @Nullable
+    public BlockPosition findNearestMapFeature(World world, String s, BlockPosition blockposition, int i, boolean flag) {
+        StructureGenerator<?> structuregenerator = (StructureGenerator) WorldGenerator.aF.get(s.toLowerCase(Locale.ROOT));
+
+        return structuregenerator != null ? structuregenerator.getNearestGeneratedFeature(world, this, blockposition, i, flag) : null;
+    }
+
+    protected void a(IChunkAccess ichunkaccess, Random random) {
+        BlockPosition.MutableBlockPosition blockposition_mutableblockposition = new BlockPosition.MutableBlockPosition();
+        int i = ichunkaccess.getPos().d();
+        int j = ichunkaccess.getPos().e();
+        Iterator iterator = BlockPosition.a(i, 0, j, i + 16, 0, j + 16).iterator();
+
+        while (iterator.hasNext()) {
+            BlockPosition blockposition = (BlockPosition) iterator.next();
+
+            for (int k = 4; k >= 0; --k) {
+                if (k <= random.nextInt(5)) {
+                    ichunkaccess.setType(blockposition_mutableblockposition.c(blockposition.getX(), k, blockposition.getZ()), Blocks.BEDROCK.getBlockData(), false);
+                }
+            }
+        }
+
+    }
+
+    public void addDecorations(RegionLimitedWorldAccess regionlimitedworldaccess) {
+        BlockFalling.instaFall = true;
+        int i = regionlimitedworldaccess.a();
+        int j = regionlimitedworldaccess.b();
+        int k = i * 16;
+        int l = j * 16;
+        BlockPosition blockposition = new BlockPosition(k, 0, l);
+        BiomeBase biomebase = regionlimitedworldaccess.getChunkAt(i + 1, j + 1).getBiomeIndex()[0];
+        SeededRandom seededrandom = new SeededRandom();
+        long i1 = seededrandom.a(regionlimitedworldaccess.getSeed(), k, l);
+        WorldGenStage.Decoration[] aworldgenstage_decoration = WorldGenStage.Decoration.values();
+        int j1 = aworldgenstage_decoration.length;
+
+        for (int k1 = 0; k1 < j1; ++k1) {
+            WorldGenStage.Decoration worldgenstage_decoration = aworldgenstage_decoration[k1];
+
+            biomebase.a(worldgenstage_decoration, this, regionlimitedworldaccess, i1, seededrandom, blockposition);
+        }
+
+        BlockFalling.instaFall = false;
+    }
+
+    public void a(IChunkAccess ichunkaccess, BiomeBase[] abiomebase, SeededRandom seededrandom, int i) {
+        double d0 = 0.03125D;
+        ChunkCoordIntPair chunkcoordintpair = ichunkaccess.getPos();
+        int j = chunkcoordintpair.d();
+        int k = chunkcoordintpair.e();
+        double[] adouble = this.a(chunkcoordintpair.x, chunkcoordintpair.z);
+
+        for (int l = 0; l < 16; ++l) {
+            for (int i1 = 0; i1 < 16; ++i1) {
+                int j1 = j + l;
+                int k1 = k + i1;
+                int l1 = ichunkaccess.a(HeightMap.Type.WORLD_SURFACE_WG, l, i1) + 1;
+
+                abiomebase[i1 * 16 + l].a(seededrandom, ichunkaccess, j1, k1, l1, adouble[i1 * 16 + l], this.getSettings().r(), this.getSettings().s(), i, this.a.getSeed());
+            }
+        }
+
+    }
+
+    public abstract C getSettings();
+
+    public abstract double[] a(int i, int j);
+
+    public boolean canSpawnStructure(BiomeBase biomebase, StructureGenerator<? extends WorldGenFeatureConfiguration> structuregenerator) {
+        return biomebase.a(structuregenerator);
+    }
+
+    @Nullable
+    public WorldGenFeatureConfiguration getFeatureConfiguration(BiomeBase biomebase, StructureGenerator<? extends WorldGenFeatureConfiguration> structuregenerator) {
+        return biomebase.b(structuregenerator);
+    }
+
+    public WorldChunkManager getWorldChunkManager() {
+        return this.c;
+    }
+
+    public long getSeed() {
+        return this.b;
+    }
+
+    public Long2ObjectMap<StructureStart> getStructureStartCache(StructureGenerator<? extends WorldGenFeatureConfiguration> structuregenerator) {
+        return (Long2ObjectMap) this.d.computeIfAbsent(structuregenerator, (structuregenerator1) -> {
+            return new ExpiringMap<>(8192, 10000); // Paper - already synchronized
+        });
+    }
+
+    public Long2ObjectMap<LongSet> getStructureCache(StructureGenerator<? extends WorldGenFeatureConfiguration> structuregenerator) {
+        return (Long2ObjectMap) this.e.computeIfAbsent(structuregenerator, (structuregenerator1) -> {
+            return new ExpiringMap<>(8192, 10000); // Paper - already synchronized
+        });
+    }
+
+    public int getGenerationDepth() {
+        return 256;
+    }
+
+    // Spigot start
+    @Override
+    public World getWorld() {
+        return this.a.getMinecraftWorld();
+    }
+    // Spigot end
+}

src/main/java/net/minecraft/server/ChunkMap.java

@@ -0,0 +1,142 @@
+package net.minecraft.server;
+
+import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
+import java.util.Map;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+public class ChunkMap extends Long2ObjectOpenHashMap<Chunk> {
+
+    private static final Logger a = LogManager.getLogger();
+
+    public ChunkMap(int i) {
+        super(i);
+    }
+
+    public Chunk put(long i, Chunk chunk) {
+        org.spigotmc.AsyncCatcher.catchOp("Async Chunk put"); // Paper
+        chunk.world.timings.syncChunkLoadPostTimer.startTiming(); // Paper
+        lastChunkByPos = chunk; // Paper
+        // Paper start
+        Chunk chunk1;
+        synchronized (this) {
+            // synchronize so any async gets are safe
+            chunk1 = (Chunk) super.put(i, chunk);
+        }
+        if (chunk1 == null) { // Paper - we should never be overwriting chunks
+        // Paper end
+        ChunkCoordIntPair chunkcoordintpair = new ChunkCoordIntPair(i);
+
+        for (int j = chunkcoordintpair.x - 1; j <= chunkcoordintpair.x + 1; ++j) {
+            for (int k = chunkcoordintpair.z - 1; k <= chunkcoordintpair.z + 1; ++k) {
+                if (j != chunkcoordintpair.x || k != chunkcoordintpair.z) {
+                    long l = ChunkCoordIntPair.a(j, k);
+                    Chunk chunk2 = (Chunk) super.get(l);  // Paper - use super to avoid polluting last access cache
+
+                    if (chunk2 != null) {
+                        chunk.H();
+                        chunk2.H();
+                    }
+                }
+            }
+        }
+
+        // CraftBukkit start
+        // Update neighbor counts
+        for (int x = -2; x < 3; x++) {
+            for (int z = -2; z < 3; z++) {
+                if (x == 0 && z == 0) {
+                    continue;
+                }
+
+                Chunk neighbor = super.get(ChunkCoordIntPair.a(chunkcoordintpair.x + x, chunkcoordintpair.z + z)); // Paper - use super to avoid polluting last access cache
+                if (neighbor != null) {
+                    neighbor.setNeighborLoaded(-x, -z);
+                    chunk.setNeighborLoaded(x, z);
+                }
+            }
+            // Paper start
+        } } else {
+            a.error("Overwrote existing chunk! (" + chunk.world.getWorld().getName() + ":" + chunk.locX+"," + chunk.locZ + ")", new IllegalStateException());
+        }
+        // Paper end
+        // Paper start - if this is a spare chunk (not part of any players view distance), go ahead and queue it for unload.
+        if (!((WorldServer)chunk.world).getPlayerChunkMap().isChunkInUse(chunk.locX, chunk.locZ)) {
+            if (chunk.world.paperConfig.delayChunkUnloadsBy > 0) {
+                chunk.scheduledForUnload = System.currentTimeMillis();
+            } else {
+                ((WorldServer) chunk.world).getChunkProvider().unload(chunk);
+            }
+        }
+        // Paper end
+        chunk.world.timings.syncChunkLoadPostTimer.stopTiming(); // Paper
+        // CraftBukkit end
+
+        return chunk1;
+    }
+
+    public Chunk put(Long olong, Chunk chunk) {
+        return MCUtil.ensureMain("Chunk Put", () -> this.put(olong.longValue(), chunk)); // Paper
+    }
+
+    public Chunk remove(long i) {
+        // Paper start
+        org.spigotmc.AsyncCatcher.catchOp("Async Chunk remove");
+        Chunk chunk;
+        synchronized (this) {
+            // synchronize so any async gets are safe
+            chunk = super.remove(i);
+        }
+        if (chunk != null) { // Paper - don't decrement if we didn't remove anything
+        // Paper end
+        ChunkCoordIntPair chunkcoordintpair = new ChunkCoordIntPair(i);
+
+        for (int j = chunkcoordintpair.x - 1; j <= chunkcoordintpair.x + 1; ++j) {
+            for (int k = chunkcoordintpair.z - 1; k <= chunkcoordintpair.z + 1; ++k) {
+                if (j != chunkcoordintpair.x || k != chunkcoordintpair.z) {
+                    Chunk chunk1 = (Chunk) super.get(ChunkCoordIntPair.a(j, k)); // Paper - use super to avoid polluting last access cache
+
+                    if (chunk1 != null) {
+                        chunk1.I();
+                    }
+                }
+            }
+        }
+
+        // Paper start
+        } // close if (chunk != null)
+        if (lastChunkByPos != null && i == lastChunkByPos.chunkKey) {
+            lastChunkByPos = null;
+        }
+        return chunk;
+    }
+    private Chunk lastChunkByPos = null;
+
+    @Override
+    public Chunk get(long l) {
+        if (MCUtil.isMainThread()) {
+            if (lastChunkByPos != null && l == lastChunkByPos.chunkKey) {
+                return lastChunkByPos;
+            }
+            final Chunk chunk = super.get(l);
+            return chunk != null ? (lastChunkByPos = chunk) : null;
+        } else {
+            synchronized (this) {
+                return super.get(l);
+            }
+        }
+    }
+    // Paper end
+
+    public Chunk remove(Object object) {
+        return MCUtil.ensureMain("Chunk Remove", () -> this.remove(((Long) object).longValue())); // Paper
+    }
+
+    public void putAll(Map<? extends Long, ? extends Chunk> map) {
+        throw new RuntimeException("Not yet implemented");
+    }
+
+    public boolean remove(Object object, Object object1) {
+        throw new RuntimeException("Not yet implemented");
+    }
+}

src/main/java/net/minecraft/server/ChunkProviderGenerate.java

@@ -0,0 +1,274 @@
+package net.minecraft.server;
+
+import java.util.List;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+public class ChunkProviderGenerate extends ChunkGeneratorAbstract<GeneratorSettingsOverworld> {
+
+    private static final Logger f = LogManager.getLogger();
+    private final NoiseGeneratorOctaves g;
+    private final NoiseGeneratorOctaves h;
+    private final NoiseGeneratorOctaves i;
+    private final NoiseGenerator3 j;
+    private final GeneratorSettingsOverworld k;
+    private final NoiseGeneratorOctaves l;
+    private final NoiseGeneratorOctaves m;
+    private final WorldType n;
+    private final float[] o;
+    private final MobSpawnerPhantom p = new MobSpawnerPhantom();
+    private final IBlockData q;
+    private final IBlockData r;
+
+    public ChunkProviderGenerate(GeneratorAccess generatoraccess, WorldChunkManager worldchunkmanager, GeneratorSettingsOverworld generatorsettingsoverworld) {
+        super(generatoraccess, worldchunkmanager);
+        this.n = generatoraccess.getWorldData().getType();
+        SeededRandom seededrandom = new SeededRandom(this.b);
+
+        this.g = new NoiseGeneratorOctaves(seededrandom, 16);
+        this.h = new NoiseGeneratorOctaves(seededrandom, 16);
+        this.i = new NoiseGeneratorOctaves(seededrandom, 8);
+        this.j = new NoiseGenerator3(seededrandom, 4);
+        this.l = new NoiseGeneratorOctaves(seededrandom, 10);
+        this.m = new NoiseGeneratorOctaves(seededrandom, 16);
+        this.o = new float[25];
+
+        for (int i = -2; i <= 2; ++i) {
+            for (int j = -2; j <= 2; ++j) {
+                float f = 10.0F / MathHelper.c((float) (i * i + j * j) + 0.2F);
+
+                this.o[i + 2 + (j + 2) * 5] = f;
+            }
+        }
+
+        this.k = generatorsettingsoverworld;
+        this.q = this.k.r();
+        this.r = this.k.s();
+    }
+
+    public void createChunk(IChunkAccess ichunkaccess) {
+        ChunkCoordIntPair chunkcoordintpair = ichunkaccess.getPos();
+        int i = chunkcoordintpair.x;
+        int j = chunkcoordintpair.z;
+        SeededRandom seededrandom = new SeededRandom();
+
+        seededrandom.a(i, j);
+        BiomeBase[] abiomebase = this.c.getBiomeBlock(i * 16, j * 16, 16, 16);
+
+        ichunkaccess.a(abiomebase);
+        this.a(i, j, ichunkaccess);
+        ichunkaccess.a(HeightMap.Type.WORLD_SURFACE_WG, HeightMap.Type.OCEAN_FLOOR_WG);
+        this.a(ichunkaccess, abiomebase, seededrandom, this.a.getSeaLevel());
+        this.a(ichunkaccess, seededrandom);
+        ichunkaccess.a(HeightMap.Type.WORLD_SURFACE_WG, HeightMap.Type.OCEAN_FLOOR_WG);
+        ichunkaccess.a(ChunkStatus.BASE);
+    }
+
+    public void addMobs(RegionLimitedWorldAccess regionlimitedworldaccess) {
+        int i = regionlimitedworldaccess.a();
+        int j = regionlimitedworldaccess.b();
+        BiomeBase biomebase = regionlimitedworldaccess.getChunkAt(i, j).getBiomeIndex()[0];
+        SeededRandom seededrandom = new SeededRandom();
+
+        seededrandom.a(regionlimitedworldaccess.getSeed(), i << 4, j << 4);
+        SpawnerCreature.a(regionlimitedworldaccess, biomebase, i, j, seededrandom);
+    }
+
+    public void a(int i, int j, IChunkAccess ichunkaccess) {
+        BiomeBase[] abiomebase = this.c.getBiomes(ichunkaccess.getPos().x * 4 - 2, ichunkaccess.getPos().z * 4 - 2, 10, 10);
+        double[] adouble = new double[825];
+
+        this.a(abiomebase, ichunkaccess.getPos().x * 4, 0, ichunkaccess.getPos().z * 4, adouble);
+        BlockPosition.MutableBlockPosition blockposition_mutableblockposition = new BlockPosition.MutableBlockPosition();
+
+        for (int k = 0; k < 4; ++k) {
+            int l = k * 5;
+            int i1 = (k + 1) * 5;
+
+            for (int j1 = 0; j1 < 4; ++j1) {
+                int k1 = (l + j1) * 33;
+                int l1 = (l + j1 + 1) * 33;
+                int i2 = (i1 + j1) * 33;
+                int j2 = (i1 + j1 + 1) * 33;
+
+                for (int k2 = 0; k2 < 32; ++k2) {
+                    double d0 = 0.125D;
+                    double d1 = adouble[k1 + k2];
+                    double d2 = adouble[l1 + k2];
+                    double d3 = adouble[i2 + k2];
+                    double d4 = adouble[j2 + k2];
+                    double d5 = (adouble[k1 + k2 + 1] - d1) * 0.125D;
+                    double d6 = (adouble[l1 + k2 + 1] - d2) * 0.125D;
+                    double d7 = (adouble[i2 + k2 + 1] - d3) * 0.125D;
+                    double d8 = (adouble[j2 + k2 + 1] - d4) * 0.125D;
+
+                    for (int l2 = 0; l2 < 8; ++l2) {
+                        double d9 = 0.25D;
+                        double d10 = d1;
+                        double d11 = d2;
+                        double d12 = (d3 - d1) * 0.25D;
+                        double d13 = (d4 - d2) * 0.25D;
+
+                        for (int i3 = 0; i3 < 4; ++i3) {
+                            double d14 = 0.25D;
+                            double d15 = (d11 - d10) * 0.25D;
+                            double d16 = d10 - d15;
+
+                            for (int j3 = 0; j3 < 4; ++j3) {
+                                blockposition_mutableblockposition.c(k * 4 + i3, k2 * 8 + l2, j1 * 4 + j3);
+                                if ((d16 += d15) > 0.0D) {
+                                    ichunkaccess.setType(blockposition_mutableblockposition, this.q, false);
+                                } else if (k2 * 8 + l2 < this.k.w()) {
+                                    ichunkaccess.setType(blockposition_mutableblockposition, this.r, false);
+                                }
+                            }
+
+                            d10 += d12;
+                            d11 += d13;
+                        }
+
+                        d1 += d5;
+                        d2 += d6;
+                        d3 += d7;
+                        d4 += d8;
+                    }
+                }
+            }
+        }
+
+    }
+
+    private void a(BiomeBase[] abiomebase, int i, int j, int k, double[] adouble) {
+        double[] adouble1 = this.m.a(i, k, 5, 5, this.k.x(), this.k.y(), this.k.z());
+        float f = this.k.A();
+        float f1 = this.k.B();
+        double[] adouble2 = this.i.a(i, j, k, 5, 33, 5, (double) (f / this.k.C()), (double) (f1 / this.k.D()), (double) (f / this.k.E()));
+        double[] adouble3 = this.g.a(i, j, k, 5, 33, 5, (double) f, (double) f1, (double) f);
+        double[] adouble4 = this.h.a(i, j, k, 5, 33, 5, (double) f, (double) f1, (double) f);
+        int l = 0;
+        int i1 = 0;
+
+        for (int j1 = 0; j1 < 5; ++j1) {
+            for (int k1 = 0; k1 < 5; ++k1) {
+                float f2 = 0.0F;
+                float f3 = 0.0F;
+                float f4 = 0.0F;
+                boolean flag = true;
+                BiomeBase biomebase = abiomebase[j1 + 2 + (k1 + 2) * 10];
+
+                for (int l1 = -2; l1 <= 2; ++l1) {
+                    for (int i2 = -2; i2 <= 2; ++i2) {
+                        BiomeBase biomebase1 = abiomebase[j1 + l1 + 2 + (k1 + i2 + 2) * 10];
+                        float f5 = this.k.F() + biomebase1.h() * this.k.G();
+                        float f6 = this.k.H() + biomebase1.l() * this.k.I();
+
+                        if (this.n == WorldType.AMPLIFIED && f5 > 0.0F) {
+                            f5 = 1.0F + f5 * 2.0F;
+                            f6 = 1.0F + f6 * 4.0F;
+                        }
+                        // CraftBukkit start - fix MC-54738
+                        if (f5 < -1.8F) {
+                            f5 = -1.8F;
+                        }
+                        // CraftBukkit end
+
+                        float f7 = this.o[l1 + 2 + (i2 + 2) * 5] / (f5 + 2.0F);
+
+                        if (biomebase1.h() > biomebase.h()) {
+                            f7 /= 2.0F;
+                        }
+
+                        f2 += f6 * f7;
+                        f3 += f5 * f7;
+                        f4 += f7;
+                    }
+                }
+
+                f2 /= f4;
+                f3 /= f4;
+                f2 = f2 * 0.9F + 0.1F;
+                f3 = (f3 * 4.0F - 1.0F) / 8.0F;
+                double d0 = adouble1[i1] / 8000.0D;
+
+                if (d0 < 0.0D) {
+                    d0 = -d0 * 0.3D;
+                }
+
+                d0 = d0 * 3.0D - 2.0D;
+                if (d0 < 0.0D) {
+                    d0 /= 2.0D;
+                    if (d0 < -1.0D) {
+                        d0 = -1.0D;
+                    }
+
+                    d0 /= 1.4D;
+                    d0 /= 2.0D;
+                } else {
+                    if (d0 > 1.0D) {
+                        d0 = 1.0D;
+                    }
+
+                    d0 /= 8.0D;
+                }
+
+                ++i1;
+                double d1 = (double) f3;
+                double d2 = (double) f2;
+
+                d1 += d0 * 0.2D;
+                d1 = d1 * this.k.J() / 8.0D;
+                double d3 = this.k.J() + d1 * 4.0D;
+
+                for (int j2 = 0; j2 < 33; ++j2) {
+                    double d4 = ((double) j2 - d3) * this.k.K() * 128.0D / 256.0D / d2;
+
+                    if (d4 < 0.0D) {
+                        d4 *= 4.0D;
+                    }
+
+                    double d5 = adouble3[l] / this.k.L();
+                    double d6 = adouble4[l] / this.k.M();
+                    double d7 = (adouble2[l] / 10.0D + 1.0D) / 2.0D;
+                    double d8 = MathHelper.b(d5, d6, d7) - d4;
+
+                    if (j2 > 29) {
+                        double d9 = (double) ((float) (j2 - 29) / 3.0F);
+
+                        d8 = d8 * (1.0D - d9) - 10.0D * d9;
+                    }
+
+                    adouble[l] = d8;
+                    ++l;
+                }
+            }
+        }
+
+    }
+
+    public List<BiomeBase.BiomeMeta> getMobsFor(EnumCreatureType enumcreaturetype, BlockPosition blockposition) {
+        BiomeBase biomebase = this.a.getBiome(blockposition);
+
+        return enumcreaturetype == EnumCreatureType.MONSTER && ((WorldGenFeatureSwampHut) WorldGenerator.l).d(this.a, blockposition) ? WorldGenerator.l.d() : (enumcreaturetype == EnumCreatureType.MONSTER && WorldGenerator.n.b(this.a, blockposition) ? WorldGenerator.n.d() : biomebase.getMobs(enumcreaturetype));
+    }
+
+    public int a(World world, boolean flag, boolean flag1) {
+        byte b0 = 0;
+        int i = b0 + this.p.a(world, flag, flag1);
+
+        return i;
+    }
+
+    public GeneratorSettingsOverworld getSettings() {
+        return this.k;
+    }
+
+    public double[] a(int i, int j) {
+        double d0 = 0.03125D;
+
+        return this.j.a((double) (i << 4), (double) (j << 4), 16, 16, 0.0625D, 0.0625D, 1.0D);
+    }
+
+    public int getSpawnHeight() {
+        return this.a.getSeaLevel() + 1;
+    }
+}